Adam Bender spends his working days inside one of the largest codebases on earth. A staff software engineer at Google, he has a message for developers that cuts against the mood of the moment: the tools that make code ten times faster to write are about to make the systems that hold that code ten times harder to run.
“The way you build software today simply will not work at 10x speed,” Bender has warned in engineering discussions that have spread well beyond the company. His arithmetic is plain. A developer who produces ten times the code in a week also produces ten times the compilation work. Ten times the test load. Ten times the review backlog. And a codebase that no single person can hold in their head.
Software, in Bender’s framing, is a liability. It is one of the few assets that starts accruing interest the moment it is written. Every line must be compiled, tested, reviewed, documented and eventually maintained by someone who did not write it. Write faster, and the debt compounds faster. His warning is not that AI writes bad code. It is that the machinery around the code, the build systems, the test farms and the review queues, was engineered for a slower era.
Google is the extreme case. The company’s repository runs to billions of lines, and a single change can trigger builds spread across tens of thousands of machines. Engineers already wait minutes for tests after a routine check-in. Multiply that workload by ten, Bender argues, and the economics of the build system collapse on themselves.
The problem has a history. Compilation time has been the quiet tax on software development for decades: machines got faster, but codebases grew faster still, and the gap was closed with distributed build farms, incremental compilation and layers of caching. Those systems were sized for a world where humans wrote the code. Machines write code on a different clock.
The economics of reading make the imbalance worse. Experienced engineers have long assumed a ten-to-one ratio between reading and writing code; a developer spends most of a career understanding other people’s work. When machines do the writing, the ratio tilts further. The reader still reads, but the writer never tires, and the volume of prose to absorb grows without a corresponding increase in human attention.
The AI coding boom has made the question concrete. GitHub Copilot, Cursor, Claude Code and a shelf of rivals now write real fractions of production code. Developers increasingly type less and review more. The scarce skill shifts from producing code to judging it, and the backlog that results is already visible in engineering organizations that track such things.
Bender’s sharper point is about who wins. Not the teams with the highest output, he says, but the teams with the strongest fundamentals: clean interfaces, disciplined testing, small modules, explicit naming. AI amplifies whatever a team already does. It does not supply direction. A team with tangled abstractions will produce tangles ten times faster; a team with clear structure can absorb tenfold output without tipping over.
Engineering leaders outside Google are reaching similar conclusions. Managers who adopted AI coding assistants early now talk about review debt the way they once talked about technical debt. Some companies have added gates that route AI-generated code through extra scrutiny before it merges. Others are rediscovering build tools such as Bazel and remote compilation services, once treated as infrastructure trivia, now considered strategic assets.
Engineers who work on incident response say the failure modes of machine-written code are becoming familiar: duplicated logic, hallucinated APIs, security holes a human reviewer would have caught. None of the failures is exotic. They are the ordinary defects of software, arriving at ten times the usual volume.
The strain is already visible at the industry’s largest code host. GitHub, which Microsoft owns, suffered AI-related service interruptions this week and leaned on outside computing capacity, according to people familiar with the matter. The platform that stores the world’s code is itself struggling to absorb the code the new tools produce.
Not everyone agrees the problem is permanent. Proponents of AI coding point out that the same models that generate code can test it, and that agents able to fix their own mistakes change the maintenance math. Some startups now run entire software projects with a handful of engineers and a swarm of coding agents, and their founders argue that the old rules of software liability do not apply to software nobody had to read. The jury, they say, is still out.
What is not in dispute is the direction of travel. Enterprises are buying AI coding tools faster than they are reworking the pipelines those tools feed into. The vendors selling tenfold productivity rarely mention what happens at the other end of the pipeline, where the code lands.
Bender’s deeper argument is about direction. In a tenfold world, velocity is cheap and judgment is expensive. The teams that decide what to build, what to delete and what not to build at all will separate from the teams that simply build more. Software remains a liability; the only question is who keeps the ledger.
