Accountability debt

2026-07-22 · 7 min read essay

Anthropic published the number: over 80% of their commits are now AI-generated. Not a projection. Not a goal for next year. The current rate, at the company that builds the model. The inner loop has won. Velocity is no longer the constraint.

What accumulates in the gap is not technical debt. Technical debt is visible in the code, fixable by a refactor, addressable in principle by anyone who reads the relevant file. What accumulates here is something different: a gap in who understands what's in the codebase, and who is responsible for it when something goes wrong. Call it accountability debt. Unlike technical debt, it's invisible while it builds. It shows up all at once, and suddenly.

The tower keeps rising

Armin Ronacher put the sharpest frame on this I've read. The original Tower of Babel story turns on language: the builders were stopped not by a failure of skill or materials, but by the loss of mutual comprehension. Ronacher's inversion is that agents remove the friction that used to force that comprehension. When someone new joined a codebase and changed something, the social cost of the change, reading the unfamiliar code, asking who owned a piece, having someone explain why an invariant existed, produced a side effect: shared understanding. "Your understanding became mine."

Multiple people directing agents at the same system removes that friction. Each change is locally coherent. Tests pass. Nobody is required to consult, because nobody has to write the code themselves. The tower keeps rising. Not because nobody can communicate: because nobody needs to. The danger isn't a visible collapse. It's invisible drift, a codebase going incoherent while it keeps functioning and growing, which is precisely why no one notices until it's expensive.

The review gap

The numbers on adoption don't resolve this. 42% of commits are AI-assisted across the industry, but 96% of developers say they don't fully trust AI-generated code, and 48% say they always verify before committing. The trust gap hasn't closed as adoption rose. Those two trends running in parallel are the accountability debt accruing: more shipping, same amount of doubt, fixed review bandwidth.

Amy J. Ko spent three months using Claude Code on real open-source projects specifically to test the claims from the inside. Her finding: code was usable about 90% of the time, but only with meticulous upfront specs. The remaining 10% contained deeply buried defects, flawed performance or usability assumptions, the kind that don't surface in tests and take exhaustive review to catch. She called the experience a telephone game, not craftsmanship.

The 10% problem isn't a rate you can batch away by shipping faster. It's the problem that matters most, hiding behind the 90% that ships fine.

Speed of light

Human cognition has a speed limit. Not a soft one that training and tooling gradually improve. A hard one, the kind that doesn't move. The rate at which a person can genuinely absorb code, meaning understand it deeply enough to own it, explain it, catch the subtle wrong thing three months later, is roughly what it was a decade ago. We are not getting faster.

AI is. Not at a constant rate: accelerating. Each generation of models produces more, faster, with fewer prompts. The inner loop isn't just ahead of the outer loop. It's pulling away. If you imagine this as two objects moving through space, the human cognitive limit is the speed of light: a constant you can observe but cannot change. The AI is the object receding from you. The faster it goes, the longer the delay between what it produces and what you can receive and understand. That delay is not a temporary lag. It is a physical property of the system, and it only increases.

There is a game design problem from the early history of personal computers that maps exactly onto this. Games written for a specific CPU ran at that CPU's clock speed. When faster hardware arrived, the games sped up with it: characters moved too fast to control, physics broke, the experience became unplayable. The machines had gotten better; the game had gotten worse. The fix was not to make players faster. It was to decouple the game's logic from the hardware clock, impose a frame rate cap, pace the experience to the human on the other side of the screen. The hardware could run as fast as it wanted internally. The interface with the human ran at human speed.

That is the design problem now. The AI can generate at whatever rate the hardware allows. The interface with the human, the review, the understanding, the accountability, has to run at human speed. Not because humans are the bottleneck to be apologized for. Because human speed is the constant the rest of the system has to be designed around.

Cognitive debt

Addy Osmani named the mechanism: cognitive debt. Not the bugs you merged. The understanding you stopped building. When the agent writes the code, you review a summary of what it did rather than building the model in your head of why it does it. You can accept or reject. You can read the diff. But the deep familiarity, the kind that lets you explain to a new hire why a particular boundary exists, or notice that a change three months later is subtly wrong, doesn't transfer in a review of output. It transfers in the process of writing.

At high enough velocity, the humans stop being able to audit the outer loop, not because they've been removed from it, but because the outer loop requires understanding they no longer have time to build. The agent ships more than a human can review at the depth the review needs to happen. That's not a resourcing problem. That's the accountability debt compounding.

Billing is not accountability

The billing models that have emerged, token usage, completion counts, seats times usage, measure the inner loop precisely. They tell you how much was generated. They don't tell you who understood it, who owns it, who will explain it when it fails. There's a temptation to treat cost visibility as a proxy for accountability. It isn't. You can know exactly what you spent and have no idea what you bought.

antirez, rebuilding a local inference engine, said the thing plainly: "you can't just say 'implement XYZ' and see it working." The DwarfStar project required deep design understanding at every step, not because he distrusts agents, but because the decisions that mattered were design decisions, and design decisions can't be delegated to something that doesn't hold the full model. He proposed DESIGN.md files per data structure so that contributors, human or agent, build the right mental model before touching anything. Control the ideas, not the code. Same move as Osmani's outer loop: human direction elevated to where it actually matters, rather than distributed across a thousand review clicks that add up to nothing.

What the proven layer requires

The previous post in this sequence argued for trusting the proven layer: the small, weird, observably useful things over the beautiful unfalsifiable ones. Ship the small reliable loop. The Paperworlds tools were the example: each one small, each one testable, each one grounded in what can be measured.

Accountability debt is what that discipline is actually protecting against. The reason to build small and measurable isn't aesthetic. It's that small things can be owned. One person can hold the whole model of what a 400-line tool does. When it breaks, someone knows why. When it needs to change, someone can explain what the change means. That's not a feature of the size. It's a consequence of the discipline that keeps things small: preferring the ugly tested thing, building only what you understand, treating your own understanding as a constraint rather than an obstacle.

The inner loop can ship anything now. What the outer loop has to provide, the part that can't be automated, is the understanding that makes shipping mean something. Accountability isn't a feature you add at the end. It's the residue of having actually built the thing yourself, at a scale where "yourself" still means something.

The tower keeps rising. The question is whether anyone inside it knows what it's for.

References

Closes the triptych. Pairs with: Proven vs elegant · Inside an electron