Generation Scaled, Verification Didn’t

By mid-2024, our team had solved the problem of writing boilerplate.

A developer could sketch a five-word prompt and receive eighty lines of syntactically valid Go or TypeScript within three seconds. PR throughput climbed on paper. Burndown charts accelerated. The metric tracked by engineering directors—lines produced per sprint—looked extraordinary.

Then the quiet insolvency arrived.

The Asymmetry of Compute and Attention

Code generation scales linearly with compute. If you provision more GPU clusters, you can produce ten thousand lines of code per minute.

Verification, however, scales strictly with human working memory.

Reading code has always been cognitively harder than writing it. When you write code, you possess the mental model of the domain problem: the edge cases, the concurrency constraints, the database isolation guarantees. When you read another engineer's pull request, you must reverse-engineer that mental model from the artifact itself.

When the author of that artifact is a generative model, an insidious psychological shift occurs. The code looks plausible. The indentation is immaculate. The function names sound authoritative. Variable declarations follow idiom.

Yet underneath that superficial polish lies what we now recognize as the supervisory tax: the exhausting labor of hunting for hallucinations, subtle off-by-one race conditions, silent exception swallowing, and impedance mismatches across distributed state boundaries.

The Supervisor Trap

Senior staff engineers used to spend thirty percent of their week on design reviews, mentoring, and systems architecture. Over the last eighteen months, they became high-paid automated linter supervisors.

They are tasked with inspecting PRs four times larger than what any human teammate would have dared to open two years ago. The cognitive cost of proving a negative—verifying that generated code contains no invisible landmines—is twice as high as writing the feature from scratch with mechanical sympathy.

When a junior engineer writes messy code, the errors are usually obvious: crude naming, awkward loops, missing null checks. When a model writes flawed code, the errors are camouflaged by flawless surface grammar. It is the uncanny valley of software engineering.

The Real Scarcity

The bottleneck was never typing speed. Typing was never the constraint on software delivery; thinking through failure modes was.

If a machine generates code in four hundred milliseconds that takes an experienced engineer forty minutes to audit, reason through, and verify against production invariants, compute did not eliminate the bottleneck. It simply relocated it directly onto human attention.

We do not need tools that produce more volume. We need architectures that reduce surface area, prioritize local-first simplicity, and respect the finite attention of the humans who must wake up at 3:00 AM when the system breaks.