For the past two years, a loud, chronically online faction of tech purity testers has treated artificial intelligence as a personal existential insult. Across social media, self-appointed programming purists have spent countless hours screeching into the void that Large Language Models are "a fraudulent bubble," that generative tools produce only "slop," and that "no real software engineer with self-respect would ever touch AI." They formed dogmatic little digital picket lines, smugly convinced that the high priests of real computer science would forever banish AI from the sacred temple of systems programming.
Then Linus Torvalds logged on and pushed a branch named noref-filemap-read-with-llm directly to the official Linux kernel repository.
Yes, that Linus Torvalds. The creator of Linux and Git. The legendary architect who has spent thirty-five years publicly shredding sloppy code, eviscerating corporate buzzwords, and holding the global computing stack to the most uncompromising engineering standards in human history. Not only did the bossman explicitly credit an LLM coding assistant (Anthropic's Claude Code) with helping him research, generate, test, and write the patch series—the synthetic benchmark on his machine clocked a staggering 23x performance improvement in page cache contention.
The collective coping and seething across the anti-AI brigade was audible from space.
Shut Up, or Throw Away Your Devices
Here is the reality that the anti-AI dogmatists now have to swallow: the debate is over. You lost.
Linux is not a hobbyist framework. Linux is the operating system that runs the modern world. It powers:
- 100% of the world’s top 500 supercomputers.
- Over 70% of all internet web servers and cloud infrastructure.
- Over 3 billion active Android smartphones.
- The avionics of commercial airliners, the onboard telemetry of modern electric vehicles, the international banking backbone, and Valve's Steam Deck.
If you are one of those sanctimonious keyboard crusaders who swore on their mechanical keyboard that you would "never run software touched by AI," you have exactly two choices left: either shut your mouth and accept reality, or toss your smartphone, your PC, your router, your smart TV, and your cloud subscriptions into the nearest recycling bin.
Because every single time you tap a screen, load a webpage, stream a video, or send an encrypted text, your packets are traveling through a kernel that the man who built it is now actively refining with artificial intelligence.
Inside the Patch: Demolishing a 20-Year Bottleneck
True to form, Linus did not use AI to generate boilerplate garbage. He used it to attack a notoriously thorny, low-level architectural problem in the Linux page cache that has tortured kernel engineers for decades.
The issue stems from multi-threaded I/O contention. When multiple CPU cores execute rapid, repeated small reads (such as 16-byte pread() calls) against the same cached file, the kernel must continuously manipulate the reference count of the underlying memory pages (folios). In high-concurrency environments, this causes massive cache-line bouncing and CPU stall cycles across memory buses.
Working in lockstep with the LLM, Torvalds designed an RCU-based lockless fast path to safely bypass folio reference counting during read operations. To validate the concept, Linus used the AI tool to draft specialized user-space microbenchmarks and multi-threaded stress tests.
The result in synthetic testing? In extreme multi-threaded read scenarios on Linus's high-core-count workstation, the fast path avoided reference count locks entirely, yielding up to a 23x spike in reads per second. While Torvalds was careful to note that real-world application workloads would see far more modest gains, the proof of concept proved that AI-assisted tooling can navigate the deepest trenches of OS kernel design.
Pragmatism vs. Ideological Luddism
Why did Linus embrace AI while social media pundits wept? Because Linus Torvalds is an engineer, not a religious zealot.
Throughout his entire career, Linus has held a singular, ruthless philosophy: does it solve the problem, and is the code good?
- When the purists complained about bringing Rust into the C-dominated kernel, Linus greenlit it because memory safety matters.
- When critics whined about Git's command-line ergonomics in 2005, Linus ignored them because distributed version control worked.
- And when the Linux kernel mailing list erupted in predictable panics over AI, Linus issued clear, pro-AI directives to maintainers: treat AI like any other tool. Compilers, static analyzers, and debuggers didn't destroy programming; they made programmers more capable.
As Linus noted in earlier interviews, the tech industry is plagued by hype cycles and anti-hype counter-reactions. While Silicon Valley venture capitalists treat AI like magical pixie dust that will replace every human worker tomorrow, the anti-AI crowd reacted with equal and opposite absurdity—pretending that LLMs are completely useless toys that cannot write a functional for-loop.
Linus cut right through both delusions. An LLM is not a magic god, nor is it a useless calculator. It is a hyper-accelerated junior collaborator and research assistant that, when driven by a master architect who understands exactly what he wants, can eliminate hours of tedious prototyping and expose optimizations that might have taken weeks to hand-craft.
How Real Open Source Works: The Community Catches the Race
The most instructive part of this entire saga wasn't the AI patch itself; it was what happened next on the Linux Kernel Mailing List.
Shortly after Torvalds shared the experimental branch, veteran kernel maintainers reviewed the implementation and identified a subtle race condition in the lockless folio dereference path under specific concurrent truncation events. Did Linus throw a tantrum? Did the community declare AI dead? No. Linus acknowledged the race, and the maintainers began refining the synchronization barriers.
That is how open-source software has worked for thirty years.
AI does not bypass peer review. AI does not get a free pass into mainline Git commits. Code submitted to the Linux kernel is subjected to the most brutal, unforgiving human inspection on Earth. If code has bugs, it gets rejected. If code is brilliant, it gets merged. The source of the keystrokes—whether typed by hand at 2:00 AM on a caffeine bender or generated via a prompt to an LLM—is utterly irrelevant to the compiler.
Welcome to the Vibe-Coded Reality
The romantic myth of the lone, isolated coder writing millions of lines of pure, untainted assembly in a dark room was always largely a fantasy. Modern computing has always been built on layers of abstraction: high-level languages, optimizing compilers, third-party libraries, and automated test suites.
LLM-assisted development is simply the next layer of that abstraction.
So to the vocal social media minority still clinging to their anti-AI purity pledges: take a long, hard look in the mirror. You are running an operating system maintained by engineers who use AI. You are browsing the web through infrastructure optimized by AI. And the man who created the foundation of your digital life just proved that your ideological resistance is nothing more than historical background noise.
AI is here. It works. Even Linus Torvalds is using it. Cope accordingly.