A 15-year-old root bug in Linux. Sitting there. Waiting. Thousands of developers walked past it. Code reviews, security audits, penetration tests—none of them caught it. Then an AI model found it in minutes.
You want to know what's broken about how we build software? That's your answer.
The Work Nobody Wants to Do
Here's what happened: Someone pointed an AI at old Linux kernel code and told it to audit for privilege escalation vectors. The model churned through codebases that human reviewers had already blessed. It flagged a vulnerability that had been granting root access since 2009.
Fifteen years. Not because developers are incompetent. Because the work required to find it is soul-crushing.
Reading old code is miserable. It's archaeological work through layers of patches, deprecated patterns, and context that evaporated years ago. No dopamine hit. No creative problem-solving. Just the grinding, repetitive task of checking whether line 1,847 might interact badly with line 4,392 under specific conditions nobody's thought about in a decade.
You know what happens when you assign this work to your best engineer? She starts updating her resume.
The model doesn't care. It will read the same function 10,000 times looking for edge cases. It will cross-reference every caller. It will check boundary conditions that would make a human reviewer's eyes glaze over. And it won't complain, won't burn out, won't start half-assing the work after hour three.
This isn't about AI being smarter than humans. It's about AI being immune to boredom.
Three Jobs Wearing One Hat
We've been lying to ourselves about software development for decades. We pretend "developer" is one role. It's not. It's at least three distinct jobs that require completely different cognitive modes and personality types.
Building is creative. You're synthesizing requirements, architecting solutions, making tradeoffs. It's generative work. The dopamine flows. This is what most developers signed up for.
Testing is methodical. You're systematically exploring failure modes, constructing adversarial inputs, validating assumptions. It's structured but still engaging. Some people love it. Most tolerate it.
Auditing is archaeological. You're reading code someone else wrote, often years ago, looking for problems that probably don't exist. It's tedious, unrewarding, and absolutely critical. Almost nobody wants to do it.
We've been forcing the same person to do all three. Then we act surprised when the audit work gets skipped or half-assed.
The Linux bug is what happens when we pretend these are the same skill set. The code wasn't poorly written. It wasn't even particularly complex. It just required someone to stare at old, working code long enough to notice a subtle privilege boundary issue. And nobody wanted to do that work.
What Actually Changes
I run a portfolio of AI-powered products. I ship code daily through an agent orchestration system. Here's what this Linux discovery means in practice:
Audit becomes continuous. You don't wait for a security researcher or a major version bump. You point models at your codebase on every commit. They read everything. They check everything. They never get tired of it.
Humans stop pretending. Your senior developers can admit they're not going to spend their afternoons reading three-year-old authentication logic. That's fine. That was never a good use of their time anyway.
The backlog gets real attention. You have legacy code that's "working fine" and nobody wants to touch. Everyone knows there are probably issues in there. Everyone also knows that assigning a human to audit it is career punishment. Models don't have careers to punish.
Different economics. A human security auditor is expensive and slow. You use them sparingly, on the riskiest surfaces. A model costs pennies to run and works 24/7. You can afford to be thorough.
This isn't theoretical. I'm watching it happen across my own systems. Code that would have sat unexamined for years gets continuous scrutiny. Not because I became more disciplined, but because the economics flipped. Audit work that was prohibitively expensive is now nearly free.
The Uncomfortable Part
Here's what nobody wants to say out loud: a lot of "senior developer" time is currently spent on work that models do better.
Not the creative parts. Not the architectural decisions. Not the product intuition. But the grinding, repetitive verification work? The stuff that has to be done but nobody enjoys? Models are already superior at it.
The Linux bug proves this. It's not an edge case. It's a demonstration of fundamental capability. Models can maintain focus on boring tasks indefinitely. Humans can't.
This doesn't make developers obsolete. It makes the pretense obsolete—the pretense that one person should be equally good at creating, testing, and auditing. That we should expect humans to stay engaged during the tenth hour of reading old code.
We're about to find out how much of the software industry's technical debt exists purely because audit work is miserable and we've been assigning it to people whose brains are wired for building.
The models don't mind the work. They'll read every line. They'll check every boundary. They'll do it again tomorrow.
And they'll find the bugs we've been walking past for 15 years.
JP Howlett runs modpx.dev and ships AI-powered products daily. He writes about building software that actually works.