Torvalds and the mirror

Two days ago a long argument played out on the linux-media mailing list. The nominal topic was a plumbing question — should Patchwork link up with Sashiko, an LLM tool meant to help maintainers triage patches — but underneath it was the argument the whole industry is having: should a serious open-source project let generative AI anywhere near its review process at all. It escalated, as these things do, into an ethical standoff. And Linus Torvalds stepped in three times to put his foot down.

I read the three messages and felt something I want to be careful about. It is easy, when someone with a big name says the thing you have been saying, to reach for it as a trophy. That is not why these are worth writing about. They are worth writing about because of where they come from. Torvalds is not a founder with equity in a model company, not an influencer with a launch to time. His day job, for thirty-plus years, has been reading other people’s code and deciding what goes into the most consequential open-source project on earth. When that person talks about what AI review is actually like, he is reporting from the workbench. That is a different kind of sentence than a take.

Point at the mirror

Here is the line that stopped me:

And no, AI isn’t perfect. But Christ, anybody who points to the problems at AI had better be looking in the mirror and pointing at themselves at the same time. Because it’s not like natural intelligence is always all that great either.

I have written this argument before, at more length and more respectfully, in The immaculate programmer. The move I was trying to name there is what I called the asymmetry of scrutiny: when a model ships a bug, it gets captured, quoted, and circulated as proof the tool is useless; when a person ships the same bug, it is a Tuesday. The whole discipline of software — code review, linters, tests, CI gates, blameless postmortems — exists because we assume competent, careful humans ship exactly those bugs. The immaculate programmer who never would has never been on any team I have been on. We don’t protect ourselves against them. We protect ourselves against us.

What I could only assert from observation, Torvalds says from the trenches. In the second message he is blunter still about the human half of the comparison:

AI reports are not always great, but neither are human reviews. I see less useful reviews by humans where I go “did this person just try to get his name in the commit log, because that has no useful content”.

That is the rigged comparison I wrote about, dismantled by the person who does the comparing for a living. The honest test was never AI-alone against an idealized human. It is a process managed with AI against a process managed with humans, and both catch bugs downstream, because that is what the process is for.

Superior, not just different

The same message pushes further than I did, and I want to sit with the part that is uncomfortable rather than flattering. Torvalds does not settle for “AI review is a different signal.” He says it is often a better one:

The AI generated reports are usually much superior and more flexible. They aren’t just syntax highlighters or reporting “this doesn’t build”, they actually find real non-trivial problems.

He is careful not to oversell it. He keeps the zero-day bot — it reports what won’t build or boot — because a hard, clear signal has its own value. And he is honest that the tool hurts: AI, he says, “can also be a somewhat painful tool,” partly because “it keeps finding embarrassing bugs.” That is the note I keep insisting on and that the loudest optimists skip. He is not putting his head in the sand and singing La La La. He grants the pain and refuses to let it be the argument.

His prescription is the one this blog keeps circling: not to keep the tool out, but to do the work that makes it help instead of hurt. He points out that checkpatch — the kernel’s own linter — took years of maintainer effort to massage into something that adds more value than pain, “and that’s exactly the kind of effort we need for Sashiko and friends.” Automate the typing; keep engineering the process around it. The human who does that work is not being displaced. He is doing the part that was always the job.

The flattery we both refuse

There is one more convergence, and it is the one I find most reassuring, because it is the failure mode the credulous version of this story ignores. Torvalds’ personal annoyance with the models is not that they are too critical. It is that they are not critical enough:

My own personal annoyance was how eager to please AI models tend to be at least by default. […] I was looking for more critical review of the code, not an AI that had been taught to say “You are entirely right” just to please people.

I wrote a whole piece against the version of “augmentation” that is really this — I don’t want an AI that needs me less — where the tell is a human who reviews the model’s output at the model’s speed and rubber-stamps it. That is not augmentation; it is theater. Torvalds is describing the same trap from the model’s side: a tool tuned to please is a tool that has stopped reviewing. Both of us want the same thing from the machine, and it is the opposite of applause.

Where Linus cuts before I would

I said I would mark the friction honestly, so here it is. In the third message, answering a developer who argued there is no ethical justification for generative AI in open source, Torvalds shuts the door:

If you don’t have technical reasons, you don’t have reasons. […] So keep your ethics where they belong — in your personal life. Don’t try to enforce your ethics on others.

On the governing question I think he is right, and it is the same criterion I used in When tribalism drowns the debate: a project decides on technical merit, not on which flag you fly. But this is also where he cuts before I would. In The immaculate programmer I spent a whole section conceding that a lot of what reads as technical objection is a profession in mourning — people who built identities on a craft, watching the ground move — and that the grief is real and deserves to be taken seriously. Torvalds gives that no room inside the decision. And he is not wrong to: he is governing a project, and his job is to shield the technical decision from noise. Mine is different. I get to look at the person.

So I hold both. The grief is not a quality argument — a mourning craft measuring the machine against a programmer who never existed is not doing analysis, it is a feeling that learned to talk like one. But “the grief is not an argument” is not the same sentence as “the grief does not matter.” Torvalds is answering the first. I still want to answer the second, somewhere the merit decision isn’t riding on it.

Coda: the origin, not the applause

Why does his voice land differently than one more hot take? Not because he is Linus — that would be the authority fallacy, and it is exactly the move I have spent these posts arguing against. It lands because of how he formed the opinion. He tells the skeptic to go try one of the good models, on something fun and low-stakes, and judge for himself:

It’s what I did, because I wanted to judge things based on real use, not on what others say (and sometimes the loudest ones do it for marketing reasons because they have stock that is tied to it).

That is the whole thing. The same test I applied to Andrew Kelley in the tribalism piece — is the claim anchored to a verifiable fact, or to the author’s biography — is the one Torvalds applies to himself. His position on AI is anchored to the workbench: real use, real patches, embarrassing bugs and all. Not to the crowd, and pointedly not to the people talking their book.

So no, I don’t read these three messages as a great man handing me a verdict. I read them as two people looking at the same workbench — the one where you review other people’s code — and arriving at the same place from it. That convergence is worth something precisely because it did not come from applause. It came from the work.