The “AI software factory” metaphor is seductive.

Factories increase output. They reduce marginal cost. They turn craft into production. For decades, writing code was the bottleneck. Now generation is cheap, and it feels like we’ve industrialized software.

But factories are not optimized for throughput alone. Real factories are optimized for yield.

Throughput is how much you produce. Yield is how much of it survives.

That distinction matters more than most of the AI discourse admits.

A team embraces the factory model.

In two weeks, they’ve generated forty internal services: shared utilities, validation layers, orchestration glue, observability hooks. Everything modular. Everything neat.

Three months later, something subtle shifts.

A small requirement change touches validation. Five different modules contain similar logic. No one remembers which one is canonical. The tests still pass because they verify each implementation, not the invariant across them.

Monitoring disagrees with itself. Metrics drift, but not catastrophically. There’s no outage. Just friction.

Deleting anything feels dangerous. Everything might be referenced somewhere. No artifact looks obviously wrong. Nothing is clearly scrap.

They didn’t move too fast.

They industrialized generation without industrializing forgetting, and nothing in their tools or culture warned them they needed to.

Manufacturing learned this lesson long ago.

A factory that optimizes only for throughput accumulates waste. Defective units pile up. Rework increases. Inventory grows. Costs hide inside buffers. So industrial systems built discipline around scrap: defect rates are measured, processes are retooled, material is reclaimed, disposal is designed into production. Yield becomes the signal that matters.

Software factories might talk about output: how many features shipped, how many services generated, how many migrations completed.

...but rarely talk about yield: how many components can be safely deleted, how many services can be reimplemented without destabilizing the system, how much of the system’s identity survives regeneration unchanged.

Throughput without yield is accumulation.

And accumulation has carrying cost. Cost in cognitive load, integration surface, monitoring complexity, coordination overhead. When generation becomes cheap, those costs are easy to ignore until they dominate.

The factory metaphor is only useful if it includes reclamation.

Industrial systems are built to absorb replacement. They assume parts will be discarded and design processes where scrap is expected and controlled. Regenerative software demands the same discipline.

Deletion must be ordinary. Replacement must be bounded. System identity must live outside implementation.

The factory does not produce code. It produces behavior that can be regenerated without fear.

That is yield.

If code is cheap to produce but expensive to understand, then the durable artifact cannot be the code itself. It must be the interfaces that survive language changes, the invariants that survive framework swaps, the evaluations that survive reimplementation, and the data that survives infrastructure shifts.

Without that structure, industrial generation increases risk. Every regeneration adds surface area unless something else constrains it. Every new abstraction feels cheap in isolation. Every optimization leaves residue.

Cheap generation shifts the constraint from production to coherence.

Factories that scale output without scaling coherence do not become efficient. They become brittle. Real industrial systems reduce variance, define tolerances, and make replacement predictable. They are engineered for discard as much as for production.

The software equivalent is not “more code faster.” It is explicit boundaries, durable evaluations, drift detection in production, and compaction cycles that reduce conceptual mass rather than expanding it.

Industrial regeneration means that the cost of replacement is lower than the cost of preservation. When that is true, deletion becomes safe. When deletion becomes safe, accumulation becomes optional.

AI gives us industrial generation immediately. It does not automatically give us industrial regeneration.

You can produce artifacts faster than you can reason about them. You can increase throughput while quietly lowering yield.

A system that cannot safely forget will eventually be constrained by what it remembers.

If we are serious about industrialization, we must industrialize forgetting. That requires evaluation suites that outlive implementations, invariants expressed at stable boundaries, regeneration cadence built into process, and architectural discipline that treats deletion as a first-class event.

Until we do that, every AI-powered factory we celebrate will quietly increase the weight of the systems it claims to accelerate.

Throughput is easy.

Yield is the work.