Nat Knight

#link #ai

Laurie Voss hypothesizes that rather than driving all software developers out of a job, the rise of generative LLMs and “vibe coding” will result in more overall software development jobs, but that they will look different than the ones that currently exist.

The argument goes roughly:

• LLMs are a new layer of abstraction for writing programs
• New layers of abstraction create new kinds of programmers who don't think as much about layers lower on the stack
• There's lots of unmet demand for software development
• Developers who can “vibe code” to meet this need will be numerous, productive, and decently paid (though perhaps not well compensated as developers in 2025).

He also argues that overall demand for software development will go up as it gets cheaper, so salaries for current developers won't really be impacted.

While I have a couple of quibbles, I like this a lot! I think “AI is a new level of abstraction” is a much more useful take than “all code will be written by AI” or “AI is useless and will go away”. The idea of a software engineer who doesn't really know how to code is very strange, but I can sort of see how it would work with the right tools. You would need a bunch of knowledge about protocols, databases, architecture, etc. that previously would have been inaccessible to someone who doesn't code, but that's changed now.

I'm not sure I buy the “salaries won't go down” component. We've witnessed fifty years of capital rapaciously sucking up every grain of surplus profit it can, so if there's a way that LLMs could be used to undermine software developers' bargaining power re: the cost of their labour I bet someone will find it, or at least try hard enough that it will be a bad time, at least in the short term.

With all the AI hype flying around leaders who (for example)

• replace their staff with AI agents
• create a class of “vibe coders” whose salaries are anchored lower
• buy AI licenses for their favourite half of the engineering team and lay off the other half

will be lionized as bold and forward thinking, at least until the negative consequences of these actions start to crop up. I think they will crop up, because more code means more tech debt, and with fewer people building theories you're going to hit that wall sooner or later, but the owning class and their lackeys can remain irrational way longer than it takes to erode your salary.

#web #hypertext

Or “how you can link to arbitrary text on a webpage”.

The syntax is a little weird, but you can add a specially formatted anchor to a URL to link to a snippet of text.

The syntax is:

https://example.com#:~:text=[prefix-,]textStart[,textEnd][,-suffix]

I find it particularly useful for linking to a quote in a longer article.

See MDN for the full documentation.

#til #python #uv

(via epistasis on HN)

Semantic versioning is difficult. Not everyone has the same idea of what “breaking change” means, and depending on your language and tooling “breaking” changes can sneak in despite your best efforts.

One possible mitigation is to record when you resolved your dependencies and ignore anything published after that date. It's crude, and relies on package dependencies not monkeying with stuff that's already been published, but it's easy to understand and you can do it with uv.

It's documented here.

Put a date in your pyproject.toml file and subsequent invocations of uv will ignore anything published after the cutoff:

[tool.uv]
exclude-newer = "2023-10-16T00:00:00Z"

You can also use it in the “inline metadata” format for scripting! From the uv docs:

# /// script
# dependencies = [
#   "requests",
# ]
# [tool.uv]
# exclude-newer = "2023-10-16T00:00:00Z"
# ///

import requests

print(requests.__version__)

This use case seems particularly valuable: if I write a quick script I probably care more about it not breaking than I care about it getting updated dependencies. It's nice that uv offers a way to keep code running rather than forcing me to update it or throw it out.

#links #languagemodels #art #writing

Jamie Brew of Botnik gave a talk at Strange Loop 2023 called Comedy Writing with Small Generative Models.

The talk itself was very entertaining, with musical interludes mashing up “the Beatles” and “Craigslist ads for vehicles”, and while the algorithms were (by Jamie's own admission) pretty straightforward, there was a lot of room for expression in finding good corpuses, mashing them up, and finding fun ways to apply them.

It was an excellent reminder to me that there's an entire world of stuff you can do with computers that isn't commercial, isn't “hard tech” or “cutting edge” but is nevertheless utterly delightful.