In a survey of 300 senior engineering leaders, 79% said their teams could produce code much faster but weren't releasing software any faster.
The saved time hadn't translated into faster releases. That doesn't prove the tools had no value. It does mean that faster code production, on its own, wasn't enough to show an improvement in delivery.
For a company paying for coding agents, that's a reason to look beyond how quickly they produce a patch. What does it cost to get that patch checked, released, and working reliably?
What the Survey Actually Measures
Engineering leaders reported that engineers spent an average of:
- 9.8 hours a week writing code
- 9.7 hours debugging during development
- 7.2 hours debugging problems customers found in production
That adds up to 16.9 hours of debugging a week. These are survey estimates, not tracked hours. They cover debugging across the codebase, so they don't tell us how much involved AI-generated code or whether AI increased the workload.
Coleman Parkes conducted the survey of large US and UK organizations for Undo in July and August 2026. Most respondents worked with C or C++. Undo sells debugging tools and commissioned the research. These findings describe that group, not every software team. Undo's research report
The survey gives us a reported gap between faster production and release speed. It doesn't give us a complete account of where the saved time went. Companies need to measure that in their own teams.
The Work After Generation Still Costs Money
A patch arriving sooner can be useful. The engineer might spend less time writing routine code and have more time for a difficult design problem. A team might finish work it otherwise wouldn't have attempted.
But the patch still needs checking. Someone has to understand what changed, test how it behaves, and see whether it works with the rest of the product. If it introduces a problem, someone has to diagnose and fix it.
Some of that work would exist however the code was written. The cost question is whether the AI-assisted process reduces it, leaves it unchanged, or adds to it.
If generation gets faster while review takes the same amount of time, the team can save effort without releasing sooner because review still limits how much work it can finish. If reviewing and repairing the output takes longer, that extra work can consume the time saved during generation. Faster output can also leave a larger queue waiting for the same reviewers.
Those are different outcomes. Counting generated patches won't tell a manager which one the team is experiencing.
Whose Time Is Being Saved?
The person using the agent and the person checking its output might have different answers.
A developer can finish a task sooner while a senior engineer spends longer reviewing it. A team can merge more changes while operations staff spend longer investigating unexpected behavior. A release can arrive on time while support staff absorb problems customers encounter afterward.
These are costs to check for, not outcomes established for every team in Undo's survey. They explain why measuring only the agent user's time can give an incomplete answer.
The same accounting applies to documentation and training. If maintainers need to reconstruct why generated code behaves as it does, that work takes time. If the team records the important decisions while making the change, it spends time now to avoid some of that reconstruction later.
Neither disappears from the cost simply because it happens outside the coding session.
Count the Tool and the Work Around It
A useful comparison starts with similar work before and after adoption. It should account for:
- Tool costs: Subscriptions, usage charges, and computing resources
- Setup and use: Integration, training, instructions, and repeated attempts
- Review and repair: Checking the output, testing it, and correcting problems
- Release and support: Getting changes into production and handling failures afterward
- Maintenance: Understanding and changing the code later
Teams also need to compare what they received for that spending. Did they finish more useful work? Improve quality? Reduce interruptions? Give engineers time for work they had been postponing?
A company could reasonably pay more for better results. It could also keep spending about the same while delivering more. Those are benefits worth measuring, even when releases don't get faster.
What it cannot do is count time saved during generation as the final saving without checking the rest of the work.
Follow the Saving Through the Release
For the next set of comparable changes, record how much time goes into implementation, review, fixes, and release. Then check the problems that appear afterward. Include the people who receive the output, not only those who generate it.
That gives a team somewhere useful to investigate. If implementation gets quicker but changes spend longer waiting for review, adding more generation capacity won't resolve that delay. If review effort falls and quality holds, the team has evidence of a saving that survives beyond the demo.
AI can produce code quickly. The financial question is how much it costs the organization to turn that code into software it can depend on.
