Skip to main content
BriX Consulting
The AI bill Who signs off on AI Code you didn't write

The Tokenomy Has Arrived: The Hidden Cost of Ungoverned AI Coding

5 Frameworks, 1 Truth, and why discipline at the point of generation is the only thing that holds

Michele Brissoni
The Tokenomy Has Arrived: The Hidden Cost of Ungoverned AI Coding

It was a little after six on a November morning when Alessandro Di Gioia pinged me:

Mike, the Oompa Loompas have a new model. Opus 4.5 is out. We can switch them over and start the measurement again.

We call them Oompa Loompas, the agents Alessandro and I keep running through the night, the tireless little workers in the back of the factory, doing the job while everyone else sleeps. They are how we build the new versions of nWave, and they are also how we keep watch on the models that build alongside us. Years ago we wired up a standing regression suite that throws the same set of coding tasks at every model the day it ships and records two numbers: how good the code that comes back is, and how many tokens it spent to get there. So that morning we did what we always do when a frontier model lands. We moved the Oompa Loompas onto Opus 4.5, ran the suite, and read the meter. By then that meter had started to tell us something we had not gone looking for.

There were two races on the field, not one.

Everyone was watching the first one, the obvious sprint between DeepSeek, OpenAI, and Anthropic for the best model. The second race was quieter, and it ran underneath the first. Every time a new frontier model arrived, the same work we had measured on the model before it came back more expensive on the newer one. Not on the sticker price. On the bill. Look at the cadence and you can feel the pull: Opus 4.5 in November, 4.6 in February, 4.7 in April, 4.8 at the end of May only forty-two days after 4.7, the shortest gap Anthropic had ever shipped between Opus releases, then Fable on the 5th of June. Five steps at the frontier in seven months, and each step asked for more 💰.

Here is the part most people miss. You have little say over the first race, the price of the frontier. You have enormous say over the second, because what runs up the bill is not really the model, it is how much waste the model is allowed to produce while it writes. And that is decided one layer up, in the tools we use to point these models at real code. A friend of mine, Jeff Bailey, a principal engineer at Nike, wrote that layer down better than anyone. He had ridden the whole carousel, Copilot to ChatGPT to Windsurf to Cursor, then Kiro with Spec Kit and OpenSpec and BMAD bolted on, then Claude Code, then away from the Gas Town crowd, and finally onto nWave. He did not stumble onto it. He came to it the way a lot of crafters in our community do, through Andrea Laforgia , and then documented the whole journey himself, in his own words.

What Jeff named is the thing the whole market keeps circling. Spec Kit, OpenSpec, BMAD, Gas Town: every one of them gives you agents, skills, and commands, and every one of them describes a process. As Jeff put it, a prompt framework describes the process while a harness enforces it as the model runs. A prompt only suggests that the test comes first. A hook blocks the model from moving until the test is actually there. Claudio Perrone built the whole of Rippily on nWave. The only time he reaches for anything else is when he is spiking, throwing a quick and dirty prototype at a new idea to see whether it holds, and the tool he reaches for then is Superpowers, the skills framework with north of two hundred thousand GitHub stars. He uses it without worry for one reason:

he knows what follows. nWave’s refactor cleans up the dirt the spike leaves behind. The fast tool is safe to use only because the governed one comes after it.

You could dismiss all of this as people who sell harnesses talking their book, so set it aside and look at the data instead. A study landed this month (Faros 2026) built not on a survey but on two years of telemetry across twenty-two thousand developers and more than four thousand teams. Throughput is up, sharply. So is the damage underneath it: more bugs per developer, review times stretched, roughly a third more pull requests merged with no review at all, and code churn up more than eight hundred percent, which is the polite metric name for rework.

The finding that should stop you is this one:

Everyone assumed the DORA elite, the teams with the strongest engineering foundations, were immune to AI slop. They are not. The telemetry shows the strongest organizations degrading right alongside everyone else, because this is not a maturity problem.

Human excellence keeps a person in the loop, and that matters, but no human was built to review code at the speed a model can author it. The study’s own conclusion is that the problem has to be met at the moment of generation, not patched downstream with more reviewers.

That single sentence is the whole argument. Discipline applied after the model writes is a losing position. Discipline enforced while the model writes is the only one that holds. That is not a DevOps maturity score. It is a different kind of control. Nowadays it’s called ‘harness engineering‘.

There is a second cost most people miss, and our own work confirmed even by CodeScene‘s data makes it concrete:

