Cheap Code Makes Selection More Important

The price of producing code is collapsing. An agent can attempt a small feature, test variation, integration, or internal tool while a person is still deciding who should pick up the ticket. That changes the economics of implementation. It does not erase the economics of software.

Every change still has to be understood, proved, integrated, released, observed, secured, supported, and eventually changed again. It adds another surface where behavior can conflict with behavior that already exists. A feature that costs almost nothing to type can create years of decisions for everyone who inherits it.

This is the trap in treating cheap production as permission to produce everything. The build meter falls toward zero while the product absorbs permanent surface area. The invoice did not disappear. It moved downstream and started compounding.

When implementation was scarce, the backlog performed a crude kind of selection. Weak ideas waited behind urgent ones. Some died before anyone found the time to build them. That was an expensive and unreliable filter, but it was still a filter.

Agents remove that bottleneck. Good. They also remove the friction that stopped a vague request from becoming a permanent product commitment. If every suggestion can become a pull request, the scarce resource moves to judgment: which changes deserve to exist, what consequence is acceptable, and what evidence would justify keeping them.

Our position is that agent-run organizations will ship more valuable change with fewer people. They will not get there by accepting more output indiscriminately. They will get there by making selection mechanical, fast, and difficult to route around. Abundant construction makes a strong rejection system more valuable, not less.

A factory should estimate more than implementation effort. Ask what must prove the change, which systems it can disturb, how it can be reversed, who must operate it, and what future work becomes harder once it exists. A tiny button can carry a large behavioral contract. A large internal rewrite can be cheap to own if its boundary is narrow and its acceptance is deterministic.

Then route by expected value and consequence. High-value work with strong proof earns capacity. Reversible experiments get strict time and surface limits. Requests with unclear value, weak acceptance, or permanent operational drag go back for a decision before an agent generates inventory around them.

This is not a committee wearing an automation badge. The policy belongs in the machinery. Require an objective, an owner for the consequence, a bounded change surface, acceptance evidence, and a removal path. If the request cannot supply them, the factory should stop. A cheap attempt is still waste when there is no credible reason to keep the result.

Cheap reconstruction changes another decision: what to preserve. Teams keep weak code and marginal features because replacing them once looked expensive. When a governed factory can reproduce the useful behavior from a clear contract, preservation loses some of its hold. The organization can delete more aggressively instead of maintaining every historical compromise.

That does not mean throwing away working systems on a model's suggestion. It means retaining intent, constraints, proof, operating evidence, and migration paths so the implementation is not the only record of what matters. The factory can then compare the cost of carrying a surface with the cost of rebuilding or removing it.

A productive software asset is not the largest codebase your agents can create. It is the smallest reliable system that delivers the chosen outcome and can change without dragging every abandoned idea behind it. Factories should reward reduced surface area when the evidence says the outcome survives.

The model is not the differentiator here. Any capable model can make cheap code. The advantage belongs to the factory that can distinguish a nearly free artifact from a worthwhile change, prove the difference outside the builder's chosen conditions, and remove what no longer earns its place.

People still choose the destination and own the consequences. Agents should do the repeatable work of exploring options, constructing changes, running proof, watching production, and preparing reversals. Keeping people on routine implementation because judgment remains necessary confuses the decision with the labor around it.

Cheap code will not end software economics. It will expose organizations that never had a selection system. The winners will not be the companies that generate the most. They will be the companies whose factories know what to refuse, what to prove, and what to delete.