Your Dark Factory Burns Capital Without a Flame
The anatomy of delivery debt, and why the flame has no colour
The heat had not broken in weeks. So when the clouds came over the Adamello Brenta that afternoon, I stood outside and felt something close to gratitude, the ordinary relief of a man who has been waiting for rain.
I watched them a little longer than I needed to. And the longer I watched, the less they behaved like weather. Clouds move with the wind and thin as they climb. These did not thin. They rose from one place and stayed rooted to it, and they were the wrong colour, too dark at the base, a dirty brown where the light should have been grey.
It was not weather. It was smoke.
I told myself the rain would come and put it out. The rain did not come.
That night my daughter and I lay on the grass with our backs to the ground, waiting for falling stars, the way you do in August. She watched the sky. I kept turning my head. Behind us the mountain had a red line along it, low and steady, and it was wider than it had been at dinner.
A single strike had hit a single tree. That is all it took. Hectares of forest, from one unpredictable second.
Everyone who reads about that fire will tell the same story: lightning struck, the forest burned. It is a clean sentence, and it is wrong. The lightning did not burn the mountain. The lightning was a trigger, and triggers are cheap; the mountain burns triggers all summer without catching. What burned the mountain was months of drought in wood that nobody was measuring, waiting for any spark at all.
In June I gave something a name and then walked away from it. I wrote that Alessandro Di Gioia and I had started calling a certain thread delivery debt, and I left it there, a label on a door I did not open. Episode 99, I promised to open it. This is that.
So here is the anatomy, what the research actually measures, what I am arguing from my own observations, and the line between the two, drawn where you can see it.
Two debts, not one
ℹ️ If you are arriving cold, the whole of it in one breath. Every codebase carries two debts, not one. The first is in how the software was built, and the industry has thirty years of instruments pointed at it. The second is in what got built, the features nobody validated, and nothing measures it at all. AI drives both up at machine speed and can only pay one of them down. Delivery debt is my name for the two compounding together, and it is the reason the invoice climbs while the board stays green.
J. B. Rainsberger states the law more cleanly than anyone. The cost of a feature is the sum of two things: F = G + H.
- G is essential complication, the part where the problem is genuinely hard and no cleverness removes it.
- H is accidental complication, the mess we introduced ourselves, under pressure, without refactoring.
His uncomfortable claim is that H dominates. Most of the time the cost of a feature has almost nothing to do with how hard the problem is, and almost everything to do with how far the design has decayed. That is why Friday’s three days becomes Monday’s three months.
Rainsberger’s H was code. I found there is a second one, and it is the reason your dashboards lie to you and your AI expenses are skyrocketing.
Practitioners have been circling it since 2009, when Andrew Chen named product design debt as the user experience twin of technical debt, through Ben Yoskovitz, Paul Jackson, and Dan Duett’s modern formulation in 2023. Their common core is simple:
alongside the accidental mess in how software is built sits the accidental mess in what got built.
The features nobody validated. The scope that grew because reorganising it risked a dip. The product that answers a question the user stopped asking two years ago.
The two debts are not symmetric, and the asymmetry is everything.
Tech debt is visible. It lives in the code, so it can be detected, scored, tracked in real time, and refactored. You can point a machine at it.
Product debt is invisible. Not hidden, not neglected; invisible by nature, because no instrument measures it. There is no live score for wrongness. Its only symptoms are downstream and human: rework, reversals, corrections, a slow decline in the experience that nobody can attribute to a line of code.
Delivery debt is the two of them compounding. That is the definition I owed you in June.
What the research measures
The evidence is real and recent, and I want to be precise about what it covers.
Faros AI ran two years of telemetry across twenty-two thousand developers and more than four thousand teams, comparing each organisation at its lowest and highest AI adoption. Throughput went up: more epics, more tasks, more merges. So did everything underneath. Bugs per developer up by half. Incidents per pull request merged up by more than two hundred percent. Time in review stretched several times over. Roughly a third more pull requests merged with no review at all. Code churn, which is the polite name for rework, up by hundreds of percent.
GitClear looked at 623 million code changes and found the habit behind it. Refactoring collapsed from around a fifth of all changes to under four percent. Copy and paste rose to overtake it. Duplication is now the default move where consolidation used to be.
DORA surveyed roughly five thousand professionals and reached the sentence that governs all of this: “AI doesn’t fix a team; it amplifies what’s already there.” Their finding is that AI adoption now correlates positively with throughput and negatively with delivery stability, and the root cause is acceleration without control systems.
Read those three together and notice what they have in common. Every one of them is measuring the code. Churn, refactoring rates, review latency, incidents, stability. They are instruments pointed at the half of delivery debt that can be instrumented, and what they are recording is a fire that has already reached the treeline.
That is where the evidence stops.
What I am arguing
The rest is mine, and I want it labelled as such. This is a model I have reasoned from twenty-five years in codebases and boardrooms, not a study I can hand you.
Here it is.
AI can pay down tech debt. That is not speculation; it is what our own nWave SW Factory does every day, refactoring continuously as the code is written, driving H toward zero and holding it there. The downstream can be bailed out.
AI cannot pay down product debt. A model holds a domain as associations, a cloud of what goes with what. But the demand for a feature is not an association. It is a causal chain: this happened, then that changed, so the user now needs this. That is understanding, and it is different in kind from knowledge. When the real chain is not in the weights, the model interpolates between the points it has and dresses the result as a plausible answer. It produces reasonable features that solve problems nobody has, and it produces them faster than any human ever could.
And the two debts do not run side by side. Product debt regenerates tech debt. Every wrong feature, every reversal, every correction is rework, and rework pours fresh accidental complication back into the code faster than any loop can drain it. H in the code never reaches zero while H in the product keeps flooding it.
That is the cascade. One invisible root, one visible symptom, one bill.
I have watched this for two decades without the accelerant: companies carrying legacy code whose authors had all left, domain knowledge scattered across people who no longer spoke to each other, product definition limping through a bureaucratic backlog, epics that consumed a sprint before a line was written. It was slow and it was survivable, because building was slow. That was the drought. Nobody called it a fire because nothing had struck yet.
Vibe coding and agentic development collapsed the sprint from two weeks to less than a day. The forest did not get drier. The sparks got faster.
The bill
The token economy is where the cascade surfaces on paper, and it is the reason the CFO is now in this conversation.
The price of a token has fallen roughly a thousandfold in three years. Enterprise AI bills went up anyway. That inversion is not a pricing mystery; it is a waste signal, and CodeScene measured the mechanism: the same feature, in a codebase carrying real debt, burns fifty to a hundred and twenty percent more tokens than it would in a healthy one. The mess you tolerated last year is now metered.
Uber spent its entire 2026 AI budget in four months before capping spend per tool. In our own field work, during the AI-readiness assessment stage, we see organisations carrying around five thousand dollars per developer per month with no ceiling and no way to forecast the next invoice. That second figure is ours, from our own engagements, not from anyone’s study.
The bill is not the disease. It is the fever chart. Cheaper tokens did not shrink the invoice; they removed the last economic brake on generating waste, and drifted code is where the waste burns. And there is a cost here that never reaches the engineering budget, because it never reaches engineering at all.
Shadow IT used to be a rogue spreadsheet, a macro, a script somebody’s manager quietly tolerated. It could not hurt you much because it could not do much. That limit is gone. Anyone, in any department, can now ship working production software with no review, no security gate, no test, and no contact with anyone who has ever seen your architecture. A dark factory, sparking inside a company that does not know it is running one.
Look at what that code is made of. It was written without engineering practice, so it is accidental complication in how, from the first line. It was written without validation, so it is accidental complication in what, from the first line. It raises H on both axes at once and it starts near the top of both. And none of it reaches the telemetry, because the instruments watch the repositories, and this was never in one.
Green dashboards, dry forest
Here is the part that should keep you up, and it is not a failure of diligence. Your dashboards were green. They were green because they were measuring the half that was fine.
We have spent a decade being told to measure what matters. It became a discipline, an industry, a shelf of books. And it worked, right up to the point where the thing that mattered most stopped being measurable. Velocity, throughput, story points, deployment frequency: all of them count what got built. None of them ask whether it should have been. So we manage the half with instruments and the other half compounds unwatched, and we call the result a green board.
Measuring what matters is not enough any more. You have to measure what is necessary, and what is necessary is now the half with no gauge.
You cannot instrument wrongness directly. You can instrument the behaviours that produce it. Whether intent was clarified before generation began. Whether a specification was authored by someone who understood the causal chain, or assembled from a backlog. Whether the loop that catches a wrong feature runs in days or in quarters. Those are Key Behavioural Indicators, and they are the only honest proxy available for the invisible root. Making them visible from the board down to the code is exactly the problem our Behavioral OKRs exist to solve.
The exit
You cannot out-refactor a flood. Driving the code’s H to zero is necessary, and it is not sufficient. Any vendor who tells you otherwise is selling you the downstream.
The only exit drives both toward zero at once: continuous refactoring as the code is written, not once a quarter, and an enforced product specification, authored by human understanding, that the model must obey and cannot skip. Discipline at the moment of generation, on both axes.
That is the transformation we call The Helm, and it is where I would start if I were sitting where you are sitting.
She watched for two hours and counted four falling stars. Small, bright, harmless, gone before she could point at them. Behind her the ridge was burning the whole time and she never once looked at it, because steady light does not look like an event.
Then she fell asleep on the grass, still facing the sky. I picked her up and carried her inside and put her to bed, and the mountain was orange over my shoulder the whole way, eating hectares while she slept. She had spent the entire evening watching for the one thing in that sky that could not hurt her.
She was lucky. That fire at least had a colour.
In 1981, at the Indianapolis 500, fuel gushed from a hose before it reached Rick Mears’ car and ignited against the engine. Methanol burns transparent and without smoke. Nobody could see he was alight. A safety worker reached in to lift his helmet off, not knowing. Mechanics caught fire walking toward him, because there was nothing visible to walk away from. The sport had chosen that fuel deliberately, after a gasoline crash in 1964 killed two men behind smoke thick enough to blind the cars still coming; they traded a fire everyone could see for one nobody could, for good reasons, and years of burns passed before anyone called it a bad trade.
Your dark factory runs on methanol. So does the product debt underneath it. Invisible to you.
The sport did not stop racing. It put gasoline back into the blend for one reason: so the flame would show. It paid, on purpose, to make its own fire visible. That is what measurement is. Not a dashboard, not a count of what shipped. A decision to give the thing you are afraid of a colour, before it reaches you.
You are the one carrying the weight of the invisible token economy. Put the colour back in the flame. We are here to support you.
🗓️ Next week: the driver 🏎️ …
Stay at Indianapolis a moment longer, because I could hand you the fastest car ever built and it would still be expensive metal in the hands of someone who was never taught to drive it. Every harness on the field, every gate, every deterministic check, rests on a person who knows what good looks like and can tell when the machine is lying to them. I will show you the three layers a governed AI stack actually needs: human judgment, process enforcement, and regulatory compliance, and why pulling out any one of them brings down the other two.