On the Death of MVP, the Birth of MPL, and How Value Will Flow Next

MVP is dying. Build loops.

The MVP answered one question. Does anyone want this. You couldn't afford to build the real thing just to find out, so you built a cheap fake and read the signals off it. The MVP was never a product. It was a question you could afford to ask.

The real thing cost too much to use as a question for two reasons: building it, and running it once built. Both are collapsing. An operation can run end to end now with no human inside it. You don't build a smaller version to test it. You run it. The first thing to build isn't a product. It's a loop.

What replaces the MVP is the Minimum Profitable Loop: the smallest run of operations that clears a margin with no human inside it. The MVP guessed at demand. The loop counts the money. The unit of validation moved from one to the other.

A loop that pulls filings, extracts the fields a buyer already pays a junior to type into a spreadsheet, and drops the result in their inbox overnight — with a charge attached — is an MPL. A demo of the extractor is not.

A loop that makes something nobody buys isn't an MPL, it's a hobby. Clearing a margin means the output reaches someone who pays for it, so a minimal distribution is baked into the loop from the start. Just enough to reach the first paying buyer. Reaching a buyer is part of what makes a loop a loop.

Product-market fit collapses into a single act. PMF was a proxy. You couldn't see demand, so you inferred it from retention curves, interviews, and how far a buyer leaned in during a demo — every signal standing in for a number you couldn't reach until you'd already spent the money to reach it. A loop hands you the number directly. It clears a margin only if someone paid more than it cost to run. That is demand, realized, on the ledger. You don't establish fit and then build. You run loops until one pays, and the one that pays is the fit. The search and the business become the same act. And fit stops being a place you reach and hold. The run that uncovers it is the run that starts competing it away. It's decaying the moment you read it.

So you find a loop that pays. Then comes the real question. What do you actually own?

A loop pays because it produces at machine cost what the economy still prices at the cost of a human doing it. The output sells at the human price, the input runs at the machine price, and the gap is the business. Call it a substitution loop: a machine doing for less what a person did for more. It's the common case, and it has a problem.

It owns nothing but a cheaper method, and a cheaper method gets copied. The moment a loop pays it shows, then it gets found, copied, and undercut by the next entrant willing to run it thinner. It keeps paying while that happens, on a margin that decays toward the floor with every copy that lands. For most of business history, copying a proven approach was the slow, expensive part, and that slowness was the moat. That's what collapsed. The loop is the smallest asset you can build now, and with nothing else behind it, it has a short half-life.

But the loop doesn't disappear when the margin goes. It hardens. A loop competed down to the floor becomes cheap, reliable, and available to everyone — a primitive. It stops being a business and becomes a part. Document extraction earns a margin while it's scarce; the moment it isn't, it's a component that makes the next thing cheap to assemble.

The parts pile up. Every loop that commoditizes is a block the next loop gets built from. Compute gets cheaper, models get more capable, and a loop too complex to run last year becomes runnable this one, partly because the layer beneath it turned into cheap components. The frontier climbs on the loops that died under it. Early on, the runnable loops are mostly substitution. Later they're mostly new — things no human could do at any price, assembled out of whatever commoditized along the way. One moving line: substitution hardening into primitives below, creation at the edge, and the line never stops rising.

You capture the margin while the curve lasts. When it flattens, the value didn't disappear — it moved up, into whatever gets built on the primitive your loop just became. Nothing you hold stays where the value is.

The cycle:

1. A loop starts paying.
2. Competitors find it, copy it, undercut it.
3. The margin bleeds toward the floor.
4. The loop hardens into a primitive.
5. New value forms one layer above.

Then it runs again on the new floor.

So what's a moat now? You can't own a copyable loop. You can only run it. What's left to own is what wraps it, or the primitives it runs on. The old moat held a position still: find a profitable spot, wall it off, keep the margin as long as competition was slow. It isn't slow anymore, and a wall around a sinking position is worth nothing. A moat isn't a wall now. It's a brake. It can't stop the margin from bleeding. It sets how fast. The question flipped with that: not whether it protects you, but how many cycles it buys before the loop hits the floor. Being first stopped being a moat once copying a running loop went cheap. Finding a loop worth running was never the cheap part, and now that building has gotten cheap too, that search is the scarce part. Being first to it wins the front of the curve, not the position after.

Most of what people call moats are brakes. Proprietary data a rival can't get, distribution that reaches the buyer first, a brand a buyer won't second-guess. They share one property: a competitor can copy your loop exactly and still not have them, so they slow the copying without stopping it. The slowest brakes are the human ones. A buyer keeps paying a law firm, an auditor, a bank long after a machine could do the work, because what they're buying isn't the work — it's an institution willing to be liable for it. Trust and accountability decay slower than anything else, because the thing being sold was never efficiency in the first place. The frontier rises past them too, just later.

One way back up the margin is putting the human back on purpose. Doc extraction on its own is a primitive now, almost no margin left in it. Wrap it in a legal-processing company — an account manager, an SLA, someone the buyer can call, someone liable when it's wrong — and the margin comes back, because they're paying for the wrapper, not the extraction. The machine still runs the loop. The human carries the relationship and the risk. That isn't a retreat from automation. It's how you climb on top of it.

A brake is only worth the cycles it buys if you spend them climbing: building the next loop on the floor your last one just became, before anyone else gets there. Sit still behind a good brake and all you've bought is a slower death.

One moat doesn't behave like a brake, because it doesn't decay with the loop. It compounds. Own the primitive everyone's next loop has to run on — the model they call, the data they train on, the rails they settle through, the identity they authenticate against, the standard they have to speak — and every loop built on top of you pays to use it. The higher the stack climbs, the more of them there are paying. A brake fights the decay of one loop. A primitive feeds on the decay of all of them. It's the position that gets stronger as everything around it commoditizes.

Each hardened loop feeds the layer above it, that layer hardens and feeds the next, and the frontier — wherever the live value currently sits — never stops rising. The cycle runs until it runs out of room: until the loops have worked their way up through the whole human economy and there's almost nothing left that a person used to price and a machine can't now run. One hardened layer at a time, all the way up.

MVP asked what to build. The better question now is which loop pays. The asset that lasts isn't the loop. It's a rung ahead of the commoditization rising under you.