Picture a non-technical manager sitting down with an AI coding agent for the first time. They have a real problem, something that would normally become a ticket, get estimated, get scheduled, ship in three weeks if lucky.

Twenty minutes later, they have something running.

They close the laptop and don’t say anything. But they thought it. Almost everyone does, the first time: so that’s what they’ve been doing.

This isn’t new. There’s always been a strain of management thinking that saw software development as a throughput problem. Not craft, not judgment, just hours and bodies. It showed up in the language: resources, bandwidth, capacity. Words for pipes and factories. Most developers learned to live with it because the work was opaque enough to defend itself. What happened inside a three-hour debugging session was hard to explain, and hard to explain meant hard to devalue.

AI just removed that protection.

And here’s where it gets dangerous. The prototype is real. The 20-minute build isn’t a toy, it runs, it does something useful. What it doesn’t show is the security assumption quietly baked into the auth flow. The schema decision that will cost three months to migrate when the product changes direction. The architectural choices that looked fine in a single session and will look very different at 2am eighteen months from now.

The agent walked the decision tree. It didn’t weight it. That part, knowing which decisions are expensive to reverse, having the scar tissue from being wrong before, that didn’t get automated. It just got harder to see.

When someone feels competent doing something for the first time, they reprice it. That’s human. And right now, leaders are repricing engineering with one session of experience and a lot of confidence. Headcount decisions are being made by people who felt the 10x but haven’t yet felt the consequences of the decisions the 10x made for them.

To leaders: the prototype is an entry point, not a verdict. The developers you’re evaluating have been wrong at scale, with consequences. That experience doesn’t show up in a pull request. It shows up in the questions asked before anything gets built, the ones that look like slowness until the system fails and you realize they were the only thing standing between you and an incident.

To developers: the opacity is gone and it’s not coming back. The judgment, the instinct, the pattern recognition built over years of production failures, none of that disappeared. But it’s no longer self-evident, and self-evident is what gets funded. That case has to be made explicitly now.

The 20-minute prototype didn’t make developers obsolete. It made the misunderstanding about developers more expensive than it’s ever been. The feedback loop got slower. The decisions got faster. And the bill is still coming.