The AI Code Nobody Understands Is Piling Up. The Bill Comes Due in 2028.

I shipped a feature last week that took me forty minutes. The AI wrote most of it. Tests passed. Code review looked clean. Client was happy.

Then I tried to explain what the code actually does to a colleague. I couldn't. Not fully. I understood the intent, I understood the inputs and outputs, but the implementation details in the middle? I'd accepted them on faith.

That's fine for one feature. But multiply that by every developer, every team, every company doing the same thing right now, and you start to see a problem that nobody's talking about at the quarterly planning meeting.

The Numbers That Should Make You Nervous

41% of all new commercial code is now AI-generated. That number comes from multiple industry reports, and it's climbing fast.

GitClear analyzed 211 million changed lines of code from 2020 to 2024. What they found should concern anyone who ships software for a living. Code churn increased 39%. That means code is being written and then rewritten within two weeks at nearly double the rate it was before AI tools became mainstream. Code duplication blocks went up 8x. Refactoring activity dropped 60%.

Read that last one again. Developers are writing more code, duplicating more code, and cleaning up less code. That's not a productivity gain. That's a mess accumulating in the dark.

Stack Overflow's 2026 survey found that 76% of developers using AI tools report generating code they don't fully understand. And 66% say they spend more time fixing "almost-right" AI output than they expected. I've written about how AI coding tools are atrophying my own skills, and I'm someone who built the fundamentals over years. The developers starting their careers right now don't have that foundation to fall back on.

Forrester predicts that 75% of tech leaders will face moderate-to-severe technical debt by the end of 2026. Not might face. Will face.

Why AI Code Rots Differently Than Human Code

Traditional technical debt comes with a paper trail. Someone wrote it. Someone remembers why. Someone can explain the tradeoff they made at 2 AM to hit a deadline. It's debt, but it's debt with an author.

AI-generated code is debt without authorship.

There's no institutional memory attached to it. No one sat in a meeting and decided "we'll cut this corner here because of X." The AI simply produced something that worked, the developer accepted it, and everyone moved on. When it breaks six months later, nobody knows why it was written that way in the first place. Because it wasn't "written that way." It was generated.

Here's the other thing. AI treats every prompt as a separate task. It doesn't look at your codebase and think "oh, there's already a utility function that does this." It writes a new one. Every time. That's why duplication is up 8x. The AI isn't lazy. It's contextless.

As I wrote previously, Claude is great at building software, but it's also great at breaking it. The code looks right. It passes tests. It follows patterns. But it's what Sonar calls "code smells": subtle issues that don't trigger alarms but compound over time. Over 90% of the issues they find in AI-generated code fall into this category. Not obvious bugs. Quiet rot.

The 18-Month Wall

I've started seeing a pattern with client projects, and the research backs it up.

Months 1 through 3: Euphoria. The team is shipping at 2x or 3x the pace they were before. Everyone feels like a genius. Management is thrilled. The AI subscription is paying for itself ten times over.

Months 4 through 9: Plateau. New features start bumping into existing AI-generated code in unexpected ways. Integration takes longer. Debugging gets harder because nobody quite understands the code they shipped three months ago.

Months 10 through 15: Decline. More time is spent debugging than building. The team starts avoiding certain parts of the codebase because they're fragile and nobody wants to touch them. "Don't change that file, it works but we're not sure why."

Months 16 through 18: The wall. Delivery stalls. New features require rewriting old ones first. The velocity gains from months 1 through 3 have been eaten alive by maintenance costs. By year two, those costs hit 4x what they would have been with traditionally written code.

The clients who went all-in on AI code generation in late 2024 and early 2025? Some of them are calling me now. Not to build new features. To figure out what the code they already shipped actually does.

Vibe Coding Built the Bomb. 2028 Detonates It.

Vibe coding is where the problem goes from concerning to genuinely dangerous.

For those unfamiliar: vibe coding is when you describe what you want to an AI in natural language and let it generate entire applications with minimal human review. You prompt, you accept, you ship. It feels productive. It feels like the future. It feels like everyone building an app because AI made it possible.

The numbers are brutal. Test coverage in vibe-coded projects averages 12%. Traditional codebases? 68%. That's not a gap. That's a canyon. 45% of vibe-coded projects contain security vulnerabilities. The architecture wasn't designed. It emerged accidentally from a series of prompts.

I've written about the security nightmare that vibe coding creates. But the security angle is almost secondary to the maintenance angle. At least security vulnerabilities get found and patched. Technical debt just sits there, compounding.

A Beam study projects that 40% of primarily AI-coded projects will face cancellation or major rework by 2028. Not because the AI wrote bad code in any obvious way. Because the accumulated weight of code nobody understands eventually collapses under its own complexity.

2024 was the first year when the introduction of repeated code exceeded refactoring activity, according to GitClear. That trend line isn't flattening. It's steepening.

The Junior Dev Hole Makes Everything Worse

Here's where this connects to something I wrote about recently. Junior developers are disappearing. Entry-level job postings dropped 67% since 2022. The pipeline that produces experienced engineers is breaking.

Now combine that with the technical debt problem. Who reviews AI-generated code? Who catches the subtle issues? Who debugs the systems that nobody fully understands? Senior engineers. And we're producing fewer of them every year because we cut the junior roles that feed the pipeline.

Google's DORA report found something fascinating. AI tools sped up code reviews. Great. But they also decreased delivery stability by 7.2%. Faster reviews, less stable output. The speed is real. The quality trade-off is also real.

The irony is suffocating. We automated away the entry-level positions that taught people to read code carefully, to understand systems deeply, to catch problems early. And now we're generating more code than ever that needs exactly that kind of careful human review.

What I'm Actually Doing About It (And What I'm Not)

I'm not going to give you a "10 Steps to Fix AI Technical Debt" checklist. I don't have ten steps. I'm figuring this out the same as everyone else.

Here's what I do: I read every line the AI generates before I commit it. Every line. It takes longer. It costs me some of the speed advantage. But I know what my codebase does. When something breaks at 11 PM, I can find it.

I use spec-driven development to give the AI architectural context before it writes anything. Instead of "build me a login system," it's "here's the auth architecture, here's how it connects to the existing session management, here are the constraints." The output is dramatically better when the AI knows what it's working within.

But here's the honest part: I still ship code I don't fully understand sometimes. When the deadline is tight and the tests pass and the functionality works, I accept the AI's implementation and move on. I know it's adding to the pile. I do it anyway. The incentive structure rewards shipping fast, not shipping clean. I'm not above it.

Nobody Has a Clean Answer for This One

The industry is generating code at a pace that outstrips human capacity to audit it. That's not going to change. AI tools are getting better, not going away. The code is piling up.

Maybe 2028 isn't the year the bill comes due. Maybe it's 2029. Maybe some teams will be careful enough to avoid it entirely. Maybe AI gets good enough at understanding its own output that it can handle the maintenance too.

But right now, in 2026, what I see is this: companies shipping faster than ever, understanding less of what they ship than ever, and hiring fewer people who could close that gap than ever. That's compound interest working against you.

This isn't a doomsday prediction. It's just math. Technical debt compounds. AI accelerates the rate at which it accumulates. The fewer humans who understand the code, the harder it is to pay down.

If your business depends on software that needs to last more than two years, start asking uncomfortable questions about how much of your codebase your team actually understands. The answer might surprise you.

Want to talk about what your codebase actually looks like under the hood? Let's figure it out together.