GitClear's 623 million change analysis shows the output gain is real, and much smaller than the maintenance bill behind it.
Since they arrived on the scene, a great swathe of the software industry has pinned its hopes on AI tools, whether that’s early chat interfaces or modern agentic swarms. But the tone has changed over the past few weeks, with HR software provider Rippling adding an anti-tokenmaxxing AI spend console to give CFOs and CTOs a view over spend and IBM Vice Chairman Gary Cohn saying recently that the ROI has “not been nearly as high as people might think.” As the northern hemisphere feels the Fall cooldown, it seems that Winter is coming for AI tool budgets.
As organizations start balancing the books, teams will start seeing pressure on their Claude Code and Cursor budgets. That means they may be facing the prospect of hitting harder usage limits where returns are unclear, or where budgets can’t sustain the usage levels.
For organizations that have worked out how to measure the impact of AI, there’s a growing realization that generating volumes of code at pace doesn’t guarantee any movement in the metrics that matter. If you count lines of code, the number of pull requests, or even the number of features delivered, you’ll see no clear relationship to value. Not every line of code or feature is worth the same to the business or its customers. The distribution in this respect is galaxy-wide.
Even at the output level, many organizations haven’t worked out how to turn siloed gains into end-to-end improvements. The gains made in coding speed transfer to new tasks introduced by AI or are absorbed by downstream changes. If you hadn’t worked out the inherent properties of value streams before you bought AI, you’ll be getting painful lessons when you try to track your ROI.
If the only problem were translating the cost of AI tools into end-to-end value, it would be serious enough. But something far worse is happening.
Productivity in terms of output
Let’s get into the data, which GitClear collected and analyzed for the Maintainability Gap report. This is a substantial dataset, with millions of change operations included across three and a half years. As teams rapidly adopt AI developer environments and tools such as Cursor and Claude Code, GitClear’s code-change-operation database allows them to detect and classify code duplication, hotspots, and signals of good or poor code factoring.
The measured increase in coding output across the industry is a modest 1.3x, far from the claims of 10x increases. Teams that did outperform their peers in terms of output were doing so before AI tooling arrived. And remember, there’s no guarantee this output will accrue to the value stream, or provide meaningful value to the organization or its customers.
The first part of the ROI calculation is to determine whether these increases are worth the cost. For many organizations, I would be surprised if they were.
Perhaps because much of the discussion of AI tools has focused on speed, not much attention has been paid to other factors. The software industry may have found a different kind of value if it had focused on the tools as a forklift truck, rather than a racing car, because the straight-line speed doesn’t seem so impressive. Yet they can perform heavy lifts that are tricky for us mere humans, like large-scale changes across a codebase, like replacing an unmaintained library with a replacement.
For those who pass this first gate, we can look at the next factor.
Productivity in terms of code quality
The shift to AI has brought about a giant behavioral change in the software industry. For several decades, the importance of code maintainability has been emphasized repeatedly. More than half of the programming books on my shelf are dedicated to questions of architecture, code design, coupling, and cleanliness. The idea of refactoring, supported by a set of automated tests, is present across many of these books.
Yet the signals GitClear is getting from the data are a complete reversal: a return to the code-and-fix era of software development. Duplicated lines and code blocks are on the rise, creating opportunities for these multiple expressions of the same concept to drift apart and create whack-a-mole bugs to emerge. A dramatic drop in refactoring means code is becoming harder to understand, which will likely impact the maintainers with or without AI.

Source: GitClear.
When you make these changes, you get away with it initially because you’re early in the maintenance cost curve. Over time, however, the rising costs will become unbearable. Rework rates will rise, stealing time from new feature development. Seemingly minor issues will take far too long to pinpoint and resolve, with many simply becoming part of how it works because the fix is economically unviable. The accumulation of tightly coupled, incomprehensible code units will reach the point where the software ceases to be valuable.
We’ve been trying to validate the claims of 10x boosts with AI coding assistants. Now we’re getting 10x the amount of code duplication, we finally have.
Technical practices are the mission, not a side quest
When I’ve presented at conferences and user groups on what great software delivery looks like, I mention, among other things, test automation and refactoring. In the Q&A that follows, this question will inevitably come up in one form or another: “How do I get permission from my boss to do these things?”
Developers are whipped hard for fast progress, so they are trained to avoid what they see as the side quest. If they need to increase their output, they need to streamline coding tasks, which means there’s no time to write tests or improve the code’s design, as that would delay the feature. Inevitably, this makes all feature development vastly slower over time.
The underlying premise of lightweight software delivery processes is that they are underpinned by technical practices that control the cost to maintain software over time. The wisdom tells us that working more deliberately today means we can maintain the pace of change indefinitely. If we skip these practices, change becomes increasingly slow and expensive.

Based on figures in Extreme Programming Explained (Beck, 1999).
Those technical practices, like test automation and refactoring, aren’t side quests; they are the work. Technical discipline is a fundamental requirement of commercial software delivery, and these practices stopped being optional some time ago.
When asked for techniques to convince managers to allow these practices, I’m confused. I’ve never asked for permission to do what is right for me, the software, its users, and the organization. There is no compromise to be reached as omitting technical practices harms absolutely everyone involved.
This “side quest” thinking was unresolved in many organizations, and adding AI into the mix has made things far worse. When teams are given AI tools, the expectation of a big return comes with them. When teams are, in reality, getting a 1.3x increase in their rate of change against an industry misperception of some 10x boost, they are going to feel even more pressure to deliver.
Under these dysfunctional circumstances, it’s no wonder those who consider good practice to be a side quest are skipping crucial steps.
High-performing teams have worked out that there’s a set of practices for software delivery that stopped being optional. They realized because they were scaling long before the new tools.
For software that matters, that people depend on, and that still needs to exist in a year, in five years, and beyond, we’ve moved from the pick-and-mix of the past, and there’s a new bar for professional software delivery.
There is a glimmer of hope here. The teams that are doing well with AI are the same teams that were outpacing the industry before AI. They maintain rigorous technical disciplines, monitor code health indicators, and prioritize the craft of keeping code maintainable for the long haul.