Skip to content

Blog

When code is cheap, the design decision is the expensive part

When a full feature costs a few dollars to generate, throwing code away stops being waste and becomes the cheapest way to test an idea. The constraint moves from writing the code to deciding what survives.

Written by

Specification and review

Published: 26 May 2026 Updated: 1 min read

Last month a team I work with deleted a working feature. Tests passing, around two thousand lines, no bugs. They threw it out on purpose, and I’d say they were right to.

Code permanence used to be arithmetic

For most of our careers, code permanence was an economic fact. A feature cost real engineering hours, so once it worked you kept it. Deleting working code was deleting money. “Make it reusable” and “do not throw it away” followed from the arithmetic.

The arithmetic changed

From our experience: on one client’s line, a full feature implementation with a 220-line test suite was generated for $2.78. Per ticket, the agent runs land near $1.60 to $1.80. A developer hour costs roughly fifty times a whole agentic session. The expensive input is no longer the typing.

So the cost of producing code is solved. What is left, I think, is the cost of being wrong about the design.

Test the guess instead of arguing it

That sounds smaller than it is. When code was expensive, you protected the investment by debating the design up front, in meetings and on whiteboards. That was slow, and the design was still a guess until something ran.

Cheap code lets you test the guess instead of arguing it. Generate the feature, run it against the real system, see how it behaves. If the design holds, keep it. If it does not, the two thousand lines cost a few dollars, and you just bought hard evidence that a design was wrong before it shipped. The same lesson at integration time would cost a full quarter of rework.

The rigor moved to judgment

That still takes rigor. The rigor moved off the code and onto the judgment: what gets validated, what gets kept, what gets thrown away. The code became disposable. The decision did not.

What would your team try this quarter if the prototype cost three dollars instead of three weeks?

Further reading

  1. When code is cheap, agreeing on what to build is the bottleneck Slow typing used to force teams to agree before they built. With agents, a vague ticket produces two confident builds, so the fix moves upstream into a short alignment doc. 2 min readShort post
  2. Review the short alignment doc, not the thousand-line plan The team that popularized research, plan, implement published what they got wrong. Read the code, and put human attention on the short doc before the plan, where a bad assumption is still cheap to fix. 2 min readShort post
  3. The costly mistake is hovering over your agent Writing 20 lines by hand is no longer the overcorrection to worry about. Staying in the loop so tight that the agent never gets room to work costs far more. 1 min readShort post

All 23 posts on Specification and review

ClientsClient work

Test the constraint in your system

The Factory Readiness Assessment connects this research to your value stream, your data, and the next decision.

Training on this topic: Agentic Engineering for Developers and QA
See the assessment

Want to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check