▶ YouTube Summaries

• YT :: https://www.youtube.com/watch?v=XFSwfwiM8nk
• Original title :: Linus is so based for this

Theo reacts to a Linux kernel mailing list thread where Linus Torvalds shut down anti-AI objections to Sashiko, an agentic kernel code review tool, declaring that technical merit, not ideology, drives kernel decisions and that anyone who disagrees can "fork it or walk away." Theo uses this as the anchor for a broader argument: AI code review and bug-finding tools have crossed from "slop" to genuinely useful in the last few months, and the best open-source maintainers are the ones adapting fastest, not resisting.

The thread started around Sashiko, a self-contained agentic Linux-kernel-specific code review system that ingests patches from mailing lists or local Git and works with multiple LLM providers. Its maintainers report it catches roughly 53.6% of bugs when tested against the last 1000 upstream commits with fix tags, using Gemini 3.1 Pro (Linus is a known user of Gemini/Antigravity for his own side projects). Theo notes this is notable given 3.1 Pro is a comparatively dated model, and speculates results would likely be stronger with something like Claude or GPT-class models. False positive rate is estimated under 20%, with most flagged issues falling in a gray zone rather than being clearly wrong. Sashiko's own documentation stresses its output is probabilistic and won't reliably reproduce the same findings on repeat runs.

Theo connects this to public comments from Greg Kroah-Hartman, a lead Linux kernel maintainer, who said the quality of AI-generated security/bug reports "went from junk to legit overnight" starting around a month before an article covering it (published in March). Greg couldn't pinpoint the exact cause but confirmed the trend isn't slowing down, and that it applies across open-source projects generally, not just Linux — smaller projects with less review capacity (Theo cites Daniel Stenberg and curl, which stopped paying bug bounties due to AI slop) are hit harder than large, well-staffed projects like the kernel. Theo's own theory: Opus 4.5 saw a surge in real-world enterprise use around November/December of the prior year, and it took a few months for power users building tooling around it to produce downstream effects like better-quality bug reports reaching maintainers. Separately, he mentions a jarring statistic: 432 CVEs were reported in the Linux kernel in a single day recently, framing AI-assisted auditing as now a necessity in an "arms race" sense — if defenders don't use AI to find and fix issues, attackers will use it to exploit them first.

The core of the video is Linus's mailing list response to a maintainer (via a user named Roman) who tried to reframe the Sashiko discussion as a referendum on LLMs generally. Linus states plainly that Linux is not an anti-AI project, that AI is "a tool just like other tools," and that the "is it useful" question is no longer valid to litigate. When a contributor named Laurent argued there is "no ethical justification for the use of generative AI in free and open source development," Linus replied "I guess this is where the discussion ends," comparing personal anti-AI stances to vegetarianism: a valid personal choice that has no claim on binding the rest of the community, and invoking Linux's historical split from the Free Software Foundation's ethics-driven "free software" framing in favor of pragmatic "open source." Linus does acknowledge a real cost: AI-driven bug discovery increases maintainer workload and can be painful ("embarrassing bug" fatigue), but argues the fix is making these tools help maintainers rather than abandoning them.

Theo closes with an extended analogy to TypeScript's adoption history, illustrated by a 2022 exchange with SolidJS creator Ryan Carniato, who after four years of daily TypeScript use still didn't feel the productivity win that Theo swears by. Theo's framing: tools like TypeScript (and now AI) compress the quality distribution of a codebase by raising the floor a lot while slightly lowering the ceiling for the very best individual developers — which is why elite specialists (Carniato in JS, top kernel maintainers in C) may see less personal benefit than generalists working outside their core expertise. He argues this is exactly the dynamic he expects with AI and coding: the best living kernel developers can likely still out-code the models in their specialty, but the same experts working outside their domain (or ordinary developers generally) get pulled up substantially. Theo positions his personal stance carefully: he isn't arguing you shouldn't read the code you merge, but that code is now cheap and useful enough that using AI heavily for review, testing, and verification (not just generation) is a clear net positive, and that unlike TypeScript, which hit an early ceiling, he sees no ceiling yet for AI capability.