The rule teams kept for prolific humans and dropped for agents

The rule was that volume of code has to be matched by somebody reading it, and it was never written down anywhere, which is why nobody noticed it lapse. No team let one prolific engineer push thousands of lines a week unread. When agents took over the writing, the requirement quietly stopped applying.

Keeping that requirement is most of what Backthread does: it records the reasoning behind each change an agent makes and shows, per area of the system, where a person has actually taken it in and where the record is blank.

The comment that named it

The occasion was a submission titled Towards Self-Driving Codebases, which reached 121 points and 99 comments on 17 September. Most of the thread was about mechanism: how to stop an agent from repeating a mistake. People proposed corrective-action processes borrowed from clinical trials, static analysers strict enough to reject the pattern deterministically, tests written so the next occurrence fails loudly. Reasonable, all of it. Then one commenter moved the argument up a level:

You can’t keep humans from making those errors either but you also don’t let an error prone human crank out 20k LOC per day without forcing other humans to understand it.

That is sarchertech, in the thread on 17 September 2026. It reads like a throwaway analogy. It is the constraint the rest of the thread was trying to automate around.

Why nobody voted on the exemption

The rule was enforced by a person rather than by a policy, so removing the person removed the rule without anyone filing a change. An engineer who wrote a thousand lines a week had, by the act of writing them, built a model of what those lines did. Review then added a second reader on top. Neither of those was a process anyone chose; both came free with human authorship, and free things are the ones you fail to notice leaving.

The rate at which they left is measurable. Faros AI's 2026 report, drawn from two years of telemetry across 22,000 developers, puts median time in pull-request review up 441.5 percent under high AI adoption, and pull requests merged with no review at all up 31.3 percent. The second figure is the rule lapsing in public.

What that author was quietly guaranteeing

It helps to be specific about what disappeared, because the replacements are different for each line.

What a human author guaranteed for freeDoes it survive an agent author
At least one person held a model of the changeNo — the model formed inside a session that is thrown away at merge
Volume was capped by how fast a person could writeNo — volume is capped by budget, and budget keeps rising
A reviewer's questions had somewhere to goPartly — you can ask the agent, but it re-derives an answer rather than recalling one
The reasoning existed somewhere, even if unwrittenOften not — on our own repository, 62 percent of decisions captured from agent sessions record no alternative and no trade-off at all

The last row is the one people get wrong. The common assumption is that the rationale exists and merely went unrecorded, which would make this a documentation problem. Frequently it never formed, because nothing was weighed in the first place. You cannot recover a decision that was never made; you can only notice which changes were made without one.

The version of the rule that survives agents

The old rule was about people and volume, and in that form it is gone. Written as a property of the system instead, it still holds: every area of the codebase should have somebody who has worked through its merges, and a record that accounts for them. That version does not require anyone to slow down. It requires you to know which areas are in that state, which is a question about a record rather than about discipline.

Two things follow for an engineering leader, neither of them heroic. The reasoning has to be captured while the session that produced it is still open, because a month later it is a reconstruction with good grammar. And the picture has to be kept per area of the system rather than per person, because "who is productive" and "which parts of this have nobody holding them" are different lists, and only the second one tells you where the next bad week comes from. That is what our map of who understands what exists to show, and why a merge alone was never the evidence people took it to be.

The thread's own instinct was right and aimed one step short. Deterministic tooling stops an agent repeating a known mistake. It does nothing about the far larger category of code that is correct, merged, and understood by nobody.

Connect one repo and you can see which areas of your system have accumulated merges with no recorded reasoning behind them; the trial runs fourteen days.

In short

The rule was never written down, so nobody noticed it lapse
No team allowed one prolific engineer to push thousands of unread lines a week. That limit was enforced by human authorship rather than by policy, so it vanished along with the human author, without any decision being taken.
Human authorship carried guarantees that agent authorship does not
A person who wrote the code held a model of it, was capped in volume by their own typing speed, and could answer a reviewer from memory. An agent supplies the code and none of the three, and the session holding the reasoning is discarded at merge.
Restate the rule as a property of the system, not of people
Every area should have somebody who has worked through its merges, and a record that accounts for them. Stated that way the rule survives agents, needs no slowdown, and turns into a question about what your record actually contains, per area.

Sources

  1. Towards Self-Driving Codebases — Hacker News discussion, 17 September 2026 (121 points, 99 comments)
  2. The quoted comment — sarchertech, Hacker News, 17 September 2026
  3. Towards Self-Driving Codebases — detail.dev, 17 September 2026
  4. AI Engineering Report 2026: The Acceleration Whiplash — Faros AI, 21 May 2026

Backthread shows how much of what your agents built your team really understands. See how it works