No Consumer, No Build

I ran a code-verified audit of my own ecosystem. The most expensive thing I found wasn't a bug. It was working software with zero callers.

The audit

This month I pointed my own tooling at my own fleet. Every repo, every service, every deployment. I asked it to verify what actually runs, what actually calls what, and what actually gets consumed.

The most expensive thing it found wasn't a bug. It was working software with zero callers.

My Belgian company-data service is live, four real sources integrated, intelligence engine built and tested. Zero callers. Four of its tables have never held a row.

Across my services layer: zero cross-service calls in production. The "platform" is a diagram. The wires don't exist.

Brand identity: re-implemented four times. Auth too.

One product carries ~5,000 lines of duplicated data-source clients. The shared service that replaces them exists. The migration never happened.

An archived platform holds my only real LLM gateway: 1,500 tests, six provider adapters, a budget guard with cost_usd=0.0 hardcoded. It shipped without ever charging anyone. Itself included.

None of this is broken. It all passes its tests. That's what makes it expensive. It's inventory dressed as assets.

The failure mode has a name

My failure mode is never bad code. It's a new deep artifact mid-quarter. A beautiful spec, sprints of scaffolding, then a pivot orphans it.

Spec-overreach feels like progress while you do it. The contracts are elegant. The tests are green. The README is immaculate. Then the quarter turns and the artifact joins the museum of things built ahead of their first user.

The gap between "vision" and "wired" isn't a vibe. It's measurable. Zero cross-service calls is a fact with a grep behind it.

The rule

So the doctrine has one load-bearing rule.

Every platform piece ships against a paying-product need. No consumer, no build.

Not "no vision." The vision is written, versioned, bigger than ever. The rule governs sequencing: infrastructure gets built the moment a real product pulls it into existence, and not one sprint earlier.

The rest exists to make the rule survive my own enthusiasm.

A hard WIP limit: three active projects. Not three per lane. Three.

A fixed pecking order. The cash lane wins every conflict. The product lane ships zero new features this quarter, deliberately. The platform lane is strictly serial.

Every chapter ends in a demo, not a document. Nothing starts before the previous gate passes.

Frozen means frozen. The gateway stays frozen until agents spend money unsupervised. Sunk cost buys no seat.

What it costs

This doctrine has a price, and I'm paying it.

It means telling myself no on the most interesting work available. It means my strongest engine stays under-adopted another quarter. It means watching duplicated code sit there, known and ticketed. It means deleting working software rather than rescuing it. That's the tax on building it too early.

The point

Code with no callers isn't an asset. It's a claim about the future that compounds interest against you.

The fix isn't better architecture. Mine was fine. The fix is a sequencing rule with teeth: no consumer, no build.

Growth is adding companies and services. Not rebuilding foundations. Not building cathedrals ahead of the congregation.

If this thread interests you:

We are not launching a company. We are proving one loop.