Writing code got cheap. Reviewing it didn't, and the bottleneck quietly moved somewhere the tools aren't looking.
Somewhere in the last year, the job changed. If you write software for a living in 2026, you probably spend more time reading code than writing it. The surveys now put review ahead of authoring, and it matches everyone I talk to. The agents write; you review. And reviewing, it turns out, doesn't scale the way writing did.
Once an agent can write the code, you're left with two options, and there's nothing between them. You babysit: you stay in the loop, approve each step, correct every drift. You keep control, and yes, the code comes out faster. But you're still the one making every call, all day, and it's draining in a way writing never was. Or you let go. You fire off the agents, walk away, and drown in more output than any human could actually read. So you don't read it. You skim, you approve, you merge, you tell yourself you'll look later. When there's more to review than time to review it, "review" stops being a thing you do and becomes a word you say.
Babysit or drown. "Stop babysitting your agents" is standard advice now (it was a session title at Code with Claude 2026), which tells you how universal the first half is. But the second half is worse, and the whole industry is pouring itself into making only that half faster: more agents, more parallelism, more throughput. A faster agent doesn't relieve the bottleneck, though. It tightens it. More capable models produce more good-enough output, from more parallel streams, all funneling into the same single human who still has to decide what's real. The cheap thing keeps getting cheaper; the expensive thing, human attention, stays exactly as scarce as it ever was. So the better the agents get, the worse this gets. You can't buy your way out with a better model. A better model is what's causing it.
