For decades, the expensive part of building software was writing it. Engineers were the bottleneck: slow, careful, and scarce. Generative AI has flipped that assumption. Code is now cheap and abundant — an agent can produce a thousand lines while you're refilling coffee. So what becomes expensive? According to this paper: judgment. Deciding whether the code is right, whether it fits, whether it should exist at all.

The authors ran a first-person, 12-week experiment: build a real system with heavy AI-agent involvement and document what actually happens. It's not a benchmark paper or a leaderboard — it's an honest field report from engineers trying to work in the new regime.

Their central observation: when generation is nearly free, the interesting engineering problem shifts from "can the AI write this?" to "how do we keep the whole system inspectable, correctable, and maintainable when a big chunk of it was produced by a process we didn't fully witness?" They call this "governable" agentic engineering — building not just software, but the surrounding scaffolding (architectures, tools, evidence trails, feedback loops) that lets humans stay in the loop meaningfully.

Some of the concrete findings that resonate:

• Architecture matters more, not less. If code is cheap, poor structure gets amplified. Bad boundaries mean the agent happily generates thousands of lines in the wrong place.
• Evidence is the new deliverable. The pull request is less "here's my code, trust me" and more "here's what I built, here are the tests, traces, and reasoning that show it works." Reviewers need audit trails, not vibes.
• Feedback loops are the throttle. Fast, reliable tests, type checks, and runtime signals are what keep an agent from wandering. Slow or missing feedback lets small errors compound into weeks of drift.
• Human judgment concentrates at higher levels. Engineers spend less time typing and more time deciding what to build, what to accept, and what to reject.

The paper's charm is that it doesn't oversell. The authors admit the costs of governance are real and sometimes exceed the savings from cheap code — hence the title. If you're careless, agents can produce a plausible-looking mess that's harder to fix than writing it yourself would have been.