Thirty minutes saved, an hour spent elsewhere
Take one pull request (PR). A developer uses a coding agent and finishes the implementation 30 minutes faster than they would have by hand. The AI tool's dashboard records the session, the accepted changes and, if the vendor estimates it, the time saved.
Then the PR goes to review. The reviewer asks what a new helper is for. The developer checks with the product owner about an edge case the agent guessed at. A staff engineer spots that the change reads the database directly from a handler the team had agreed would go through the service layer. The continuous integration (CI) pipeline fails twice on a flaky integration test that the new code made slower. The developer rewrites the data access, and the PR goes back for a second review.
Add it up and that downstream work can come to an hour. The figure is an illustration, not a measurement: we have no dataset that says the typical ratio is two to one. The point of the example is where the hour lands. None of it appears on the AI tool's dashboard. It is spread across four people and several systems, and no report charges it back to the tool that saved the 30 minutes.
This guide gives you a way to cost that hour for your own team.
What the research signals say
Recent research points at the same place, from different directions. A September 2026 LeadDev article by Chantal Kapani, built on data from the developer-analytics company DX (its State of AI Impact in Engineering report), reports that AI spending has climbed steeply while the share of engineering time spent on new features has stayed flat. The article argues that work piles up at reviews, approvals and other gates where a person has to judge the change. LeadDev sums up the view of Jeff Watkins, chief AI officer at NorthStar Intelligence: the wider delivery system is absorbing the gains rather than turning them into business value.
A National Bureau of Economic Research (NBER) working paper by Demirer, Musolff and Yang, Writing Code vs. Shipping Code (revised September 2026), studies more than 500,000 GitHub developers. It finds that the gain from autonomous coding agents falls from 240% in coding activity to 30% in releases. We cover that paper in AI throughput is not engineering throughput, and the defect and churn telemetry from Faros AI in why AI productivity gains often lead to more rework.
These are separate studies with separate methods, so read them as signals, not as one funnel. They agree on one thing that matters for costing: the time AI saves at the keyboard and the time it costs later are measured in different places.
Why the AI dashboard never sees the hour
AI coding tools report what happens inside the tool: sessions, suggestions, accepted lines, agent runs, tokens. Those numbers are useful adoption signals. They cannot see anything that happens after the developer pushes.
The downstream hour lives in systems the AI budget owner rarely reads. Review time sits in the code host. CI minutes sit in the build system's bill. Clarification sits in chat threads and issue comments. Senior engineers' architecture corrections sit nowhere at all, because nobody logs the twenty minutes a staff engineer spends explaining a boundary in a PR comment.
One stage makes the picture worse. When the developer rewrites the change, the new commits show up in activity metrics as more output. A rework cycle can raise the very numbers that suggest AI is working.
Itemise the downstream hour
Break the hour into stages. For each one, name who pays and which system holds any record of the time. The minutes below are the same illustration as above, not benchmarks.
| Stage | Who pays | Where the time is logged | Illustrative minutes |
|---|---|---|---|
| Review | Peer reviewer | Code host: review requested and approved timestamps, not hours worked | 15 |
| Clarification | Author, product owner, reviewer | Chat threads and issue comments; usually not logged as time | 10 |
| Architecture correction | Staff or principal engineer | PR comments or a meeting; almost never logged | 10 |
| CI reruns | Author's waiting time, plus the CI budget | CI system: run count, retries and billed minutes | 5 |
| Rewrite | Author | Version control: new commits, which activity metrics count as output | 12 |
| Re-review | Peer reviewer, sometimes the staff engineer again | Code host: a second review round | 8 |
Look at the second column. The author pays for the rewrite, the CI waits and some clarification. Most of the hour falls on other people, and the most expensive slice falls on the most senior person in the chain. Now look at the third: only CI produces a machine-readable cost. Everything else has to be reconstructed from timestamps, comment threads and estimates.
The verification step itself, the reviewer working out whether a generated change is safe to merge, has its own article: the verification tax of AI coding agents. This method treats review as one line among six.
A costing method you can run in one sprint
You do not need a new tool to run a first pass. You need a sample, a baseline and an agreed rule for turning records into hours.
- Pick two samples. Take 20 to 30 merged PRs where an agent wrote most of the change, and a similar number of comparable PRs written mostly by hand. Match them roughly by area of the codebase and size.
- Pull the records you already have. From the code host: review rounds, time from first review request to approval, and commits pushed after the first review. From CI: runs per merged PR and retries. From chat and the issue tracker: clarification threads linked to the PR.
- Collect the missing hours directly. For the length of the sprint, ask reviewers and senior engineers to note minutes spent per PR, with a tag for the stage. Two weeks of rough self-reporting beats a year of guessing.
- Subtract the baseline. Hand-written PRs also get reviewed, questioned and rewritten. Only the difference between the two samples is chargeable to the tool. Skip this step and you will overstate the cost.
- Price the hours by who spent them. An hour of staff-engineer correction costs more than an hour of author rewrite, and it also displaces the design work that person was hired to do. Use loaded cost rates by level (salary plus benefits, taxes and overhead, per hour worked), not one blended rate.
- Charge it back. Net saving per PR equals the implementation time saved, minus the extra downstream hours, each priced at the rate of the person who spent them. Report the net figure next to the vendor's gross figure, not instead of it.
A worked illustration, with invented numbers: say the agent sample saves 30 minutes per PR at implementation, and the downstream stages take 50 minutes per PR longer than in the hand-written sample, of which 15 are staff-engineer time. That 50 is lower than the 60 in the table because it is what remains after subtracting the hand-written baseline: some review and clarification happens whoever writes the code.
At a loaded rate of 90 an hour, in whatever currency you budget in, for the author and reviewer and 150 for the staff engineer, the saving is worth 45 and the extra downstream time costs 90 (35 minutes at 90 is 52.50, plus 15 minutes at 150 is 37.50). The net is minus 45 per PR. The vendor dashboard would show the 30 minutes and nothing else.
Run the same sample again a quarter later. The trend matters more than the first number, because rework from one month of AI-assisted work can surface in the next month's reviews.
What the method will not tell you
Tell whoever reads the result about three limits. Attribution is noisy: a PR can need clarification because the ticket was vague, whoever wrote the code. Small samples swing. Self-reported minutes run low for senior engineers, who rarely think of a PR comment as work.
It also does not judge developer-productivity metrics. Task time and AI-assisted work rates are fair leading indicators of adoption. They describe the input. The charge-back describes what the organisation keeps after the downstream stages take their share, which is the number a budget decision needs. AI Engineering ROI: How to Measure the Real Return From AI Coding sets out the wider measurement model this sits inside.
A negative net figure for one team is not a verdict on the tool either. It usually points at a specific stage, and the stage tells you what to fix: unclear tickets, slow tests, or decisions that the agent never saw.
Where governance moves the hour
In this example, two of the six stages, architecture correction and the rewrite that follows it, trace back to a decision the team had already made and the agent did not follow. When rework has that cause, it is the easiest cost to move earlier, because the decision exists before the code does. If a check against the decision runs before review, the staff engineer's correction can become a check result the author fixes in minutes, and the re-review round can disappear.
That is the problem engineering decision governance addresses, and it is where Mneme, an open-source tool for governing AI coding agents, works: once a team turns a decision into a machine-checkable rule and switches that rule on, Mneme checks it in supported coding agents and in CI, and blocks a violation in strict mode. It does nothing about vague tickets or flaky tests, which stay on your list.