Technical debt from AI coding agents: how to measure the bill

Technical debt written by coding agents never shows up as a bug, it shows up as schedule. Three counts you can run this afternoon, plus what to change in code review.

The new debt arrives in the pull request approved in four minutes

The technical debt that will squeeze your next fiscal year was written this week. An agent pushed it, a human skimmed it for about four minutes, and it got merged because the tests were green. You do not need a new tool to size it. You need three counts that fit in one afternoon: how much of the code merged in the last 90 days can someone on the team explain without opening the file, how many near identical blocks were created in that window solving the same thing in different places, and how many business rules shipped without a person deciding the rule.

Those three answers are your real debt, and it never shows up as a bug. It shows up as schedule. The change that used to take two weeks starts taking six, nobody can quite say why, and the honest answer is that no one in the building understands the part of the system that has to change. The bill lands on whoever opens that file about fourteen months from now, and that person probably has not been hired yet.

Results are thin and the budget keeps growing

When nobody can explain the rule, the roadmap review turns into archaeology

CIO Dive reported yesterday that enterprises keep betting on coding agents despite results well below the promise, citing McKinsey data on AI budgets running over in most companies. The overrun is the part finance sees. What the overrun buys shows up later: code arriving faster than any team's ability to understand what arrived.

The New Stack published a number that gives it shape. With AI in the loop, code volume rose around 25% and duplication jumped 81%. The first number becomes a quarterly slide. The second one surfaces the day a commission rule changes and you find it written in four places, with three slightly different behaviours, each one passing its own test.

That is technical debt in the sense that matters to whoever runs the business. Cost, schedule and revenue trapped in a detail that appears in no engineering report.

Three counts that fit in one afternoon

1. Take the pull requests from the last 90 days, pick ten at random, and ask whoever approved them to explain, without opening the file, what the code does and why it was written that way. The share of "I don't remember" is your orphan code rate. Past a third, you are already maintaining a third party system inside your own repo.
2. Run any duplication detector and look only at blocks created after agents joined the workflow. Old duplication is known history. New duplication is a decision someone approved this week without noticing.
3. List the business rules whose behaviour changed this quarter, pricing, commission, discount, credit limit, eligibility, and find the name of the person who decided each one. A rule with no human owner is the one that blocks your next enterprise negotiation, because nobody can state what the system does when the customer asks.

After those three counts the conversation stops being about code quality and becomes about risk, which is the language boards decide in.

The commission rule nobody remembers agreeing to

Whoever opens this file in fourteen months was not in the room when the agent wrote it

I counted the branches in a pricing service I inherited: 1,043 conditionals. In the last twelve months, 34 of them changed, roughly 3%. The rest were there because someone, in some meeting, needed to cover a specific case and never wrote down which case. Humans built that service over years. An agent produces the same volume in weeks, with one difference that changes everything: you cannot call the author into the room to remember.

I see this from both chairs. I founded Revin and I also run technology at a listed company, covering two large ecosystems where my job is clearing the path so the team can execute. The request that reaches my desk is almost never "go refactor that". It is "why does this take so long now". Same sentence, spoken about twelve months apart.

"But the agent writes the tests too"

It does. That is exactly where the bill grows without setting off an alarm. Generated tests cover what the model understood about your code, which is one thing, while what your business needs guaranteed is another. I have seen high coverage held up by tests with no assertion at all: the file runs, the dashboard number climbs, and nothing is actually verified. The metric exists, the guarantee does not.

This lands in two bad places. In the incident, when the team finds the whole suite green while customers cannot complete checkout. And on the diligence call, where a buyer asks how the rule behind your revenue is validated and the room goes quiet. If you are hiring engineering to carry that risk, the rate card matters less than who stays, and the developer rates in Brazil for 2026 only make sense read against that.

What changes in code review when the author is not a person

Three cheap changes that do not stop the roadmap:

• The human who opens the pull request owns it as if they typed every line. If they cannot explain it out loud, it goes back, whatever the tests say.
• Every new business rule ships with one plain English line saying why. It costs fifteen seconds today and it is the only thing that survives team turnover.
• Duplication created for the agent's convenience goes back in the queue even when it works. It looks like nitpicking during the sprint and it decides whether the next commission change takes two days or three weeks.

None of that slows the agent in any way a chart will notice. What changes is who keeps the knowledge: your team, rather than the chat history of a vendor you may not be using next year.

Where this advice does not apply

If you have three people, no large contract signed and you are still finding out whether the product has a market, ignore most of this. At that stage debt is a deliberate choice and speed beats traceability. What matters is knowing the expiry date on that choice: it comes due on the first contract that demands an audit, an integration with an enterprise ERP or a written SLA. That is when the bill you postponed becomes the most expensive line of the quarter.

The question to bring to your next roadmap review

Before approving more agent seats, ask how much of the code merged in the last 90 days your team can explain without opening the file. Do not request a report. Ask for the count on the spot, with ten pull requests picked at random in front of everyone.

Silence tells you the size of your debt while it is still cheap to pay. A confident answer tells you that you bought real speed, and it is worth doubling down. What does not work is deciding by the number that climbs on the dashboard while the expensive part grows outside it.