On July 15, 2026, Linux creator Linus Torvalds sent a sharply worded email to the developer mailing list. He demanded the community accept an AI review tool called Sashiko — one that automatically checks code patches and helps developers catch potential bugs. Linus even laid down a hard line: Linux “is not an anti-AI project,” and anyone who wouldn’t accept it could “fork the codebase, or just leave.”
But veteran maintainer Laurent Pinchart said no — to his face.
Pinchart is a core maintainer of Linux’s media subsystem, with over a decade of contributions. His refusal rested on a calm judgment: AI-generated review comments are often a “hallucination mishmash” — they flag correct code as wrong, wasting human developers’ time on wild-goose chases. The media subsystem had previously tried having Sashiko send review comments straight to developers’ inboxes; the result was that AI’s false warnings drowned out the genuinely useful feedback, creating more work, not less.
The scene is telling: the highest authority in the tech world pitching a new technology to his own community, only to have it thrown back in his face — and the reasons given landed squarely on the holes in his own logic.
”Trust Me” vs. “Show Me the Code” — Whose Double Standard?
What really set Lobsters ablaze was the contradiction Linus displayed in this exchange.
It started with a guide from the Software Freedom Conservancy. The guide suggested: AI-generated code-review comments should first be screened by a human maintainer, confirmed correct, then sent to the patch author; and developers who don’t want AI messages should have their wishes respected.
Linus’s response opened with an emotional appeal. In his own words: “This is where I’m going to plant my feet as a top-level maintainer.” “AI is a tool, and it’s obviously useful.” — essentially, selling it on personal authority.
But after Pinchart refused, Linus pivoted to Linux’s core principle: “We make decisions primarily on technical merit, not out of fear of new tools.”
The community pounced on the contradiction. The top-voted Lobsters comment (78 upvotes) cut straight to it: Linus first tried to sell on personal authority, then, when asked for technical reasons, said “we only look at the technical” — which is itself the textbook double standard. The commenter added a jab: “Appealing to authority is about the most shallow, weakest argument a person can make; invoking Linus’s name doesn’t make a point stronger.”
What made this explode is that it hit the single most central cultural rule Linux has held for over three decades. Linus himself said in 2000 the line now encoded in every programmer’s DNA: “Talk is cheap. Show me the code.” It’s the distillation of an entire engineering philosophy: in Linux’s world, any claim must be backed by visible, tangible, verifiable evidence — no one’s prestige substitutes for that process.
And now the man who said it led with “trust me.”
The Villain: Opaque AI vs. Transparent Open Source
If the contradiction above is “a people problem,” the deeper one is “a problem in the tool’s very DNA.”
The second-highest Lobsters comment (42 upvotes), from user addison, captured something that made many open-source veterans fall silent:
“Everyone makes mistakes. I broadly think Linus is moving in the right direction on open-source governance. And I don’t deny these tools work — on some tasks they’re even better than our existing batch-review approaches. But the scary part is this: both sides are, in a sense, right. The tools really are useful, but LLMs and their derivatives epitomize everything wrong with this industry — and a lot of that is exactly what Linux set out to avoid in the first place.”
That passage is the key to understanding the fight.
Linux was born in 1991. The dominant model then was closed-source commercial software — Microsoft’s Windows, Sun’s Solaris, their source code invisible to the outside world. You didn’t know what the OS was doing; you could only trust the company. When Linus Torvalds started the project in his Helsinki dorm room, one motive was to oppose that opacity: code should be public, decision-making should be public, anyone should be able to see, understand, and audit every line of logic.
That’s why the Linux community treats “code review” with near-religious rigor. When a patch arrives, maintainers review it line by line, challenge every design decision, demand a reason for every change. This process is the central ritual of transparent engineering culture.
And the essence of an LLM sits squarely opposite that tradition. It’s a giant black box — a neural network of billions of parameters, and no one can precisely explain why it produced this output for that input. It offers no reasoning trace, no auditable chain of decisions. You can only “trust” it — or not.
Opaque versus transparent — two fundamentally opposed ways of knowing the world, colliding on the same field.
Linus’s True Feeling: The Pragmatist’s Dilemma
But I don’t want to paint Linus as someone who “betrayed his own ideals.” His actual email shows a more complex position.
He admitted AI “may be a somewhat painful tool, adding to maintainers’ workload while being uncomfortable from the angle of ‘it keeps finding embarrassing bugs.’” He explicitly said “we’re not forcing anyone to use it” — what he opposes is “anyone trying to stop others from using it.”
He also said something that, on a longer historical scale, isn’t absurd: “In the community, we do open source because it produces better technology, not for religious reasons.” “This isn’t some ‘social justice warrior’ project — never was, never will be.”
That last line enraged many. But from Linus’s angle, his logic runs: a tool is a tool; AI is no different in kind from a compiler, a static analyzer, or a code-search tool. A decade ago, when static analyzers first appeared, people said the same — too many false positives, overwhelming maintainers. Now they’re standard procedure. Linus sees the same arc — AI isn’t good enough yet, but it’ll get better, and burying your head and chanting “I can’t hear you” isn’t a solution.
There’s honesty in that position. But the problem is: AI and a compiler really are different in kind. A compiler is deterministic — same input always yields same output, and you can understand exactly how it works. An LLM isn’t. It’s a probabilistic system, its behavior unpredictable, non-reproducible, not fully auditable.
The trust system Linux built over thirty years rests on “auditability.” Who wrote each line, who reviewed it, why it changed — all public, all traceable. When you inject an unexplainable black box into the review chain, you shake the very foundation of that trust.
The Moment Both Sides Had a Point
I have no intention of picking a side, because both make fair arguments.
Linus’s anxiety is real. The Linux kernel maintainer pool is aging, new blood is thin, and the codebase keeps swelling. He’s said publicly that finding qualified maintainers is “genuinely hard” now. Facing that labor shortage, AI as an assistive tool has undeniable value. As project leader, seeing a chance to lighten the community’s load and pushing for it is understandable.
The community’s resistance is real too. They’re not Luddites — not frightened reactionaries against new tech. They’re the people who’ve hand-maintained the most important software infrastructure on Earth for over twenty years. When they say “AI’s hallucinations add to our workload,” that’s experimental data. The media subsystem tried it; the result was chaos.
A commenter on GamingOnLinux spotted a bigger blind spot: Linus says Linux “was never a social-justice project,” yet after the Russia-Ukraine war he personally removed Russian maintainers from the kernel development team. Isn’t that a values-based, not purely technical, decision?
A “look only at the technical” stance works when the tools in question are technical. But when the tool changes the very nature of technical behavior — an opaque, unexplainable, unauditable system — “look only at the technical” may itself be insufficient.
Not Over Yet
The debate closed, for now, on Linus’s forceful note. His authority as top-level maintainer remains unshaken. But the community wasn’t truly convinced — the 145 points and 134 comments on Lobsters show the discussion is far from finished.
More interestingly, the Godot game engine recently updated its contribution policy, explicitly banning AI-generated code submissions. The RPCS3 emulator team made a similar call — telling developers to “stop submitting AI code you don’t yourself understand.” The open-source world is splitting into two camps: one embracing AI as an irreversible trend, the other drawing boundaries to defend the baseline of human auditability.
Linux’s little storm isn’t an isolated incident. It’s one local eruption of a larger historical question: when a community built on transparency meets a tool that is fundamentally opaque — which one changes the other?
Linus’s answer: the community should adapt to AI.
But thirty-three years ago, when he typed the first line of Linux in his dorm, his answer used to be: a community should trust nothing it can’t see.
References
- Phoronix: “Linus Torvalds Reaffirms That Linux Is Not ‘Anti-AI’” — quotes Linus Torvalds’s full LKML email
- Neowin: “‘Fork it or leave’: Linus Torvalds fires back at Linux’s anti-AI crowd” — background on Sashiko’s failed experiment
- Lobsters: “Linus Torvalds on LLM usage in kernel development” (145 points / 134 comments) — sharp criticism of the double standard and addison’s key comment
- XenoSpectrum: “Linux Declares It Won’t Reject AI” — breakdown of Sashiko’s workflow table and the meaning of its 53.6% self-rated accuracy
- Banandre: “Linus Torvalds to AI Critics: Fork Linux or Walk Away” — Reddit reaction and Linus’s prior anti-AI statements
- LKML original email (lore.kernel.org) — the direct exchange between Linus Torvalds and Laurent Pinchart
