AI Coding Tools Deliver 25% Gains, But Duplication Soars 81% as Quality Suffers

The software industry's enthusiasm for AI coding assistants is colliding with hard data about their actual impact. A new analysis from GitClear examining 623 million code changes spanning 2023 to 2026 shows that organizations investing heavily in tools like Cursor and Claude Code are seeing real productivity gains—but at a cost that may not justify the expense, and with troubling side effects on code quality.

The shift in sentiment is already visible. HR software company Rippling recently introduced an anti-tokenmaxxing AI spend console to help CFOs and CTOs track expenditures, while IBM Vice Chairman Gary Cohn stated last week that the ROI has "not been nearly as high as people might think." As budget pressures mount, organizations are beginning to scrutinize whether their AI tool investments are delivering value.

The pressure on spending is real. Teams face tightening usage limits on AI coding assistants as organizations struggle to demonstrate clear returns, or budgets that cannot sustain current consumption levels. Many companies have yet to establish reliable metrics for measuring AI's impact on their business outcomes.

For organizations attempting to measure AI's contribution, a troubling pattern emerges: generating more code does not automatically translate to business value. Lines of code written, pull requests submitted, and features shipped show no clear correlation with what actually matters to the business or its customers. The relationship between output volume and meaningful progress is highly variable across teams and organizations.

Even when teams do see productivity improvements, those gains often fail to compound. Speed increases in coding tasks get redirected toward new work introduced by AI itself, or absorbed by downstream changes. Without first understanding how value flows through an organization's development process, teams cannot accurately calculate their return on investment in AI tools.

Output gains are real but modest

GitClear's Maintainability Gap report, published in June, draws from a substantial dataset spanning three and a half years of code change operations. The analysis reveals a critical gap between industry expectations and actual performance.

Teams that adopted AI tools heavily achieved a 25% increase in their own prior velocity—far below the 10x productivity claims that circulated when these tools first emerged. Heavy AI users do outproduce non-AI users by 4 to 10x, but this comparison is misleading: the teams showing the largest output gains were already outperforming their peers before AI arrived. Superior teams remained superior; AI amplified existing advantages rather than leveling the playing field.

Whether a 25% output increase justifies the cost of AI tooling remains an open question for many organizations. The economics may not work in their favor.

Industry discussion has centered almost entirely on speed, overlooking other potential uses. AI coding tools might be better understood as heavy-duty equipment for large-scale refactoring tasks—replacing unmaintained libraries across a codebase, for example—rather than as racing cars for raw velocity. From this perspective, the straight-line speed gains look less impressive, but the capability to perform difficult, labor-intensive changes becomes more valuable.

Code quality deteriorates sharply

The data reveals a troubling behavioral shift. For decades, the software industry has emphasized code maintainability, refactoring, and clean architecture. Yet GitClear's findings suggest a reversal: a return to the code-and-fix development model that characterized earlier eras of software engineering.

Block duplication—multiple instances of the same code concept—rose 81% over the period from 2023 to 2026, climbing from 40.3 to 73.0 instances per million changed lines. As duplicated code drifts apart over time, it creates maintenance nightmares and whack-a-mole bugs. Meanwhile, moved code—the signature of refactoring work—collapsed from 21% of changed lines in 2022 to 3.8% in 2026. Code is becoming harder to understand, a problem that will plague maintainers regardless of whether they use AI.

This approach works initially because maintenance costs accumulate slowly. Over time, however, the bill comes due. Rework rates climb, stealing time from new feature development. Small issues become expensive to diagnose and fix, often left unfixed because remediation is economically unjustifiable. Tightly coupled, incomprehensible code eventually becomes a liability that destroys the software's value.

Before AI, developers chose refactoring over copy-and-paste at roughly a two-to-one ratio. Today, they are approximately five times more likely to copy and paste. The data contradicts claims of 10x productivity gains; instead, it documents a fundamental shift in coding behavior toward practices that harm long-term maintainability.

Technical discipline is not optional

At industry conferences, when the topic turns to test automation and refactoring, a question inevitably arises: "How do I get permission from my boss to do these things?" The question itself reveals a dysfunction. Developers face intense pressure for speed, so they treat technical practices as optional side quests rather than core work. They skip testing and design improvements to ship features faster, unaware that this approach makes all future development slower and more expensive.

The foundation of sustainable software delivery is technical discipline. Test automation and refactoring are not luxuries or optional enhancements; they are the work itself. These practices control the cost of maintaining software over time, allowing teams to sustain their pace of change indefinitely. Skip them, and change becomes progressively slower and more costly.

The "side quest" mentality was already a problem in many organizations before AI arrived. Adding AI tools has amplified the dysfunction. When teams receive AI coding assistants, expectations for dramatic productivity gains follow. But when actual gains reach only 25% against an industry narrative of 10x improvements, pressure intensifies to deliver more. Under these conditions, teams treating good practice as optional are skipping even more crucial steps.

High performers maintain the discipline

A bright spot exists in the data: the teams succeeding with AI are the same teams that outpaced the industry before AI arrived. They understood long ago that software delivery practices are no longer optional. They scaled successfully before these tools existed, and they continue to succeed because they maintain rigorous technical discipline, monitor code health indicators, and prioritize keeping code maintainable for the long term.

For software that matters—that people depend on and that must continue to function in five years and beyond—the industry has moved past the pick-and-mix approach of earlier decades. A new standard for professional software delivery has emerged, and it includes technical practices that cannot be compromised.