AI code debt doesn't get paid back. It compounds silently.

I've argued before that cheap code is the most expensive code. This is the harder, more specific version of that claim, and now there's a number on it: AI-generated technical debt doesn't behave like the debt we know how to manage. It doesn't get paid back. It just quietly piles up in a place no one is watching.

The number that should worry you

A 2026 study from Singapore Management University — "Debt Behind the AI Boom" — went through 302,600 verified AI-authored commits across 6,299 repositories and found 484,366 distinct issues. The stat that matters isn't how many issues AI introduced; it's how many survived: 22.7% of the issues AI introduced were still present at HEAD. Not caught, not fixed, not paid down — still there, live, in the current code. Per-tool introduction rates ranged from ~17% to ~29% depending on the assistant.

Nearly a quarter of the flaws, still in the tree. That's not a review-quality problem. That's a different kind of debt.

Why AI debt behaves differently

Human technical debt has a natural repayment mechanism: someone wrote it, so someone remembers it. The person who took the shortcut carries a mental model of where the bodies are buried, feels the pain when they return to that module, and pays it down because it's theirs. Debt and ownership travel together.

AI-generated debt severs that link. Nobody wrote the code, so nobody owns the mental model of it. It merges looking clean — plausible, well-formatted, passing tests — and then it sits there, unfelt, because there's no author to feel it. When the flaw finally surfaces, the response isn't "oh right, I remember this." It's "who wrote this? …nobody did." You're now debugging a system no human ever understood, and the codebase reaches its untouchable, no-one-dares-change-it state faster than a human-authored one ever would.

Debt you generated but never understood isn't a shortcut you'll repay later. It's a liability that's already on the balance sheet, in a language no one on the team speaks.

Coverage is not comprehension

The reflexive fix is "add more tests." But tests catch the failures you anticipated. The dangerous AI debt is the code that passes every test and is still wrong for reasons no one understood well enough to test for — the subtle coupling, the swallowed edge case, the assumption that held until it didn't. Coverage tells you the code does what the tests say. It tells you nothing about whether anyone knows what the code does.

The only real hedge is unglamorous:

• Merge only what someone understands. If no human on the team can explain a diff and defend it, it's not done — it's a liability wearing a green check. Comprehension is the acceptance bar, not test pass.
• Generate smaller, so it stays legible. A 40-line change a reviewer actually reads beats a 400-line one they skim. Volume is how AI debt sneaks in unread.
• Assign ownership on merge, not on incident. Someone's name goes on it, and that someone can explain it. Restore the author→debt link the AI severed.
• Treat "we don't understand this module anymore" as a Sev-2. That's the real state to fear, and AI gets you there faster and quieter than any human team ever did.

The bottom line

AI didn't just make code cheaper to write; it made debt cheaper to create and forget. Nearly a quarter of AI-introduced issues are still sitting in production trees because the mechanism that used to pay debt down — a human who remembers — was never in the loop.

Stop measuring AI code by whether it passes. Measure it by whether someone understands it — because the debt you can't see and no one owns is the only kind that truly compounds.