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 — and asked it to verify what actually runs, what actually calls what, and what is actually consumed.
Selected findings:
- My Belgian company-data service is live, with four real data sources integrated. Its intelligence engine — compare, history, timeline — is built and tested. It has 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 is re-implemented four times. So is auth.
- One product carries ~5,000 lines of duplicated data-source clients that a shared service was supposed to replace. The shared service exists. The migration never happened.
- An archived platform contains my only real LLM gateway — 1,500 tests, six provider adapters, and a budget guard with
cost_usd=0.0hardcoded. It shipped without ever charging anyone for anything, including itself.
None of this is broken code. All of it passes its tests. That's what makes it expensive: it's inventory that looks like assets.
The failure mode has a name
Reading the audit, the pattern was embarrassingly consistent. 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're doing it. The contracts are elegant. The tests are green. The README is immaculate. And then the quarter turns, priorities move, and the artifact joins the museum of things that were built ahead of their first user.
The audit gave me the number I needed to stop arguing with myself: the gap between "vision" and "wired" is not a vibe, it's measurable. Zero cross-service calls is not a strategy disagreement. It's a fact with a grep behind it.
The rule
So the new operating 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 down, versioned, and bigger than ever. The rule governs sequencing: infrastructure gets built at the moment a real product pulls it into existence, and not one sprint earlier.
The rest of the discipline exists to make the rule survive contact with my own enthusiasm:
- A hard WIP limit: three active projects. Ever. Not three per lane. Three.
- Lanes with a fixed pecking order. The cash lane — client work with an invoice attached — wins every conflict. The product lane runs on autopilot: my main product ships zero new features this quarter, deliberately. The platform lane is strictly serial.
- Every chapter ends in a demo, and no chapter starts before the previous gate passes. Not a document — a demo. A service kit is done when a new capability goes from idea to deployed, key-gated, agent-callable service in one afternoon. The identity layer is done when an agent reading workspace X gets a clean 403 on workspace Y, with the same correlation id in both logs.
- Frozen means frozen, with a written re-entry condition. The LLM gateway is frozen until agents start spending money unsupervised — it's a safety mechanism, not a dashboard, and safety mechanisms get built when the hazard exists. My old agent engine is parked, and the phrasing in my own planning doc is the phrasing I need on a poster: sunk cost buys no seat.
What this costs
Honesty section: this doctrine has a price, and I'm paying it.
It means telling myself "no" about the most interesting work available. The gateway is the most intellectually appealing piece of the entire platform, and it is explicitly frozen. It means my strongest engine stays under-adopted for another quarter because adoption follows the serial plan, not my pride. It means watching duplicated code sit there, known and ticketed, because the migration is scheduled behind a demo gate.
And it means accepting that some built things will never get their consumer, and will be deleted rather than rescued. Deleting working software is the tax on having built it too early.
The point
The audit found the most expensive state in software: built, but not wired. Code with no callers is not an asset — it's a claim about the future that compounds interest against you.
The fix isn't better architecture. Mine was already fine. The fix is a sequencing rule with teeth: no consumer, no build; every chapter gated by a demo; sunk cost buys no seat.
Growth is adding companies and services — not rebuilding foundations, and not building cathedrals ahead of the congregation.