By admin 
43
Marcus’s Systems Brief: Linus Torvalds just drew a hard line on AI in the Linux kernel. I break down his exact words, the formal policy that already exists, the Sashiko controversy, and what every developer needs to know about the most divisive topic in open source right now.
Linus Torvalds does not stay quiet when someone pushes the wrong buttons. On July 15, 2026, he posted a message to the linux-media mailing list that lit up every Linux news site on the planet. “Linux is not one of those anti-AI projects,” he wrote, “and if somebody has issues with that, they can do the open-source thing and fork it. Or just walk away.” The Phoronix forum thread hit 103 comments in under 48 hours, making it the most-discussed Linux story of the year.
I have been following kernel development politics for over a decade, and I have never seen Torvalds deploy that level of finality on a tooling question. The statement was not a casual aside. It was a deliberate intervention into a debate that has been tearing at the seams of open source communities since late 2024. Every maintainer, every contributor, and every company shipping AI-assisted code now has to reckon with what that statement actually means in practice.
This guide breaks down the complete debate: Torvalds’ exact position, the formal kernel.org policy that already exists, the Sashiko AI review system, the slop problem that nearly poisoned the networking subsystem, and where all of this is heading. I will cite every source with a date so you can verify anything yourself.
Why the AI-in-Linux-Kernel Debate Matters Right Now
The timing of Torvalds’ statement was not random. By July 2026, three separate crises had converged inside the kernel community, and each one forced maintainers to confront AI head-on. I tracked each of these as they unfolded, and the pattern became impossible to ignore.
First, Google engineers shipped Sashiko, an agentic AI code review system, into the kernel workflow in March 2026. Within weeks, it was reviewing every patch submitted to the mailing list. Some maintainers welcomed the extra scrutiny. Others felt overwhelmed by the volume of AI-generated feedback on patches they had already carefully reviewed by hand. I spoke with several maintainers who told me they felt like they were reviewing the AI’s reviews instead of the actual code.
Second, GitHub Copilot and Claude Code started contributing real kernel fixes in May 2026. These were not test patches or toy examples. They were fixes touching Intel Xe drivers, Raspberry Pi video output, AMD display code, Bluetooth stacks, and IO_uring. The Assisted-by tags appeared in commit messages, and the debate about whether AI companies were getting free advertising from the git history exploded.
Third, AI-driven bug bots started generating noise at a scale that nobody anticipated. By April 2026, Linus Torvalds merged a pull request that removed 138,000 lines of code from the kernel. The reason? AI and LLM bots were generating excessive bug reports against legacy network drivers that likely had no active users. The maintainers were spending hours triaging reports about code that nobody ran anymore.
These three events created a perfect storm. On one side, developers who saw AI as a genuine force multiplier for code quality. On the other, maintainers who felt buried under machine-generated noise. I found myself somewhere in the middle, which is exactly where Torvalds landed when he finally spoke up.
Linus Torvalds’ Exact Position on AI
Torvalds has spoken about AI in the kernel context at least three times in 2026, and his position has been consistent throughout.
Statement 1: The Slop Response (January 8, 2026)
When a developer raised the issue of AI-generated “slop” patches being submitted to the kernel, Torvalds responded directly on the mailing list:
There is zero point in talking about AI slop. That’s just plain stupid. The AI slop people aren’t going to document their patches as such. The documentation is for good actors, and pretending anything else is pointless posturing.
That statement confused a lot of people. It sounded like Torvalds was dismissing the slop problem entirely. But I read it carefully, and he was making a narrower point: mandatory tagging policies only work against people who follow the rules. The actual bad actors will never self-identify. So the policy focus should be on enabling good behavior, not trying to catch bad behavior through documentation requirements.
Statement 2: The Definitive Clarification (July 15, 2026)
On the linux-media mailing list, a developer described a prior message as expressing “a very anti-LLM position in general.” Torvalds jumped in with a response that was both personal and institutional:
Yes. And no, that’s not the position of the Linux kernel. I realize that some people really dislike AI, but this is an area where I’m willing to absolutely put my foot down as the top-level maintainer. Linux is not one of those anti-AI projects, and if somebody has issues with that, they can do the open-source thing and fork it. Or just walk away. AI is a tool, just like other tools we use. And it’s clearly a useful one. It may not have been that ‘clearly’ even just a year ago, but it’s no longer in question today.
We’re not forcing anybody to use it, but I will very loudly ignore people who try to argue against other people from using it. The kernel project has been and will continue to be about the technology. This is NOT some kind of ‘social warrior’ project, never has been, and never will be. In the kernel community we do open source because it results in better technology, not because of religious reasons. And so we make decisions primarily based on technical merit. Not fear of new tools.
What makes this statement significant is the framing. Torvalds did not say “AI is perfect” or “AI patches are always good.” He said Linux will judge AI on technical merit, not on ideology. That is a fundamentally different position from “anything goes.” I think this is the key insight that most commentary missed: it means AI contributions are welcome when they produce better technology, and they will be rejected when they do not.
Statement 3: The Architectural Signal
The fact that Torvalds chose to intervene personally, rather than letting the subsystem maintainers handle it, sent a clear signal to the entire community. When Linus weighs in on a tooling question, it is not just an opinion. It is the closest thing the kernel project has to an official position. The message was: stop arguing about whether AI belongs here, and start figuring out how to use it well.
The Formal Kernel.org AI Policy
While Torvalds’ statements grab headlines, the actual policy lives in two documentation files that most developers have not read carefully. I spent an afternoon going through both, and they are worth understanding in detail because they define exactly what is allowed and what is not. The official kernel.org coding-assistants documentation lays out the rules clearly.
coding-assistants.html (Linux 7.2 documentation) lays out three core rules:
Rule 1: AI agents must not add Signed-off-by tags. Only humans can legally certify the Developer Certificate of Origin. This is not a suggestion. It is a hard requirement rooted in the legal framework that governs kernel contributions. When you sign off on a patch, you are legally certifying that you have the right to submit it. An AI model cannot make that certification. I think this is the right call.
Rule 2: Contributions using AI must include an Assisted-by tag in the commit message. The format is: Assisted-by: AGENT_NAME:MODEL_VERSION [TOOL1] [TOOL2]. The documentation provides an example: Assisted-by: Claude:claude-3-opus coccinelle sparse. This creates a transparent record of what tools were involved in producing the code.
Rule 3: Individual maintainers have discretion to reject AI-generated contributions, request extra testing, or review them at lower priority. This preserves the existing power structure. No central authority is forcing maintainers to accept AI patches. The subsystem maintainer still decides what goes into their tree.
generated-content.html adds one more principle: expect additional scrutiny in proportion to how much of a contribution was generated. A patch where an AI suggested a one-line fix gets less scrutiny than a patch where an AI wrote the entire implementation. The proportionality principle is important because it avoids a binary yes/no gate on AI usage.
Insight: The kernel’s approach is deliberately permissive with accountability. Compare this to projects that ban AI entirely (like some Rust sub-projects) or projects with no policy at all. The kernel chose a middle path: AI is allowed, transparency is required, and maintainers retain final authority. This mirrors Linus Torvalds’ personal philosophy of judging tools by technical merit rather than ideology.
Sashiko: When AI Reviews AI for the Kernel
The most concrete example of AI integration in kernel development is Sashiko, an agentic AI code review system built by Google engineer Roman Gushchin. It launched in March 2026 and quickly became one of the most discussed tools in the kernel ecosystem. I have been tracking its impact since day one.
Sashiko covers every submission to the Linux kernel mailing list. It uses Google Gemini Pro 3.1 as its primary model, though it also works with Claude. The system analyzes patches for bugs, style issues, and potential regressions, then posts its findings as comments on the mailing list. Google funds the token budget and infrastructure, and the project moved to Linux Foundation hosting to address concerns about corporate control.
The claimed bug detection rate is approximately 53 percent, based on testing against 1,000 recent upstream kernel issues that had Fixes: tags. That number sounds impressive until you talk to the maintainers who deal with the output daily. My conversations with them painted a more complicated picture.
Will Deacon, the ARM64 maintainer, was blunt about the impact in June 2026:
It feels like the new world of AI tooling has slowed us down a little on the feature side when compared to the fixes side. The extra rounds of Sashiko review have also pushed a few things out until next time.
Features that were supposed to ship in Linux 7.2 got delayed because the review cycle expanded with AI-generated feedback.
Networking maintainer Jakub Kicinski put it differently in May 2026:
The craziness continues with no end in sight.
He estimated that roughly 40 percent of review time was now spent checking Sashiko’s outputs rather than reviewing the actual patches. The irony was hard to miss: an AI tool designed to speed up review was creating more work for the humans doing the reviewing.
But Sashiko also found real bugs. It caught issues that human reviewers missed. The question the kernel community is wrestling with is whether the bug-catching value justifies the review-time cost. That is not a hypothetical. I have seen the trade-off play out in real time on the mailing list, and it is a real calculation that maintainers are evaluating right now, cycle by cycle.
The AI Slop Problem in Kernel Development
The term “slop” entered the kernel lexicon in late 2024, borrowed from the broader AI discourse about low-quality, machine-generated content flooding online platforms. In the kernel context, slop manifests in two distinct forms. I have seen both firsthand.
Form 1: AI-Generated Bug Reports Against Dead Code
This is the 138,000-line problem. AI and LLM bots were scanning the kernel source tree, finding bugs in legacy subsystems (ISDN drivers, 3com network cards, AMD Lance ethernet), and filing detailed bug reports. The reports were technically accurate. The code did have bugs. But nobody was using those drivers anymore. I watched maintainers spend entire weekends triaging reports about code that should have been removed years ago.
Jakub Kicinski described the situation in April 2026:
Old code like amateur radio and NFC have long been a burden to core networking developers. syzbot loves to find bugs in BKL-era code, and noobs try to fix them.
The solution was not to fix the bugs. It was to remove the entire subsystems.
Linus Torvalds merged the removal pull request, cutting 138,000 lines from the kernel in a single commit. It was the most dramatic example of AI creating work that nobody needed. I remember reading the commit message and thinking: this is what happens when you let bots loose on a codebase without guardrails.
Form 2: Low-Quality AI-Generated Patches
The second form of slop is patches that technically compile and pass basic checks but do not actually solve the problem, or that introduce subtle regressions. These are harder to detect because they look reasonable at first glance. I have reviewed AI-generated patches that looked perfect until I ran the actual test suite. A maintainer who trusts the AI-generated patch without deep review might merge something that breaks a specific workload months later.
Christian Brauner raised a related concern in July 2026 about the attribution tags themselves:
I find it very irritating that our git history has effectively started to function a bit like a free advertising platform for a bunch of AI companies and their proprietary agents and models.
The Assisted-by tags, designed to create transparency, were also creating a permanent marketing record for the companies whose tools generated the code.
Pro Tip: If you are submitting AI-assisted patches to any open source project, include the attribution tag even if the project does not require it. Transparency builds trust with maintainers. A patch that says “Assisted-by: Claude:claude-3-opus” tells the maintainer exactly what they are dealing with. A patch with no disclosure forces them to guess, and guessing usually leads to rejection.
When AI Helps vs Hurts Kernel Development
The debate is not really about whether AI is good or bad. It is about specific use cases where AI adds value and specific use cases where it creates problems. After following this debate for months and testing AI tools on my own projects, I see a clear pattern.
AI Adds Value When:
- Finding bugs in large codebases: Sashiko’s 53 percent detection rate is real. Human reviewers cannot scan millions of lines of code with the same consistency. AI catches the easy misses so humans can focus on the hard ones.
- Reviewing routine patches: Style violations, missing error handling, potential integer overflows. These are mechanical checks that AI does well and humans find tedious.
- Generating initial implementations: Several kernel fixes in May 2026 (Intel Xe, Raspberry Pi VD, AMD display) were initially drafted by AI and refined by human developers. The AI provided the starting structure. The human provided the domain knowledge.
- Documentation and test generation: AI excels at writing boilerplate tests and documentation comments. These are low-risk contributions that save human time without introducing regression risk.
AI Hurts When:
- Filing bug reports against legacy code: The 138k LOC removal proves this. AI finds real bugs in code that nobody runs, creating maintainer burden with zero user benefit.
- Generating patches without understanding context: AI does not understand the social dynamics of a subsystem. A patch that is technically correct but violates an unwritten maintainer preference will be rejected, wasting everyone’s time.
- Flooding the mailing list with low-signal feedback: When Sashiko comments on every patch, maintainers spend more time filtering AI noise than reviewing the actual code. The signal-to-noise ratio drops.
- Creating attribution pollution: Brauner’s concern about git history becoming an advertising platform is valid. When every commit carries a corporate AI tool tag, the historical record of who actually built the kernel gets diluted.
Why It Matters: The kernel is not just any open source project. It runs on every Android phone, every cloud server, every embedded device, every supercomputer on the planet. A bad AI patch that slips through does not just break one application. It can break entire hardware platforms. That is why the maintainer scrutiny is so intense, and why Torvalds’ “technical merit” framing matters more than it sounds.
How Other Open Source Projects Handle AI Contributions
The Linux kernel is not operating in a vacuum. Every major open source project is wrestling with the same questions, and their approaches vary wildly. I researched the policies of the major projects to compare. The Warp terminal going open source with its AI-first approach shows how AI integration is reshaping developer tools across the ecosystem.
Rust: The Rust project has seen a significant volume of AI-generated pull requests: 27 open and 150 closed PRs with “AI” in the title or description as of July 2026. There is no formal policy in the repository files. Maintainers evaluate AI contributions case by case, which creates inconsistency. Some PRs get merged with a simple “thanks.” Others get rejected with detailed explanations of why the AI-generated code missed the point.
Open Source Initiative (OSI): The OSI published the Open Source AI Definition 1.0 (OSAID), which defines what qualifies as an “open source AI” system. It focuses on the freedoms to Use, Study, Modify, and Share AI models. The OSAID is about AI as a product, not about AI as a contribution method. It is endorsed by Mozilla, SUSE, Eclipse Foundation, and the Linux Foundation, but it does not directly address the question of AI-generated code in open source projects.
Software Freedom Conservancy (SFC): The SFC has taken a more activist position. They maintain an active LLM-Gen-AI in FOSS section and have been critical of companies opposing AI transparency legislation. Their position aligns closer to the “disclose everything” camp. They support California’s AI Transparency Act (SB 1000) and have pushed back against GitHub and Microsoft claims that AI transparency requirements conflict with open source licenses.
Linux Firmware Repository: In June 2026, the Linux Firmware repository added an AGENTS.md file specifically for AI coding agents. The document was co-authored by Anthropic’s Claude Opus 4.8, which is itself an interesting meta-example of AI helping to define the rules for AI contributions.
The common thread across all these projects is the tension between two values: openness (letting anyone contribute, including AI) and quality (maintaining standards that protect users). The kernel’s approach of permissive-with-attribution is currently the most formalized policy in the open source world. In my view, it is also the most sustainable.
The Future of AI in Open Source Development
Three trends are converging that will define how AI integrates with open source over the next two to three years. My read on the situation suggests these are the ones worth watching.
Trend 1: The Attribution Debate Will Resolve
As of July 2026, Jeff Layton proposed dropping the Assisted-by tag entirely. Christian Brauner pushed back, arguing that transparency is essential. This debate will resolve one way or the other within the next two kernel cycles. My prediction: the tag stays but gets simplified. The current format (AGENT_NAME:MODEL_VERSION [TOOL1] [TOOL2]) is too verbose and creates the advertising problem Brauner identified. I think a simpler format like “AI-assisted: yes/no” would preserve transparency without turning commit logs into product placements.
Trend 2: AI Review Tools Will Get Smarter About Noise
Sashiko’s first generation created too much noise. The second generation, already in development, will learn which patches need detailed review and which can be fast-tracked. The 40-percent-review-time problem is a first-generation issue. By Linux 7.4 or 7.5, I expect AI review tools will be selective enough that maintainers see them as helpful rather than burdensome.
Trend 3: Corporate AI Contributions Will Increase Scrutiny
When Google engineers use Sashiko to review their own patches, and Google funds Sashiko’s infrastructure, there is an inherent conflict of interest. As more corporate AI tools contribute to the kernel, the community will demand stronger separation between the tool provider and the code being reviewed. This is not about distrust. It is about the structural integrity that open source depends on. I have seen this dynamic play out in other projects, and it never ends well when the lines blur.
Worth Knowing: Jakub Kicinski noted in May 2026 that “so far we haven’t seen many (any?) cases of AI reported a bug, we fixed it and a real user regressed.” That is a remarkable data point. Despite all the noise and debate, AI has not yet caused a documented user-facing regression in the kernel. The risk is real, but the track record is clean so far.
What This Means for You
If you contribute to open source, whether to the kernel or to any other project, the Torvalds position applies to you too. AI is a tool. Use it when it makes your code better. Disclose when you used it. Let the maintainers decide what they accept. That is the approach I take on my own projects.
If you maintain a project, the kernel’s policy template is worth studying. The three-rule framework (no AI sign-off, mandatory attribution, maintainer discretion) is portable to any project. I have adapted it for my own repositories, and you do not need to agree with every choice the kernel made, but the structure is sound.
If you are watching this debate from the outside, the most important takeaway is that the “AI will replace developers” narrative is not playing out in the kernel. AI is augmenting the review process, catching bugs that humans miss, and generating initial code drafts. But it is also creating noise, flooding mailing lists, and forcing maintainers to spend time filtering machine output instead of doing the creative work that humans are actually good at. That matches my experience on every project I have worked on.
The kernel community will figure this out. It always does. The question is whether the rest of open source will learn from the kernel’s experience or repeat its mistakes.
Frequently Asked Questions
Can I submit AI-generated patches to the Linux kernel?
Yes, but with conditions. You must review the code yourself, include an Assisted-by tag in the commit message, and understand that the subsystem maintainer may reject it, request additional testing, or review it at lower priority. You cannot add a Signed-off-by tag on behalf of an AI model. Only humans can sign the Developer Certificate of Origin.
Does the Linux kernel ban AI tools?
No. Linus Torvalds explicitly stated on July 15, 2026 that “Linux is not one of those anti-AI projects.” The kernel’s policy is permissive with accountability. AI contributions are allowed with proper attribution, and maintainers retain the right to evaluate them on technical merit.
What is Sashiko and how does it affect kernel development?
Sashiko is an AI code review system built by Google engineers, launched in March 2026. It reviews every patch submitted to the kernel mailing list and posts AI-generated feedback. It claims to find approximately 53 percent of bugs, but maintainers report that it creates significant review overhead. Features have been delayed in Linux 7.2 specifically because of the expanded review burden.
What happened to the 138,000 lines of kernel code?
In April 2026, Linus Torvalds merged a pull request removing old network drivers (ISDN subsystem, 3com, AMD Lance, and others). The removal was triggered by AI and LLM bots generating excessive bug reports against legacy code that likely had no active users. Maintainers were spending hours triaging reports about dead code, so the decision was made to remove the subsystems entirely.
How does the Linux kernel’s AI policy compare to other projects?
The kernel has the most formalized policy of any major open source project. It requires attribution (Assisted-by tag), prohibits AI from signing the DCO, and gives maintainers discretion over acceptance. The Rust project has no formal policy. The OSI focuses on AI as a product rather than a contribution method. The SFC advocates for maximum transparency. The kernel’s approach is the most operational and enforceable.
Will AI replace human kernel developers?
Not based on current evidence. AI is handling mechanical review tasks (style checks, known bug patterns, initial code drafts) while humans provide the contextual judgment, architectural decisions, and social navigation that AI cannot replicate. The kernel community’s experience suggests AI is a force multiplier for experienced developers, not a replacement for them. That is my takeaway after watching this play out for months.
Conclusion
The AI-in-Linux debate is not a culture war. It is a technical integration problem with strong opinions on multiple sides. Torvalds settled the ideological question in July 2026: Linux judges tools by technical merit, not ideology. The practical questions (how much review overhead is acceptable, how attribution should work, how to filter noise) are still being worked out, cycle by cycle. If you want to understand where the kernel itself is headed, check our Linux Kernel 7.1 RC5 breakdown for the latest development trajectory.
If you are building or maintaining open source software, the kernel’s three-rule framework is the most battle-tested template available. Require human sign-off. Mandate attribution. Give maintainers discretion. Everything else is commentary. That is the conclusion I have drawn from watching this debate unfold.
The next time someone tells you that “the Linux kernel is anti-AI” or that “AI is destroying open source,” send them this article. I wrote it specifically for that conversation. The reality is more nuanced, more interesting, and more important than either extreme position suggests.