On the surface, AI coding assistants look like the easiest win your team will ever get. More code, written faster, with less effort. Press the tab key and a whole function appears. What’s not to love?
Plenty, as it turns out, but not in the way the doom-mongers claim. The problem isn’t that AI writes bad code (though sometimes it does). The problem is far more subtle, and you won’t see it on any dashboard that only tracks how much you’re shipping.
To explain what’s actually happening, we need to go back to a definition of technical debt we keep coming back to. Just twelve words:
Technical debt is anything that adversely impacts throughput or stability over time.
Two halves to that sentence: throughput (how much change reaches production, and how fast) and stability (how reliably those deployments succeed). Hold onto both, because AI does something fascinating, and dangerous, to the balance between them.
Does AI increase technical debt?
Here’s the finding that should be on every engineering leader’s wall.
In its 2024 Accelerate State of DevOps Report, Google’s DORA team looked at what happens to delivery performance as teams adopt AI. They found that for every 25% increase in AI adoption, delivery throughput dropped by an estimated 1.5%, and delivery stability dropped by an estimated 7.2% [1].
Read that again. The thing sold to you as a productivity rocket was, in the data, associated with less stable software. The DORA team were careful to say the trade-off is uneven and the data can’t fully explain why [1], but the leading theory is intuitive enough: AI lets developers produce larger, more complex change lists faster than they can properly review them, and bigger batches are riskier to deploy [1].
The 2025 follow-up makes it more interesting, not less. By 2025, around 90% of respondents were using AI in their work, and AI’s relationship with throughput had actually flipped positive: teams were getting the speed back. But the link to instability didn’t go away. DORA’s own conclusion was blunt: AI adoption isn’t fixing instability, it’s currently associated with making it worse [2].
So to answer the question directly: AI doesn’t create a brand-new, exotic kind of debt. It pours fuel on the debt you were already at risk of creating, and it concentrates the damage on the stability half of the equation, which is exactly the half most teams don’t measure.
Why the stability hit is so easy to miss
Think about how most teams judge whether AI is “working.” They look at velocity. Lines of code. Tickets closed. Pull requests merged. Every one of those is a throughput measure.
And on throughput, AI delivers. One 2026 benchmark study found pull requests per developer rose roughly 20% year-over-year with AI assistance [8]. That’s the number that gets celebrated in the all-hands.
The number that doesn’t get mentioned? In that same study, incidents per pull request rose 23.5%, and change failure rates climbed roughly 30% [8]. More changes are going out, and a higher share of them are breaking something. You feel productive. The system is getting less reliable. Both things are true at once, and if you’re only watching the throughput side, you will genuinely believe AI is an unqualified success right up until the outages start.
This is the trap. Reckless debt has always been the dangerous kind: shortcuts taken with no awareness and no plan. AI hasn’t changed that. It’s just made it possible to generate that debt at machine speed, one accepted suggestion at a time, while every vanity metric on your dashboard glows green.
It was never one bad function. Now it’s thousands, automatically
The point we make again and again about technical debt is that a single shortcut is harmless. A real debt problem is thousands of small shortcuts compounding quietly over years until delivery grinds to a halt.
AI changes the timescale of that compounding from years to months.
The evidence is starting to pile up. GitClear’s analysis of more than 200 million changed lines of code found that duplicated code blocks (five or more lines cloned from nearby code) jumped roughly eight-fold in a single year, while code churn (lines reverted or rewritten within two weeks of being written) has been climbing toward double its pre-AI baseline [3]. Duplicate-but-slightly-different code is design and architecture debt by definition, and it’s invisible in any single pull request; you only see it when the whole codebase becomes impossible to change safely.
A large-scale empirical study of more than 300,000 AI-authored commits across thousands of public repositories tracked the debt AI introduced and found unresolved issues climbing relentlessly, from a few hundred in early 2025 to more than 110,000 surviving issues by February 2026 [4]. And the adoption curve guarantees this gets bigger before it gets smaller: Gartner has projected that 75% of enterprise software engineers will be using AI code assistants by 2028, up from under 10% in early 2023 [5].
Here’s the part that should worry the people holding the budget. One 2026 review estimated that unmanaged AI-generated code drives maintenance costs to around four times the traditional level by the second year, as the debt compounds [6]. That’s not a productivity gain. That’s a deferred bill, and it’s a big one.
If you’ve read our work on the cost of technical debt, you know how this maths works. Wasted, non-value-added effort plus the cost of downtime runs into the millions per team over a few years, and AI, used carelessly, doesn’t shrink that number. It accelerates it.
So what do you actually do about it?
Let’s be clear, because this is not an anti-AI article: AI is one of the most powerful tools your team has ever had, and used well it can pay down debt as effectively as it creates it. The difference between the two outcomes isn’t the tool. It’s whether you’re managing it.
A few things that matter more in the AI era than they ever did:
- Measure both halves, always. If you take one thing from this, take this: never judge AI adoption on throughput alone. Watch your change fail rate and your deployment rework rate, the stability metrics, with at least as much attention. The whole reason the DORA finding blindsided people is that they weren’t looking at the side AI was hurting.
- Treat every AI suggestion like a junior developer’s pull request. Read it line by line. Does an existing utility already do this? Does it match your conventions? Accepting AI output unread is the textbook “we don’t have time” reckless-and-deliberate debt that Martin Fowler warned about [7], just faster.
- Lean on your Definition of Done. Code reviewed, automated checks passed, tests written, documentation done. AI makes it trivially easy to skip these because the code looks finished. Anything skipped gets logged in your technical debt register, exactly as it always should have.
- Remember it’s a culture problem, not a code problem. AI is an accelerant. Drop it into a culture where shortcuts are rewarded and debt is hidden, and it will create reckless debt faster than anything in history. Drop it into a culture where debt is safe to surface and standards are enforced, and it becomes a genuine advantage.
Industry watchers have started framing it neatly: 2025 was the year of AI speed; 2026 is the year of AI quality [6]. That shift only happens on purpose. The tools won’t make it for you.
AI hasn’t rewritten the rules of technical debt. It’s just turned up the volume, on the speed, on the debt, and on the gap between teams who manage it and teams who don’t. The twelve-word definition still holds. The only question is whether you’re watching both halves of it.
Understanding the throughput-and-stability trade-off is the foundation of our course, Technical Debt 101: From Confusion to ConfidenceTraining. Over six modules it gives you and your team a shared language for spotting debt, measuring what it’s costing you, and managing it deliberately, whether it’s written by a person or an AI. Get the course here, or take an assessment to see where you stand today.
Sources
[1] Google Cloud / DORA, Announcing the 2024 DORA Report and 2024 Accelerate State of DevOps Report. Available: https://cloud.google.com/blog/products/devops-sre/announcing-the-2024-dora-report and https://dora.dev/research/2024/dora-report/
[2] DORA, 2025 State of AI-assisted Software Development Report (findings on persistent instability); analysis by R. Stephens, RedMonk, 18 Dec 2025. Available: https://dora.dev/ and https://redmonk.com/rstephens/2025/12/18/dora2025/
[3] GitClear, AI Copilot Code Quality: 2025 Data Suggests 4x Growth in Code Clones (duplication and code-churn findings across 211 million changed lines), as reported in How AI-Generated Code Compounds Technical Debt, LeadDev. Available: https://www.gitclear.com/ai_assistant_code_quality_2025_research and https://leaddev.com/technical-direction/how-ai-generated-code-accelerates-technical-debt
[4] Debt Behind the AI Boom: A Large-Scale Empirical Study of AI-Generated Code in the Wild (304,362 AI-authored commits; unresolved issues growing to more than 110,000 by February 2026), arXiv, 2026. Available: https://arxiv.org/abs/2603.28592
[5] Gartner, Gartner Says 75% of Enterprise Software Engineers Will Use AI Code Assistants by 2028 (up from less than 10% in early 2023), 11 Apr 2024. Available: https://www.gartner.com/en/newsroom/press-releases/2024-04-11-gartner-says-75-percent-of-enterprise-software-engineers-will-use-ai-code-assistants-by-2028
[6] AI Generated Code Technical Debt: How to Manage It (maintenance-cost and “speed vs quality” framing, citing CodeRabbit), BuildMVPFast, Mar 2026. Available: https://www.buildmvpfast.com/blog/ai-generated-code-technical-debt-management-2026
[7] M. Fowler, Technical Debt Quadrant, martinfowler.com, 14 Oct 2009. Available: https://martinfowler.com/bliki/TechnicalDebtQuadrant.html
[8] Cortex, Engineering in the Age of AI: 2026 Benchmark Report (PRs per author +20% year-over-year; incidents per pull request +23.5%; change failure rate ~+30%), 12 Nov 2025. Available: https://www.cortex.io/post/ai-is-making-engineering-faster-but-not-better-state-of-ai-benchmark-2026