Run the numbers on a coding-agent rollout and the spreadsheet nearly fills itself in: seats, token spend, hours saved per feature, added review time. What almost never gets a line is comprehension. Who will understand this code in a year, and what will it cost to change it then?
That question is concrete for us. Convective has built and maintained production systems since 1998, and most of our modernization work happens inside estates whose original authors are long gone. At that distance, maintainability stops being an abstraction. It is the invoice that arrives ten years after the code shipped.
The industry just noticed
Three signals landed within about ten days of each other. Thoughtworks published a controlled experiment on the economic benefit of refactoring an agent-built codebase, measuring what structure does to the cost of every future change. InfoQ ran an architecture piece arguing that comprehension is an architectural characteristic: code generation no longer builds understanding as a byproduct, and a system nobody understands cannot evolve safely. And GitHub turned maintainability into a product, moving Code Quality to general availability with maintainability scores, coverage gates, and organization dashboards aimed at teams whose AI-assisted output has outrun their ability to assess it.
Different authors, different motives, one conclusion. Agents made code cheap to produce and did nothing to make it cheap to understand.
The vantage point all three share
Read those pieces closely and a pattern shows up. The refactoring experiment ran on a greenfield application one person built this year. The architecture guidance assumes a team that once held a shared mental model and needs practices to keep it. The tooling assumes a modern repo wired into modern CI. All of it reasons about comprehension debt from the moment the agent arrived, as if the meter started at zero.
Most estates we walk into started the meter years ago. The systems running insurance carriers, county agencies, and mid-market operators carried comprehension debt long before an agent existed. The engineer who held the theory of the system left in 2016. The documentation describes version three while production runs version seven. Point an agent at an estate like that and it writes plausible code on top of code nobody fully understood in the first place. The debt does not add. It compounds.
That compounding is missing from every AI-code ROI model we have seen. The generation savings show up this quarter. The comprehension cost lands two or three years out, in the currency legacy work is always paid in: slower changes, riskier releases, and a shrinking set of people willing to touch the system.
What to price in
- A comprehension budget, spent before generation. On an estate with history, understanding has to be rebuilt deliberately before an agent writes into it. Ground the agent in evidence about what the system actually does, the discipline behind our ColdFusion modernization work, and charge that effort to the project rather than pretending it is free.
- Structure as a cost input. The refactoring experiment's larger lesson is that estate structure sets the price of every future change, human or agent. Cleanup belongs in the rollout budget, not in the deferred-maintenance pile it usually dies in.
- An ownership answer for every agent change. Someone on the team must be able to explain what the change does and why it is safe. If nobody can, the change is not done. That rule is cheap to state and expensive to skip, and it is the single control that keeps the debt from compounding silently.
The question a buyer should ask is not whether agents accelerate delivery. They do. The question is whether the ROI model charges that acceleration for the understanding it consumes. On an estate already carrying ten years of comprehension debt, that line item decides whether the project pays off at all. An AI readiness assessment is where we price it before real money gets spent finding out the hard way.