The software industry's enthusiasm for AI coding assistants is colliding with uncomfortable data. GitClear's examination of 623 million code changes spanning 2023 to 2026 shows that heavy AI users achieved a 25% increase in their own prior output velocity—far below the 10x claims circulating through the industry. Meanwhile, code duplication metrics have deteriorated sharply, signaling a return to practices that will compound maintenance costs over time.
The shift in tone around AI tool spending reflects growing skepticism among executives. HR software provider Rippling recently launched an anti-tokenmaxxing console to help CFOs and CTOs track AI 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 question whether their Claude Code and Cursor spending translates into meaningful business value.
The challenge extends beyond simple ROI calculation. Many teams have not established how to measure AI's impact on metrics that actually matter to the business. Increases in lines of code, pull request volume, or feature count show no clear correlation with organizational value. Productivity gains in isolated coding tasks often transfer to new work introduced by AI tools or get absorbed by downstream changes, rather than flowing through to end-to-end improvements.
Output gains mask quality deterioration
GitClear's Maintainability Gap report, published in June, reveals a troubling pattern in how developers are using AI assistance. Teams that adopted AI tools heavily outproduce non-AI users by 4 to 10x—but these same teams were already outperforming their peers before AI arrived. The real concern lies not in the output metric itself, but in how that output is being generated.
Block duplication across the dataset rose 81% over 2023, climbing from 40.3 to 73.0 instances per million changed lines. Simultaneously, moved code—the signature of refactoring work—plummeted from 21% of changed lines in 2022 to 3.8% in 2026. This inversion of long-established software engineering practices suggests developers are choosing copy-and-paste solutions over thoughtful code reuse. Before AI adoption, developers favored refactoring over duplication by roughly two to one; that ratio has now flipped to five times more likely to duplicate.
The immediate consequences remain hidden because new code sits early on the maintenance cost curve. Over time, however, the accumulated weight of duplicated, tightly coupled code units will exact a price. Rework rates will climb, stealing development capacity from new features. Debugging will become exponentially harder as multiple diverging copies of the same logic create whack-a-mole problems. Eventually, the software stops being economically viable to maintain.
Technical discipline is not optional
The root cause of this deterioration traces back to organizational pressure for speed. Developers face relentless demands for fast progress and are trained to view test automation and refactoring as optional side quests rather than core work. When AI tools arrive with expectations of massive productivity gains, the pressure intensifies. Teams seeing 25% improvements against industry hype of 10x boosts feel compelled to cut corners further.
Yet decades of software engineering literature—from architecture and design patterns to refactoring and test-driven development—establishes that technical practices are not luxuries. They are the foundation of sustainable software delivery. Lightweight development processes depend entirely on these practices to control maintenance costs over time. Working deliberately today preserves the pace of change indefinitely; skipping these steps makes all future development vastly slower and more expensive.
The premise that technical discipline can be deferred in favor of speed is fundamentally flawed. For software that must exist and function in five years and beyond, there is no pick-and-mix approach. Professional software delivery requires rigorous adherence to these practices, not as a negotiable preference but as a non-negotiable requirement.
High performers maintain the difference
A critical insight emerges from the data: teams performing well with AI are the same teams that outpaced the industry before AI arrived. These high-performing organizations maintain rigorous technical disciplines, monitor code health indicators continuously, and prioritize the craft of keeping code maintainable for the long term. They scaled successfully before AI tools existed, which is precisely why they continue to scale successfully with them.
The divergence between teams will widen. Organizations that treat technical practices as optional will accumulate maintenance debt that eventually strangles their ability to deliver. Teams that view these practices as core mission work will continue extracting genuine value from AI tools while maintaining the code quality that enables sustained delivery. The data suggests the industry has reached a new baseline: technical discipline is no longer optional for any organization building software that matters.