an unhealthy, legacy codebase does not just slow you down, it taxes your tokens. 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, and it shows up on the invoice. This is the thread Alessandro and I have been calling delivery debt, and it is exactly what we are building our tokenomy dashboard to surface: not how many tokens you spent, but how much of that spend your own delivery debt is causing.

Put the two together, models that cost more at every step and codebases that tax every step, and you reach the number that is starting to frighten the people who sign the invoices. Silicon Valley already has a name for the behavior, tokenmaxxing, burning maximum tokens in pursuit of output. J.P. Morgan put out a note this month with a title that needs no gloss: AI Bills Are Out of Control. OpenAI is now processing more than fifteen billion tokens a minute, up from six billion in October. And Uber‘s own CTO confirmed the company spent its entire 2026 AI budget in four months, with engineers running five hundred to two thousand dollars a month each, before the company capped spend per tool to stop the slide. In the after-pilot stage, we now see organizations carrying around five thousand dollars per developer per month, climbing with no ceiling and no way to predict the next invoice.

You do not have to take it from a vendor. Salvatore Sanfilippo, the creator of Redis, spent this week, like all of us, testing Fable 5 and said two things at once. The model is a real leap, the best in the world right now, and he was clear about that. And the economics are a trap. Prices keep climbing while usage falls, he said; OpenAI and Anthropic look like rivals but play the same game, and the real opponent is the user who has to pay for it. He was just as blunt about the cage: Fable is the first model that makes you feel more locked in than ever, refusing the moment you get near security work.

We felt the cage directly. Fable is a genuine step up, and it also costs twice what Opus 4.8 costs per token, and on hard problems it spends far more tokens thinking, so a real task can land at three to five times the bill, not two. And every time we pointed our DevSecOps agents at a security scan, Fable’s safeguards tripped and quietly handed the job down to Opus 4.8. The better model, declining the work, because the work looked like security.

So here is the one truth under the five frameworks. The harnesses that endure will be the ones that enforce engineering discipline at the point of generation, with gates the model cannot talk its way around. Guardrails that merely ask are guardrails the model learns to step over. You need the harness built so the model cannot leave the lane, a Deterministic eExecution System that checks the work programmatically, from outside the model, where the model cannot reach. That is the quiet core of what we build, and in its enterprise form it runs zero-trust: the workflow, the contracts, and the execution patterns are held by gates the agent does not control.

And if you still think depending on a single distant frontier model is a safe foundation, consider what landed on June 12. The US government issued an export-control directive, citing national security, suspending all access to Fable 5 and Mythos 5 for every foreign national, inside or outside the country. The net effect was that Anthropic had to disable the model for all of its customers overnight. The trigger, by Anthropic’s own account, was a claimed method of getting the model to read a codebase and repair its flaws, a capability available in other models too. Whatever you make of the decision, the lesson for any organization is plain:

access to the thing your whole pipeline runs on can be taken away in an afternoon, by a letter, with no notice. Sovereignty over your models and your delivery is no longer a philosophical nicety.

I learned that one in a calisthenics park. My daughter was in the pool for her training session and I was outside on the bars, working through sets of burpees and pull-ups with a twenty-kilo vest, recording notes for this article between rounds and sending them to the agents to check what was running. A young woman near me was warming up for a track session. Somewhere in the middle of a set, a message came back from the agent: sorry, this model is no longer available, downgrading to Opus 4.8. It took me a second. Then it landed, the government order. Fable, pulled out from under me, because I am a foreign national outside the United States, and that now meant me.

I started to laugh, on the bar, under twenty kilos of extra weight. The runner looked over, trying to decide whether I was alright. Oh, nothing, I told her. My AI ran into a problem working overnight. She gave me a look that said she had no idea what that sentence meant, and went back to her warm-up.

That gap is the whole thing. While she stretched for a run, an export-control letter had reached across an ocean and switched off the model my Oompa Loompas had been running on, and the only visible trace of it was a tired man laughing on a pull-up bar. The two races we started measuring on that November morning, the one for the best model and the quieter one over what a token costs and who controls it, had arrived in a public park on a Saturday. They are not abstract. They are the new frontier of enterprise AI governance, the place where technological advancement and economic survival meet, the thing we have started to call the tokenomy.

Next week: The skill nobody is teaching. Every framework on the field, the harnesses, the guardrails, the deterministic gates, quietly leans on the one thing none of them can automate: the judgment of the human behind the keyboard, the person who decides when to let the Oompa Loompas run and when to hold them. I will show you how I built my orchestrator around that person, and why behavioral engineering, not another tool, is the foundation the whole stack rests on.