Key Takeaways
- AI coding tools make individual developers measurably faster, but the system-level costs accumulate in places that traditional velocity metrics were never designed to detect.
- GitClear's 2026 Maintainability Gap report found refactoring activity collapsed from 21% of changed lines in 2022 to 3.8% year-to-date in 2026, while block duplication hit its highest level on record.
- The measurement problem compounds across review cycles. Faros AI's 2026 telemetry across 22,000 developers found that the median PR review time increased by 441%, and 31% more PRs are merging without review.
- 66% of developers cite "almost right but not quite" AI code as their top frustration, and 45% say debugging AI-generated code takes longer than writing it themselves, according to Stack Overflow's 2025 Developer Survey.
- Engineering leaders who measure only individual developer speed are optimizing for the one dimension AI already improved, while the dimensions that determine actual delivery quality go untracked.
Something odd is happening in engineering organizations right now. GitHub's controlled experiment found that developers using Copilot completed tasks 55% faster. And yet, delivery timelines haven't budged. Some have gotten worse.
CFOs want to know why the AI budget isn't translating into faster releases or smaller teams. CTOs find themselves defending tools that clearly help individual contributors while struggling to point to anything concrete at the system level.
This issue shows up in sprint retrospectives across organizations. Individual developers check off tasks faster than before. Project management dashboards look great. But the same teams keep missing release targets, and technical debt piles up in ways that feel harder to unwind. Measuring story points completed, pull requests merged, and lines of code written made sense when coding was the bottleneck. And they still tell you something. They just don’t tell you the whole story.
The Productivity Paradox Is Real and Documented
The most authoritative evidence comes from Google's 2024 DORA report, which surveyed roughly 3,000 professionals and represents a decade of DevOps performance data. It found that every 25% increase in AI adoption correlates with a 7.2% decrease in delivery stability. Throughput also dipped, by 1.5%, for the same level of adoption increase.
That’s the paradox. The same tools that make individual developers faster are, at the system level, correlating with less stable, less predictable delivery. DORA's own analysis attributes much of this to batch size: AI makes it easier to write more code, and larger changesets introduce more risk.
The 2025 DORA report noted that throughput slowdowns had stabilized. But delivery instability remains an open problem, and the pattern of individual gains masking system-level costs has not been resolved.
What’s Happening to the Codebase
The most detailed view comes from GitClear's 2025 AI Copilot Code Quality research, which analyzed 211 million changed lines of code from 2020 through 2024 across anonymized commercial repositories and major open-source projects.
The findings are consistent. Refactoring activity dropped from 25% of changed lines in 2021 to under 10% in 2024. The use of code that had been copied and pasted rose from 8.3% to 12.3% over the same period. In 2024, for the first time in the dataset, copy-paste volume exceeded refactoring volume. Duplicated code blocks of five or more lines increased eightfold during 2024 alone.
Code churn tells the same story from a different angle. GitClear defines churn as lines revised or reverted within two weeks of being written, the clearest signal of low-quality commits. Churn rose from 3.1% of changed lines in 2020 to 5.7% in 2024. More code is being generated, less of it is carefully structured, and more of it needs immediate correction.
None of this appears in velocity charts. All of it shows up later in maintenance costs.
The Comprehension Debt
The second hidden cost is less visible in aggregate data but shows up consistently in developer surveys. Stack Overflow's 2025 Developer Survey, conducted with over 49,000 respondents across 177 countries, found that 66% of developers cite "AI solutions that are almost right, but not quite" as their top frustration, and 45% say debugging AI-generated code is more time-consuming than writing it themselves.
This is what practitioners now call comprehension debt: the time cost of understanding that AI generated without encoding its logic into the surrounding codebase's patterns and abstractions. It shows up as a longer code review, a slower onboarding for the next developer who touches that file, and a debug cycle that extends because the engineer fixing the issue only half-understood the code when they approved it.
This becomes most visible in code reviews. Senior engineers evaluate AI-generated code against architectural standards, integration risks, and long-term maintainability, not just whether it functions. This review work is invisible in traditional metrics, which treat a merged pull request as equivalent regardless of the review effort.
Why Traditional Metrics Miss This Entirely
Engineering measurement frameworks inherited their structure from a time when writing code was the primary bottleneck. Story points completed, pull requests merged, lines of code written, these measurements made sense when generating code was hard. AI changed the equation. Code generation isn't the bottleneck anymore, but system-level integration, architectural coherence, and long-term maintainability still are. The metrics haven't adapted.
The financial consequence of ignoring this is significant. AlixPartners analysis found that by 2025, approximately 40% of IT budgets at large organizations were being directed toward maintaining existing technical debt rather than building new value. AI-generated code is accelerating the rate at which that debt accumulates, while the metrics used to justify AI investment measure only the speed at which new code is being added.
Consider what this means in practice. AI assistants generate functional code quickly, but that speed comes with a cost that doesn't show up anywhere obvious. Developers spend more time understanding both their own and their teammates' AI-generated code than they save during initial writing.
Debug cycles extend when issues emerge in code that someone only half-understood when they approved it. Integration testing surfaces additional complications: AI-generated code often functions correctly in isolation but can cause unexpected interactions when combined with existing systems, leading to longer debugging cycles and more complex root-cause analysis.
What to Measure Instead
Measurement reform requires extending existing frameworks to account for the changes AI has introduced.
Track comprehension time alongside velocity. Time spent understanding existing systems, including AI-generated code, reveals the hidden costs that traditional measurements ignore. Developers don't naturally track this time, and self-reporting tends to significantly underestimate it. Engineering tools that record actual time on file exploration, code reading, and review deliver a more accurate picture.
Shift to deployment and stability metrics. Deployment frequency, rollback rates, change failure rates, and time to restore reflect system-level outcomes rather than individual throughput. A team shipping fast but rolling back often looks very different through this lens than it does in a velocity chart. Taazaa's breakdown of DORA metrics and executive reporting explains how these metrics are translated from engineering dashboards into language that finance and operations stakeholders can act on.
Monitor code health indicators directly. Churn rate, duplication rate, and refactoring activity are now trackable through tools that analyze repository structure longitudinally. GitClear's research demonstrates the value of this approach at scale. What gets measured gets managed, and right now, the most important code health signals are being left unmeasured in most organizations.
Anchor AI tool ROI to system-level outcomes. The 55% individual speed increase means very little if delivery stability is declining 7.2% for every 25% of adoption. ROI measurement for AI coding tools needs to include stability metrics, not just velocity metrics, or the productivity story it tells will consistently lead to decisions that look good on a dashboard but turn into problems in production.
Where This Is Going
The pattern GitClear identified reflects the current state of AI tool use rather than its ceiling. Development teams are still calibrating how to use these tools well. The DORA findings for 2025 already show some stabilization in throughput impacts. Whether the comprehension tax declines permanently with experience is still an open question.
Investment priorities likely need to be rebalanced toward code comprehension tools, documentation systems, and architectural visibility platforms. Team incentive structures may also need to be revisited. Current reward systems that prioritize individual throughput create misaligned incentives when AI tools enable rapid code generation without corresponding improvements in system maintainability.
The path forward starts with an audit of your current metrics. What are you measuring? What are you missing? The organizations that establish system-level measurement practices now, before AI adoption deepens further, will have better visibility and better outcomes than those that continue measuring only individual developer speed.
Frequently Asked Questions
Why does AI coding feel productive individually but not improve delivery at the team level?
Google's 2024 DORA research found that every 25% increase in AI adoption correlated with a 7.2% decrease in delivery stability. AI enables larger changesets, which introduce more integration risk. The code is written faster; the review, integration, and debugging work downstream grows proportionally.
What is comprehension debt, and why does it matter?
Comprehension debt is the accumulated cost of understanding code generated without encoding its logic into the surrounding codebase's patterns. It shows up as longer code reviews, slower onboarding, and extended debug cycles. Stack Overflow's 2025 survey found 45% of developers say debugging AI-generated code takes longer than writing it themselves.
What does GitClear's research show about code quality?
Across 211 million lines of code analyzed from 2020 to 2024, refactoring activity dropped from 25% to under 10% of changed lines, copy-paste volume rose 48%, and code churn nearly doubled. In 2024, copy-paste exceeded refactoring for the first time in the dataset. These are structural signals of declining maintainability, not anecdotal observations.
What metrics should engineering leaders track alongside velocity?
Deploy frequency, rollback rate, change failure rate, and time to restore measure system-level outcomes. Code churn, duplication rate, and refactoring activity are indicators of codebase health. Comprehension time, while harder to track, makes the hidden cost of AI-generated code visible before it compounds into a maintenance problem.
Does this mean AI coding tools aren't worth using?
No. The research argues for measurement discipline, not tool abandonment. GitHub's controlled study found genuine, statistically significant gains in individual productivity. The problem is that organizations measure only those gains while system-level costs accumulate unmeasured. ROI calculations need to include stability and maintainability metrics alongside velocity to be accurate.
.webp)
