A few months back I wrote about why I think making software cheap won't give us less of it but a lot more*, and I still think that's where this is headed. What's nagging at me now is the question that comes right after you accept the abundance: what happens when we produce software faster than we can select it?

Boris Cherny*, who is the guy who built Claude Code and so makes one of the machines in this story, said in February that the closest thing he can find in history is the printing press. Turns out that in mid-fifteenth-century Europe under one percent of people could read, scribes did the copying, and "in the 50 years after the printing press was built, there was more printed material created than in the thousand years before." Fair enough. But the analogy falls short right at the most interesting spot. The press neither wrote the books nor read them: it multiplied what one author had written so that someone else could read it. AI does both. It writes the software and consumes what it writes: libraries, compilers, tests, documentation, protocols. Author, press and reader in the same contraption, and the circuit feeds itself. And that's where Gutenberg stops helping.

For what comes next you need another Englishman, one with a beard. Darwin didn't discover that species change; half the world already suspected that. He discovered the mechanism: variation, selection, inheritance. And the point of the mechanism is that variation, on its own, is not progress. Nearly all mutations are neutral or harmful. What turns noise into adaptation is that most of them don't survive. A circuit that feeds itself without selection doesn't evolve. It goes off, like milk.

Now think about what AI does to software. It blows up the first variable. We'll be able to generate a thousand implementations of a component in an afternoon. What it doesn't blow up, or at least not at the same pace, is the other two. My hunch is we're mixing up two things: AI doesn't necessarily make better software, but it does make more mutations.

There's a case from this summer that tells it better than I can. Bun, a JavaScript runtime, was written in Zig, half a million lines. Jarred Sumner*, its creator, rewrote the whole thing in Rust in eleven days (yes, eleven): up to sixty-four agents working at once, six and a half thousand commits, about a hundred and sixty-five thousand dollars in tokens. A year's work for a small team, done in eleven days by one man and a fleet.

And mind the detail that matters: the review was done by agents too, with a single instruction, "find bugs & reasons why the code does not work," and it passed one hundred percent of the test suite before being merged. Paul Dix*, who founded InfluxData and has spent years keeping a database running in production, used it in August as proof that we've reached the end of programming as we knew it: most of the code "won't have been written or even read by humans," and what's left for humans is reviewing results, not code.

Quite something. But there was a reply, and it came from where it hurts most. Andrew Kelley*, the creator of Zig, the language Bun had just walked out on, answered the next day. He boiled the other side's reasoning down to one line, "the test suite is good enough to catch everything," and handed it back with an edge: if those tests didn't catch the bugs in the Zig, are they going to catch the ones in "1 million lines of unreviewed slop"? Kelley may have his reasons to be sore, and he says so himself, sipping from a mug that reads "It Tastes Like It's Not My Problem Anymore." But the question has teeth. A test suite measures what somebody thought to measure. And nobody read the million lines.

You'll say that's their company, their business. Where it becomes everyone's business is open source, which is, if you think about it, the biggest distributed selection system we ever built. Linux isn't good just because anyone can send a patch. It's good because almost no patch gets in. Maintainers, review, tests, users, forks, reputation: that's selection, done by hand for thirty years. And that system is already feeling the runaway mutation.

GitHub* opened a public discussion in January to acknowledge "the increasing volume of low-quality contributions that is creating significant operational challenges for maintainers": they "fail to follow project guidelines, are frequently abandoned shortly after submission, and are often AI-generated." Among the measures on the table is one that five years ago would have sounded like heresy: letting a project switch off pull requests. A button to close the front door of the open source house.

Debian*, which has been voting on its own rules for thirty years, voted on this one in August: eight options, from banning AI in the Social Contract to waving it through. The middle one won, "responsible use": AI is allowed, but whoever signs has to "understand, review, test, and, where appropriate, modify" what they hand in, and they're encouraged to say they used it. They don't ban the mutation. They regulate who answers for it.

And that reminded me of what DHH*, the creator of Ruby on Rails, wrote when he rode in with the cavalry. In June he said all those barriers against AI-assisted contributions are "a protectionist tale as old as time," that the talk about quality and attribution is an excuse, and that the real motive is "you, your insecurities, and your privileges." That open source spent decades fighting for everyone's right to change software, and now that anyone finally can, it turns out "everyone" never actually meant everyone.

He's largely right about the democratization. But I think he's missing a variable, and it's Darwin's. Sending a patch is close to free. And reviewing it? That still comes out of the maintainer's time, the same time as before. An agent drops ten pull requests on you in the time it takes a maintainer to understand one. That's not democratizing participation. It's shifting the cost of selection onto whoever has the least of it.

And the way out that many already took, and that maybe all of us will end up taking, is Bun's: let the agents do the selecting. If generation is automatic and selection is too, the whole circuit spins with nobody reviewing it. The press writing its own books, printing them and reading them. And that doesn't sit right with me.

It could go well: the agents select, the good stuff accumulates, a better model gets trained on what accumulated, and it generates better. Or it could go badly: selection is weak or everyone skips it, the noise gets through, other projects reuse it, the next model gets trained on the noise, and it generates more noise with more confidence. The diagram looks lovely in both cases, because slop passes the test too. The difference isn't in the AI. It's in whether selection is up to the variation.

And the pessimist gets a good innings here, and I'll grant it. Because "selecting well" hides a problem that more machines don't fix. There's no best organism; there's the one best adapted to a place. Software may well work the same way: SQLite and PostgreSQL are both excellent because they solve different problems. Whatever can be measured, AI will measure ever more cheaply. What can't be measured is what matters here, what we're giving up in exchange, and who takes the blame a few years from now. That doesn't come out of the same code the model just generated.

So I think software engineering isn't left without a trade; it moves, again. Gutenberg didn't end the book trade; it moved it. Anthony Grafton*, who spent years in the print shops of the Renaissance, tells how printing created "a new social type," the corrector, highly educated people doing the job of a modern desk editor, and how the scribe's work, far from disappearing, expanded. Even Trithemius, the abbot who in 1492 wrote a tract in praise of scribes against the press, had it printed two years later, which is why we know it.

If I can generate a thousand versions of something and my job is no longer to produce them, what's left for me? More than there was: designing what tells them apart, the systems that generate them, the tests that matter, the benchmarks that don't get gamed, the rules for what gets in and what doesn't, and who answers for it. In Darwin's terms, AI brings the variation and we have to bring the selection. With one difference biology doesn't have, and it's all ours: we design the selection knowingly, and if we design it badly, what survives is whatever games the test best.

Gutenberg explains the abundance. Darwin explains what comes next. And what comes next is that, for the first time, the press writes and reads its own books, and the one thing it doesn't do is decide which ones go in the libraries. Or does it? That ought to be on us.