Reading the code used to be paid for by writing it

Because whoever wrote it had already done the reading. That was never a separate task, so nobody costed it, and it is precisely the part agents took away. Backthread is built for what is left: the reasoning behind each merged change, kept per area of the system, so a team can tell where anybody still understands what shipped.

The question somebody finally asked plainly

On 2 October a senior engineer put it to Hacker News with no product attached and no thesis to sell: is anybody producing good code with coding agents. The post ran to 29 points and 40 comments. The sentence that carried it was this one:

It takes 5x longer to review Claude merge requests and I barely understand what I approve.

That is ruffrey, asking on 2 October 2026. Most of the thread answered with method — write better specs, use a different model for the reading pass, audit every hunk as it lands. Useful advice, all of it aimed at the symptom.

The comment that named the mechanism

Part way down, one commenter stopped proposing remedies and described the accounting instead:

I think an underappreciated aspect is that we previously amortized the reading and comprehending over the time we spent designing and writing.

That is hey-hey, in the same thread. It explains the five-times figure without blaming anyone's prompt, and it is the only reply that treats the problem as structural.

Comprehension was never free. It was bundled. A field study of 78 professional developers across seven projects, covering 3,148 working hours, measured 58 percent of that time going to program comprehension — and that was when the developers were writing the code themselves. The cost was always most of the job. What has changed is who pays it, when, and whether anything is left behind afterwards.

Under human authorship the payment was spread thinly across hours of producing the change, and it was collected by the person who would later be asked about it. Agents do not remove the cost. They unbundle it: the same reading now arrives in one block, in front of somebody who was not in the session, in the twenty minutes before a merge. Five times longer is not a sign of worse code. It is the bill arriving without the instalment plan.

The thread's figure is not an outlier, either. Telemetry across 22,000 developers over two years puts median time in pull-request review up 441.5 percent where AI adoption is high, and pull requests merged with no review at all up 31.3 percent. One of those numbers is the cost being paid. The other is it being skipped.

Three answers, and what each leaves open

The thread's proposals sort into three strategies. Each one works; each one leaves the same thing unsolved.

Someone pushed back on the third with the obvious objection: how is that different from any large codebase nobody reads end to end. The reply was precise about the difference — on a big system nobody held all of it, but somebody held the high-level shape, somebody else held each piece, and you could go and find them. That chain of people is the property at risk. Holding every file in one head was never the thing worth protecting.

What it changes for an engineering leader

Three consequences follow, and none of them asks the team to produce less.

1. Budget comprehension as work, not as a tax on review. If 58 percent of the old job was reading, and the writing half has been automated, the reading did not shrink — it got concentrated. Scheduling it only inside the review window guarantees it is done badly, by whoever happens to be on rota.
2. Capture the reasoning while the session that produced it is open. The alternative weighed and the trade-off accepted exist for about as long as the agent's context does. Written down at the time, they let the next reader start warm rather than cold. Reconstructed a month later, they are a plausible guess.
3. Keep the picture per area of the system, not per person. Which parts of this have nobody holding them is a different list from who is shipping, and only the first one predicts the next bad week. A merge has not been evidence of understanding for a while now, which is an argument we have made at length, and this thread is forty engineers discovering it independently.

The honest limit: nothing here removes the reading. Somebody still has to sit with an area until they hold it, and no record substitutes for that. What a record changes is that you choose which areas, on evidence, which is what our map of who understands what is for.

Connect one repo and the first per-area picture of where reasoning was captured and where it is blank is there the same day; the trial runs fourteen days.