Imagine you’re a pilot, and the autopilot suddenly decides to ignore your inputs because it thinks it knows better. That’s what’s happening to Linux right now, and most developers are asleep at the yoke.
You’ve probably noticed the headlines: AI is coming to the Linux kernel. Bug fixes, automated patches, even AI-generated code. Sounds efficient, right? Wrong. The moment we let AI decide what code runs in the kernel, we stop being engineers and become passengers.
Drew DeVault, a veteran Linux developer, didn’t mince words. He called out the creeping adoption of AI in kernel development as a fundamental threat. He’s not a Luddite—he’s a realist who understands that the kernel’s value lies in its deterministic, human-verifiable reliability. Every line of code is supposed to be understood by someone. AI changes that.
Here’s the twist: the open-source community fought for decades to keep the kernel transparent, auditable, and accountable. Now we’re willingly handing over control to probabilistic black boxes that no single person can fully trust. AI in the kernel isn’t a technical upgrade; it’s an abdication of engineering responsibility.
I’ve seen this firsthand. A friend of mine works on critical infrastructure—power grids, financial systems. They rely on Linux because it’s predictable. Introduce AI that can change behavior based on opaque training data, and you kill that predictability. The irony is thick: the same people who raged against proprietary software are now embracing a system that’s even less transparent than a binary blob.
Don’t get me wrong—AI has its place. It’s great for code suggestions, bug categorization, even reviewing patches. But when it starts writing kernel code that runs on millions of servers, you’re gambling with the internet’s backbone. Neutrality is death here. This is dangerous. Full stop.
Some will argue that open models solve the problem—they’re transparent, right? Wrong. The model itself may be open, but the decisions it makes are still emergent and unpredictable. You can’t debug a neural network the way you debug a driver. You can’t prove it won’t crash under a specific edge case. That’s a regression, not a progression.
So what’s the real cost? Trust. The Linux kernel has been the bedrock of the internet because you could trust it—not to be perfect, but to be accountable. Every bug could be traced back to a human decision. AI breaks that chain. If we don’t stop this, we’ll wake up one day to find the kernel we trusted is no longer ours.
This isn’t about progress versus stagnation. It’s about understanding what we’re sacrificing. The next time you see a PR that says ‘AI-generated fix,’ ask yourself: who owns that code? Who stands behind it? Because if no human can answer, you’ve already lost.
FAQ
Q: But AI can find bugs faster than humans, isn't that good?
A: Not if it introduces bugs that no human can find. The kernel's value is predictability. AI sacrifices that for speed. Tradeoffs matter, and this one is reckless.
Q: What's the practical implication for developers?
A: Stop blindly accepting AI-generated patches. Demand that every kernel change be human-understandable. Push for policies that ban AI-generated code in critical subsystems until we can audit the models themselves.
Q: Isn't AI already in compilers and editors? Why is the kernel different?
A: Compilers and editors don't run in production. The kernel runs on everything. AI in a code assistant is a tool. AI in the kernel is a decision-maker. Different stakes, different rules.