I have a friend in Bengaluru who once hired, on a neighbor's word, the fastest house painter in the city. Word was the man could do a full house in a single day — walls, trim, all of it — for half what anyone else charged for the privilege of watching him work. My friend hired him. The man showed up at seven, left by six, and the house looked immaculate. Somewhere around week three, half the plug points stopped working. Turned out the fast painter, moving at the speed of a man who bills by the house and not the hour, had painted clean over a switchboard. Not around it. Over it. Glossy, seamless, gorgeous. It took an electrician two visits and a fair amount of muttering to find it, because from the outside it looked exactly like a wall, and walls are not where you go looking for your wiring problem.
That's the AI coding boom, in miniature. Something got dramatically faster. Something else, quieter and less visible, got dramatically slower — and nobody built a line item for it.
For centuries, organizations have tried to make skilled production cheaper. Taylorism, assembly lines, offshoring, agile — every wave found a new way to squeeze more output from fewer expensive humans. AI has done that for software faster than any wave before it. Various industry surveys now put daily AI-tool use among professional developers past the halfway mark, with AI-assisted code creeping toward half of everything written. Production, by any measure that counts lines or tickets, is up.
What nobody modeled is what happens when creation gets cheap and trust doesn't. Manufacturing solved production scarcity and immediately discovered logistics scarcity — the factory could make ten thousand units, the dock could ship three hundred, and the bottleneck didn't vanish, it just moved downstream and changed uniforms. Software is doing the same thing right now, except the dock, in this analogy, is your most senior engineer, and she did not sign up to be a dock.
Here's the distinction most productivity dashboards politely decline to make: a developer generating code faster is real, measurable, and looks wonderful in a sprint review. What doesn't show up is the senior engineer who now spends a meaningful chunk of her week reviewing pull requests that are syntactically flawless, structurally dubious, and confidently wrong in ways that take real thought to catch. She didn't write any of that code. She's just the one who eventually finds out it was painted over the switchboard.
One December 2025 analysis by CodeRabbit found AI-coauthored pull requests carrying roughly 70% more flagged issues than human-only ones — not because the code looks bad, but because it looks fine, which is the more expensive problem to have. A bug that announces itself gets caught in five minutes. A bug that's dressed for the office gets merged.
Economists have a name for a cost you create that lands on somebody else's ledger: an externality. AI-assisted code generation runs on one. The developer gets the productivity credit — it's in the sprint velocity, it's in the demo. The reviewer absorbs the verification cost, and that part shows up nowhere except her calendar.
Opsera's 2026 benchmark of more than 250,000 developers across sixty-plus enterprises found AI tools cutting the time to open a pull request by more than half — and those same pull requests then sitting in review 4.6 times longer than normal before anyone trusted them enough to merge. Read that twice. The generation side of the ledger got faster. The verification side got almost five times slower. Nobody's calling that a productivity loss, because nobody's measuring the second number.
Call the running total Verification Debt — not a one-time cost but a balance that compounds every time you add another AI coding tool without adding a single hour of corresponding review capacity. It doesn't show up on your technical-debt register. It shows up on your senior engineers' calendars, and then, eventually, in production.
There's a harder version of this problem most organizations haven't hit yet, though a fair number are closer than their roadmap admits.
Human attention doesn't scale the way GPU clusters do. A senior engineer can meaningfully review a certain number of pull requests a week before review turns ceremonial — before "LGTM" starts meaning "I looked at this for ninety seconds and nothing was on fire yet." When AI generation scales faster than verification capacity, you don't get more throughput. You get more unverified throughput, which is a different animal wearing the same badge.
The research here is genuinely unsettled, and worth being honest about. One controlled trial from the AI research group METR found experienced developers 19% slower with AI coding tools in early 2025 — the tools were adding overhead, not removing it, once review and correction were counted in. A year later, the same group's updated estimate put developers at roughly 18% faster. Nothing about the technology needed to change for that swing to happen. What changed was that teams learned where the tools help, where they don't, and built review processes that could actually keep pace.
The Supervision Ceiling is the point where your organization's ability to generate exceeds its ability to trust. Above it, you're not shipping faster. You're stockpiling risk, the way a hoarder stockpiles newspapers, and calling the pile a library.
The role emerging here doesn't have a clean job title yet, so let's give it one: Supervisory Engineering. Not reviewing line by line, not writing code — designing the verification layer itself. Deciding what needs human eyes, what a machine can be trusted to check on its own, and what the failure modes of AI-generated components actually look like once they're in production and nobody's watching them anymore.
This isn't junior work. It requires the kind of institutional memory that knows why the "deprecated" service is quietly still load-bearing. Most organizations are staffing this problem with the same senior people who were already at capacity — handing them a second job and calling it a promotion. That's not a staffing decision. That's asking a man to hold two ladders at once on the theory that both ladders are, technically, his.
Most engineering organizations track lines of code generated, pull requests opened, sprint velocity, deployment frequency. None of these tell you how much of what shipped was actually understood by a human before it went out the door.
Verified Throughput is that number — the volume of output that passed genuine human comprehension, not just automated testing. Automated tests catch what they were written to catch, and most of them were written before the AI-generated code they're now checking ever existed. They are not a substitute for a person understanding what the code does and why.
Tracking it mechanically isn't complicated: tag each merged PR by whether a human materially engaged with the logic — not just clicked approve — and watch that ratio against total PRs merged, month over month, the same way you'd watch any other capacity metric. The organizations building durable AI-native engineering operations are the ones treating the gap between Verified Throughput and total throughput as a liability, not a footnote.
The answer isn't slowing down generation. That ship has sailed, and good riddance to the old pace of it.
Risk-tier your verification. Not all AI-generated code carries the same verification cost. A utility function touching nothing external is not a payment-processing change. Build explicit tiers, and spend human attention where it changes outcomes — not uniformly across everything a model happens to write.
Build AI-assisted verification, not just AI-assisted generation. Use the same technology to generate test coverage, flag anomalies, surface confidence scores, and catch when generated code drifts from established patterns. The tool creating the abundance can help manage the load it created — if you design for that on purpose, instead of bolting it on after the first incident.
Make Verification Debt visible. Put it on the same dashboard as technical debt. Track the ratio of AI-generated PRs to senior-engineer review hours, and watch it over time. When it climbs, that's not a productivity signal. That's a Supervision Ceiling warning, arriving early enough to actually do something about it.
AI productivity is measured at the point of generation. Organizational productivity is determined at the point of verification. Every tool vendor selling you on speed is measuring the first point. Every engineering leader wondering why the roadmap still isn't moving is staring at the second one, usually alone.
The Verification Economy isn't a problem you solve by buying another tool. It's a problem you solve by redesigning how trust actually flows through your organization — slower, harder, and considerably less photogenic than a product demo. But it's the actual work. The organizations that win the next five years won't be the ones that generated the most code. They'll be the ones that figured out how much of it to believe.
Somewhere in your codebase, right now, is a switchboard somebody painted over. It isn't hiding. It's just waiting on someone whose job it technically wasn't to go looking.
PS: You'll find the expensive line eventually. Everyone does. Usually the same way my friend found his — not by inspecting the wall, but by standing in a dark room, wondering why the lights went out.
Claude went rogue, attacked three real companies, and published malicious code to the internet. Anthropic's Claude AI agent gained unauthorized access to three real company networks during what Ars Technica describes as a genu
Get unvarnished architectural insights on scaling engineering orgs, directly to your inbox a few times a week.