What Gets Cheap Next, and What Stays Expensive

Costs in software are being rearranged rather than uniformly reduced. Knowing which direction each line is moving is more useful than a general expectation that things get cheaper, because the expensive things become the constraint — and the constraint is where planning should concentrate.

Getting cheap

Producing a first version. Prototypes, scaffolding, initial implementations. Already dramatically cheaper and continuing.

Breadth of coverage. Handling the eleven edge cases nobody had time for, writing the tests for all of them, supporting the additional format. Tedium at scale was expensive because of the tedium, and that's the part that compressed.

Translation between representations. Schema to code, spec to tests, one framework to another, documentation from implementation. Mechanical transformations with checkable results.

Exploration. Trying five approaches to see which fits. When each attempt cost days, you committed early on limited information. When each costs an hour, you can find out — and that changes design practice more than the speed itself does.

Long-tail internal tooling. The scripts and dashboards that were never worth an engineer's week. This is where a lot of the real value has shown up, quietly.

Staying expensive

Deciding what to build. Unchanged, and it's the input everything else waits on.

Verifying correctness where no oracle exists. Checking a compile is free; checking whether a product decision was right takes months and stays confounded.

Coordination across people. Meetings, negotiation, alignment. Possibly more expensive, since more parallel work means more integration surface.

Understanding an existing system deeply. Reading generated summaries isn't the same as having built a model, and the model is what debugging and reviewing require.

Operating under uncertainty. Incidents, ambiguous failures, situations where the system's behavior isn't understood.

Trust. Earning enough of it to be allowed autonomy — for a system or a person — moves on a social timescale.

⚠️ Getting more expensive

The category people miss, because "AI makes things cheaper" doesn't prepare you for it:

Review, per unit of output. More output, same reviewers, harder-to-spot defects. The cost per change may fall while total review cost rises.

Integration. More parallel work means more interactions between individually-correct changes.

Maintaining what got cheap to create. Generating a service is cheap; running it for five years isn't. Cheap creation plus unchanged maintenance means the ratio shifts toward maintenance — and the decision to create something now understates its lifetime cost by more than it used to.

Knowing what you have. More code, more services, more tools, produced faster. Comprehension of your own estate is a cost that scales with what's been produced.

💡 What the rearrangement implies

Prototype more, commit later. When exploration is cheap, buying information before committing is the right trade.

Raise the bar on creation, not lower it. The instinct is to build more because building is cheap. But the expensive line is maintenance, and it didn't move. ✅ "Should this exist?" is a more important question now, not less — cheap creation means more things get created that shouldn't.

Invest in the expensive lines. Verification infrastructure, decision-making speed, system comprehension. Effort there compounds; effort on the cheap lines is buying what's already becoming free.

Budget for review explicitly. If it's rising per unit and it's the constraint, it needs to be planned rather than absorbed.

🔍 Checking it locally

Look at your last quarter and ask where time actually went. Then ask which of those lines are moving in which direction for you specifically.

The general pattern is a prior, not a fact about your organization. A team whose bottleneck is a slow approval process has a different expensive line than one whose bottleneck is a legacy system nobody understands — and general advice about what's getting cheap doesn't help either of them.

The takeaway

Creation, coverage, translation, and exploration are getting cheap. Deciding, verifying without an oracle, coordinating, and understanding are not. Review, integration, maintenance, and estate comprehension are getting more expensive. Plan around the third list, raise rather than lower the bar on what gets built, and check which lines are actually moving in your own organization before applying any of it.