Skip to content
Reality Graph

Economics

AI Code Churn

Last updated: 2026-11-045 min read

Sources checked 2026-11-048 sourced figures

AI code churn – the share of merged code reworked within two weeks – rose from 3.1% in 2020 to 5.7% in 2024 as AI assistance spread, in GitClear’s 2025 analysis of 211 million changed lines: close to a doubling of the near-term rework share. Churn is the cheapest verification-debt signal you can compute, the lagging confirmation that code shipped before it was checked – and, priced honestly, the visible tip of a larger bill.

Contents

What the metric measures – and why two weeks

Churn counts merged lines that get modified or reverted within a window; the 14-day window is what makes it diagnostic. Rework that fast rarely means requirements changed: it means the change was wrong or incomplete when it merged and nobody caught it. That is why two-week churn functions as the lagging confirmation of verification debt: the leading indicators (unverified merges, falling review depth) predict it, and churn arrives two weeks later as the receipt.

What 211 million lines show

Findings and their boundary

These figures are starting points for your own measurement, not inputs to a combined impact formula.
Two-week churnCopy/pasteMoved codePR volume
Reported3.1% (2020) → 5.7% (2024)GitClear vendor research · 2026-11-048.3% → 12.3%; cloning 4×GitClear vendor research · 2026-11-04~25% → below 10%GitClear vendor research · 2026-11-04+98% PRs merged per developer (2025)Faros AI telemetry · 2026-11-04
Interpretation boundaryTrend, not a universal multiplierEditorial interpretation · 2026-11-04Observation, not a quality causeEditorial interpretation · 2026-11-04Trend, not an architecture diagnosisEditorial interpretation · 2026-11-04Context from a separate datasetEditorial interpretation · 2026-11-04
These figures are starting points for your own measurement, not inputs to a combined impact formula.

The last row matters for the money math. The two figures come from different datasets, so they do not multiply into a result; but in your own repository, a doubled churn rate on a doubled change volumemeans roughly four times the churned lines. That is Reality Graph’s reading, not the sources’, and the metric it names is two-week churn.

The defect supply behind the rework is measured elsewhere too: in Veracode’s 2025 test, 45% of AI-generated code samples failed security tests. We read that as the same problem seen from the security angle; the metric it names is the unverified-merge rate, because a flaw that reaches the main branch got there without a check that caught it.

The honest caveats

  • Not all churn is waste. Fast iteration churns healthily; the debt signal is the delta above your own baseline and its trend, not the absolute number.
  • Vendor-adjacent research. GitClear sells git analytics. The dataset is large and the method is documented in the full report, but the vendor caution applies. That is why the consistent direction across separate signals from other vendors (review telemetry, security test rates) carries the argument.
  • Working titles inflate. Figures like “39% more churn” circulate without a traceable source; we use the numbers the dataset actually supports. Directional honesty beats dramatic precision.

Measuring and reducing your own

Your churn is a git script away: for each merged change, count lines modified again within 14 days: weekly, per repository, trend over absolute. The full recipe sits in measuring verification debt, and the levers that move it are the verification loop itself: written tasks, checks before merge, validation the model did not author. Because the metric is cheap and weekly, it doubles as the before/after gauge for any pilot, and its euro translation lives in the cost calculation.

What the rework costs, once you have measured it

Churn measured, then priced

Churn is a share of lines, so it never becomes a cost on its own. Once your own tickets give you a rework rate for changes, this puts a number on it alongside the reconstruction time that is paid whether anything churned or not.

10
20
Share of merges that are AI-assisted
€75

Estimated cost of verification debt

Example – illustrative arithmetic, not a benchmark

€67,000

per year · €5,580 per month

Modelled on about 120 AI-assisted merges a month.

At these inputs the model puts verification debt at €67,000 a year, or €5,580 a month: 74.4 hours of engineering time, 60 of them spent working out what a change was meant to do before it can be judged.

Past the band.The amber band marks 30 to 40 AI-assisted changes a month, about 19 to 25 hours of modelled debt, on a logarithmic scale so the whole range fits.
Cost linePer monthHours a month
Review reconstruction€4,50060 h
Rework on churned code€1,08014.4 h
Incident allowancenone assumed0 h
Rework and review reconstruction priced from a locally reason-coded rate. Churn is the warning signal, not the input. Illustrative arithmetic, not a benchmark.

What the model assumed for you· Assumption set as of 2026-08-15

0.5 hours of review reconstruction per AI-assisted change · 2 % of AI-assisted changes reworked for a defect within 14 days, an illustrative rate to replace with your own · 6 hours to rework one churned change

Where Reality Graph fits

Reality Graph addresses one preventable contributor to churn: changes merging unchecked against their task. It checks each run against its written task and records a verdict before the merge, so a defect it catches is fixed before the merge instead of reworked after it. Its evidence reports give a churn investigation its starting point: which change, what was checked, what was skipped. Reality Graph does not compute churn; your git history does. We quote no reduction percentage, so measure churn around your own pilot.

This analysis provides

  • Source-bound trend values
  • An explicit causality boundary
  • A team metric measurable each week
  • A bridge to the cost model

It does not provide

  • A universal churn multiplier
  • A claim that all churn is waste
  • Certainty from one vendor dataset
  • A promised reduction
Measure the same definition before and after a process change; do not borrow another dataset's rate.

FAQ

How much does code churn rise with AI coding tools?
One large public dataset is GitClear's 2025 analysis of 211 million changed lines: code reworked within two weeks of being pushed rose from 3.1% in 2020 to 5.7% in 2024 as AI assistance spread, close to a doubling of the near-term rework share. A precise universal multiplier does not exist and codebases differ; the direction and the order of magnitude are what the data supports.
What exactly does the two-week churn metric measure?
The share of merged lines that are modified or reverted within 14 days. The window is the point: rework that fast usually means the change was wrong or incomplete when it merged, too soon for changed requirements to be the normal explanation. That makes two-week churn a proxy for 'shipped before it was verified', which is why it serves as the lagging confirmation of verification debt.
Is all churn bad?
No, and honest analysis prices only part of it as debt. Some churn is fast iteration working as intended: prototypes hardening, feedback landing. The signal is in the delta and the trend: a codebase whose churn doubles as AI volume grows is not iterating twice as healthily. GitClear's accompanying findings point the same direction: duplicated code rising sharply while moved (refactored) code declines, a copy-paste-over-refactor shift that is hard to read as health.
How reliable is the GitClear research?
It is one large public vendor dataset on the question, and its method is documented in the full report (February 2025). Because GitClear sells git analytics and the time trend does not isolate AI as a cause, we treat it as directional evidence rather than a universal baseline. The strongest move remains measuring your own churn with the same definition over time.
What does churn cost in money?
Churn has no price of its own: it is a share of lines, and our cost model deliberately does not read a churn delta as a defect rate. The model's worked example uses 120 AI-assisted changes per month, a 2% locally reason-coded rework rate, six hours per rework, half an hour of review reconstruction per change and €75 per hour. That prices rework at 14.4 hours or €1,080 per month and review reconstruction at 60 hours or €4,500. Churn is the visible signal that tells you to count the rework; the larger line is the review time paid on every change.
How do we reduce AI code churn specifically?
Start with one contributor you can act on: changes merging before anyone checked them against what was actually asked. Written tasks with acceptance criteria, verification before merge and independent validation can move some defects from post-merge rework to pre-merge fixes. Two-week churn is cheap to compute weekly, so use it as a before/after gauge rather than assuming a reduction.

Keep reading

Sources

Want to see what your last agent run would have looked like?

Request access