The Debt Nobody Prices: AI-Generated Code

TL;DR: Every borrowed shortcut in a codebase carries interest, but AI-generated code is the first debt instrument teams take on at scale without anyone signing for it. The repo-level data is unambiguous: duplication up 81%, refactoring line-moves down 70%, two-week churn up 15%, bugs per developer up 54% at high adoption. None of it appears on any invoice at merge time. Below: what the liability looks like in git, and how to price it before it prices you.

Why AI-generated code creates technical debt

Technical debt, classically, is a trade someone chooses: ship the shortcut now, pay the interest later. What makes the AI era different is that the trade happens by default, at generation speed, with nobody signing the loan.

The mechanism is mundane. When a model can produce a working fresh variant faster than a developer can find and understand the existing abstraction, copy-paste stops being a shameful shortcut and becomes the path of least resistance. Each individual choice is defensible - the sprint ends Friday. The aggregate is a codebase that grows by accretion instead of refinement: new logic piling up beside old logic, drifting apart, waiting to be fixed in one place and stay broken in the other.

That's not a hypothetical decay curve. It's now one of the best-measured phenomena in software.

What the repo data shows

GitClear's 2026 "Maintainability Gap" report analyzed 623 million code changes from 2023 to 2026 and reads like a debt schedule, in the study's own units and against the study's own baseline years:

• Code-block duplication up 81% against 2023 (40.3 duplicated blocks per million lines in 2023, 73.0 year to date in 2026).
• Within-commit copy/paste rose from 9.4% of changed lines in 2022 to 15.7% in the first half of 2026.
• Refactoring line-moves down 70% against 2022 levels. The share series is steeper still: moved code fell from 21% of changed lines in 2022 to 13% in 2023 and 3.8% year to date in 2026.
• Two-week churn up 15%: more shipped code rewritten or discarded within weeks.

Read the duplication line against the refactoring line and you have the whole instrument: copies going in faster than anything consolidates them.

The direction was already visible in GitClear's 2025 research across 211 million changed lines, which measured cloned lines rising from 8.3% of changed code in 2020 to 12.3% in 2024 while refactoring's share sank from 25% of changed lines in 2021 to under 10% in 2024. And the interest payments have started arriving: Faros AI measured bugs per developer up 54% at high AI adoption, across two years of telemetry from 22,000 developers on 4,000 teams.

One more number belongs next to those, from before the AI wave crested: in the Stack Overflow 2024 survey, technical debt was already professional developers' top frustration, cited by 62.4%, roughly twice the next answer on the list. AI didn't create the debt problem. It attached a compressor to it, and aimed it at the thing your engineers already hated most.

The three line items nobody prices

At merge time, generated code is free - the seat was already paid for, and the diff looks like productivity. The liability hides in three line items that never appear on the AI dashboard:

1. Duplication: every future fix, multiplied. A duplicated block isn't one cost; it's a subscription. Each copy must be found, understood, fixed, and tested every time the logic changes - and the copy nobody found is the next incident. When duplication rises 81% while refactoring line-moves fall 70%, the codebase is accumulating copies faster than it consolidates them. That ratio is the debt curve.

2. Churn: work paid for twice. Code rewritten within two weeks of shipping was written, reviewed, merged, and deployed - then again. It's the most direct price tag on generated code that didn't survive; the measurement playbook, including how to separate healthy iteration from expensive regression, is in AI code churn, and the team-level version of the same instrument is your rework rate.

3. Review burden: the safety net billed by the hour. Generation multiplied code output; it did not multiply reviewers. Either review hours grow to match volume (a real, recurring cost) or review depth thins (a deferred, larger cost that converts directly into line items 1 and 2). There is no third option. Watch the ratio of review comments to changed lines across your adoption curve: when it halves, your debt intake doubled without anyone making a decision. Pretending otherwise is how AI slop gets merged with an approval on it.

How to price the debt

Debt you can price, you can manage. None of this needs a new platform; your git history already holds every number below. The pricing takes three trend lines and a rate card:

1. Chart duplication and moved-code ratios across your AI-adoption boundary. If copy/paste climbs while refactoring moves collapse, you're watching principal accumulate, per directory, with receipts.
2. Fix a churn window and track it. Two weeks post-merge, held constant. Shipped lines rewritten inside the window are your interest payments, countable each month.
3. Convert to money at loaded cost. Rework hours, duplicate-fix hours, and added review hours all convert through your engineer cost rate. The general method for turning debt trends into a number a CFO respects is in the cost of technical debt.
4. Put survival on the scoreboard. Report "shipped and still standing after 90 days" next to throughput. The moment leadership celebrates code that survives, the duplication discount stops being free.

None of this requires turning the tools off; the balanced evidence, gains included, is laid out in AI-assisted development: what the evidence says. It requires treating generated code as what it is: borrowed capacity. Borrowing is wonderful in a system that measures its liabilities and lethal in one that only counts its gains.

The debt nobody prices still gets collected. The only choice you have is whether the number shows up on your dashboard this quarter or in your incident reviews next year.