Linus Torvalds is right about AI coding, and the backlash misses the point

Linus Torvalds is no stranger to making headlines, but his latest intervention in the Linux kernel community has caused a particular stir. Responding to a mailing-list discussion about Sashiko, an AI-powered system that reviews proposed kernel patches, Torvalds declared that Linux is not an "anti-AI project." His language was characteristically blunt, but the argument underneath it was pragmatic: AI tools can be useful, provided they help human maintainers rather than burying them in additional work.

What Linus Torvalds actually said

The argument is more pragmatic

When Linus, the creator and lead maintainer of Linux, writes something, the community generally stops what they're doing to give it a read. Linux has been reported to allow AI-generated code into kernel commits, but only if the author is prepared to take responsibility for this code as they would for their own. AI tools can lower some of the barriers to learning about software development, explaining unfamiliar code and producing an initial implementation to examine, but it's down to the contributor to make sure it's all correct.

There are legitimate arguments about AI’s environmental cost, training data, misinformation, and economic effects. Torvalds acknowledges that some of those wider questions remain unresolved, but they are separate from the narrower technical question under discussion: can an AI system provide useful assistance during software development and code review? It's a debate that will continue being held across communities, but for Linux, Torvalds is open to the idea of using these tools to better the platform, as noted in his mailing list comment:

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.

AI is a tool, just like other tools we use. And it's clearly a useful one.

The solution is to make sure those LLM tools _help_ maintainers instead of just causing them pain. There's no question on that side.

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.

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.

If you read between the lines, Torvalds is commenting on how these coding tools can be useful, and the practical question is how they can be deployed without causing too much overhead for human maintainers to handle. It's not that Torvalds is outright proposing an LLM become a kernel maintainer, but rather he is defending a developer's freedom to use the tool as they see fit, providing code that can be checked, approved, and incorporated into the wider Linux kernel.

It's more than just using AI to code

Linus previously opened up to the idea of using AI to aid coding, but this specific mailing list conversation was regarding AI-assisted review, not actual vibe coding. Sashiko is an agentic system designed specifically to inspect proposed Linux kernel patches. Architecture, execution flow, resource management, security, and hardware-specific mistakes are all in its crosshairs. Sashiko doesn't even make changes itself. It simply comments on anything it deems to require human insight.

The project is developed by the Linux Foundation and is funded by Google (for LLM tokens and resources). From the outset, it's understandable how someone could take what Torvalds has said over recent months and run with a complete beginner asking for a giant patch from a chatbot and forwarding it without completing due diligence. That's not really what's going on here. Sashiko, in its own testing, could detect more than 50 percent of bugs based on the last 1,000 upstream "fix" commits.

AI is here to stay, regardless of the bubble

We've already let the genie out of the bag

AI-assisted programming is unlikely to disappear even if today’s investment boom eventually contracts. Code completion, automated analysis, test generation, and natural-language interfaces are already becoming part of development environments. Individual products and companies may fail, but the underlying idea of using statistical systems to assist software development is unlikely to vanish with them. Everyone is hopping aboard the AI train.

AI is slapped on everything, mostly without merit, but it's going nowhere. Even if the bubble somehow bursts like it did in the early 2000s, we'll continue to use AI in new and wonderful ways, like we have online services such as Amazon. That goes for coding too. Chatbots and agents designed specifically for helping with code can make software development more accessible. It's also great for learning, as you can actively see how the code works.

The same goes for this whole Linux kernel debate. Torvalds never stated that AI is correct or should be used as the sole commit stage, but if it can be used to help maintainers, that can only be positive for the platform as a whole. It's not about submitting more code thanks to the power of AI, but more about stamping out bugs earlier, not missing anything, producing sandboxed testing, and even suggesting changes within a specific set of parameters.

As someone who previously laughed at all these chatbots and now actively uses LLMs in a local setting, I can confidently agree with Torvalds' points on how AI can be incredibly useful when used appropriately.

Software development can be scary

But AI can help make it more accessible and reliable

I'm not a Linux kernel maintainer. I've never submitted a commit to the repo for a change to be made. It's not because I don't want to, but because it's simply outside of my comfort zone. Give me barebones Linux to play around with and I'll be happy for weeks, but actually helping shape the future of the platform that powers everything is an entirely different beast. Also, I know next to no C, having firm roots in web languages from school and college.

Using AI to help complete code or make changes before committing can be a great way to leverage the power of a system to give code a going over to pick up on any potential issues. But as Torvalds has previously stated, as soon as code is submitted from someone who has used AI assistance, that submission is their responsibility. There's no saying "Well, that was the chatbot" since the submitted code is from a contributor, not a chatbot. It doesn't matter how code is finalized.

That's the same with my interactions when I get Qwen to generate some PHP or JavaScript. I'll still check over every line of code it generates to make sure it matches what I wanted. I'll run it sandboxed to ensure there's no funky business and it fits into the wider application. Although Qwen generated the lines of code, I still view it as my responsibility to ensure it works as intended. The same goes for creating commits for the Linux kernel.

But the conversation has evolved from covering using LLMs to code to Sashiko. It's actually completely different. How the tool works is through decomposing the review into stages, checking claims against implementation, tracing error paths, and looking for leaks and bugs. One could even view it as a form of Grammarly for the kernel. Like Sashiko, many experienced coders don't simply ask an LLM to complete the entire task. It's very specific with smaller predetermined goals.

There's a clear way forward

The strongest objection is not that an LLM can never produce anything useful. It is that generation is cheap while the review process remains expensive. A contributor can generate ten plausible-looking patches in minutes, while an experienced maintainer may spend hours determining whether they are safe. If not used appropriately, AI won't eliminate work and will transfer work from the person submitting code to the person responsible for protecting the project.

The Linux project already has clear and concise guidelines on AI-assisted work. A human submitter must review the code, assisted code should be appropriately tagged, and contributors must understand and defend every submission. One simply cannot ask ChatGPT to make heavy kernel changes and submit them without knowing what's going on. It's the right way to handle AI tools by making the contributor (not the model) accountable. This also forces testing and evidence with clear disclosure.

That's precisely where a tool such as Sashiko is valuable to help maintainers better handle the increased workload. Instead of blanketing every AI-assisted commit as nothing but AI slop, Sashiko can help improve filtering and hold human contributors accountable. Torvalds is attempting to move the discourse on from "Is AI useful?" to touch on where it can be used, under what controls, and who is accountable. AI-generated code flooding repositories is terrible, and I'd be the first in line to complain about this use of agents.

But using tools like Sashiko to pick up on potential bugs, handle repetative lines, or even come up with new ideas before the code makes its way to the repo can have a positive impact. The choice is not between blindly trusting AI and banning it outright. It is between careless automation and responsible assistance—and on that distinction, Torvalds is right.