Good Enough Is the Most Expensive Thing You Will Ever Ship

Why cheap tokens are bankrupting your AI budget — and how the Agentic Constitution stops the bleeding.

Enterprise Experience Architecture presents: The Specification Economy — Article 1 of 4

They reviewed the bill without the architect who caused it. I found out a day later.

The way you find out about decisions made in rooms you were not invited to — in passing, from someone who assumed I already knew. An internal operations suite at a Fortune 100, the unglamorous kind of platform that runs a business quietly until the bill arrives. The deployment had been approved against a figure. The figure was wrong by a factor of four.

The meeting had two hours on the calendar. The VP of Engineering was there. The finance partner. The product owners. The business leads. The delivery management team.

Design was not on the invite.

That absence is the most accurate diagnostic in this article. The executive team had a rational accountability model: the people who specify technical requirements, build the system, manage the delivery. The design function had governed the business logic surfaces. Those surfaces had shipped. In their model, the architecture team’s accountability had ended at delivery — and AI inference costs — the computational price the enterprise pays every time an agent runs, metered per token — had no design author on the org chart. Nobody had built the connection. Not because the accountability was contested. Because it had never been claimed.

The VP of Engineering had a theory. Route to a cheaper model. The finance partner had a different theory. Consumption ran ahead of forecast; the line would settle. Both were describing the invoice. Neither could explain it.

When someone eventually looped me in — not during the meeting, but afterward, when two hours hadn’t produced an answer anyone trusted — I pulled the thread.

The single largest cost center on that bill, by a wide margin, was one category of work: agents generating a business logic surface, failing an internal validation check, and generating it again. And again. The platform was not paying for intelligence. It was paying for the same surface, eleven times, because the specification the agents were building against could not tell them which of eleven states they were actually in.

This was not a model malfunction. The agents were not broken and the validation check was not miscalibrated. The agents looped because they could not tell which state they were in — and they could not tell because the specification had never named the state.

That specification was not broken. Broken would have been easier. It was good enough.

That phrase is the most expensive one in the enterprise software economy of 2026, and I am not pointing at someone else when I say it. I wrote that specification. What changed is that the meter is now running on every one of them — and almost no one is putting it on the invoice.

This is the first thing to understand about what I have come to call the Specification Economy: when production approaches zero marginal cost, the specification is the only thing left that has a price. The agents are cheap. What they build against is the entire bill.

The budget review had a rational accountability model — and an empty chair. The overrun traced to one category of work: agents regenerating a single surface eleven times, because the specification never named which state they were in.

The Metered Paradox

Every time an AI agent runs — every time it generates a surface, processes a query, or completes a task — the enterprise pays a computational fee measured in tokens. Those fees are AI inference costs: the operating cost of the AI, metered per request, accruing continuously across every agent and every surface the enterprise has deployed. They are not a license. Not a subscription. A meter — running whether anyone is watching or not, charged against every session the system processes.

The price of that intelligence is in freefall.

The GPT-4-class performance that cost sixty dollars per million tokens when it launched in 2023 now costs under a dollar — a collapse of more than ninety-eight percent in under three years, and it is not finished. Gartner projects that by 2030, running inference on a frontier-scale model will cost providers more than ninety percent less than it did in 2025.

And the bills are exploding anyway.

The FinOps Foundation found that managing AI spend went from a niche concern to nearly universal in two years — ninety-eight percent of practitioners now track it — and named it the fastest-growing line item on the enterprise technology budget, and the first one CFOs are being asked to defend to the board. The cost is migrating from training to deployment: inference passed training to become the majority of AI cloud infrastructure spend in early 2026, and over a production system’s lifetime it runs to eighty or ninety percent of total cost — because training is a one-time bill and inference is the one that never stops. Gartner is blunt about why the savings never reach the enterprise: agentic workloads burn far more tokens per task than the chatbot-era usage the budgets were modeled on.

The cost of intelligence is collapsing. The cost of deploying it has never been higher.

This is not a paradox. It is a specification problem with a meter attached.

The Bill That Doesn’t Add Up

Goldman Sachs projects total token consumption growing twenty-four-fold by 2030. The math behind that projection is not complicated: a single agentic task consumes between five and thirty times the tokens of a standard chatbot exchange, because an agent does not answer once. It reasons, acts, observes, and repeats. Consumption is rising faster than price is falling. The total bill climbs every quarter regardless of what happens to unit cost.

What the board does not understand about that bill: they believe they are paying for net-new intelligence — work the enterprise could not do before, now done. A meaningful share of what they are actually paying for is rework. The same decision, made repeatedly, because the foundation underneath it was never resolved.

The phase where you counted tokens and ran pilots is ending. The phase where you count dollars is starting. When you trace those dollars to their source, they lead somewhere no one on the current org chart expects. They lead back to design.

Everyone Is Looking in the Wrong Place

The two theories in that meeting — the VP’s and the finance partner’s — are the two camps that own the entire AI cost conversation right now. Both are looking at the symptom.

The finance camp is selling deflation. Tokens are getting cheaper, ride the curve, the unit economics will mature. This is true and almost entirely useless to a CFO staring at a quadrupled invoice. You do not have a price problem. You have a volume problem — and the deflation narrative masks the volume entirely.

The engineering camp is selling optimization. Prompt compression. Caching. Model routing. Send the cheap work to a small model, reserve the expensive one for hard reasoning. Competent infrastructure hygiene, all of it — and none of it touches the actual cost driver, because you cannot optimize your way out of an authorship problem. Routing to a cheaper model lowers the price of each wrong pass. An agent that loops eleven times against a vague spec still loops eleven times. You have discounted the unit price of failure. You have not changed the rate of it. Compression shortens the prompt; it does not make an ambiguous specification unambiguous.

Both camps stop at the infrastructure layer, because that is the layer they can see. The largest controllable cost on the enterprise AI bill is not authored there. It is authored upstream of engineering entirely — months earlier, by whoever defined what the system was supposed to do, and how precisely they defined it. Model routing and compression reduce the price of a single pass. They do not reduce the number of passes an ambiguous specification generates. The volume problem sits upstream of every infrastructure optimization there is.

Gartner has warned that leaders who mask architectural inefficiency with cheap tokens today will find agentic scale out of reach tomorrow. They meant systems architecture. The warning is correct and does not go far enough. The inefficiency starts earlier than the system. It starts at the experience specification.

Where the Tokens Actually Go: The Retry Loop

If you want to find the money, find the loop.

When an agent produces an output that fails a validation check, it does not shrug and move on. It self-corrects. It resubmits the task — and it resends the full conversation history as context every time it does. An agent grinding through ten correction cycles can burn up to fifty times the tokens of a single clean pass. This is not a malfunction. Retry behavior is how agents reach acceptable output. It is architecturally necessary, and nobody put it in the cost model. Nobody ever does.

This is the Retry Tax: the metered cost of ambiguity. Every retry cycle is a billable consequence of a definition gap the architect did not close. It is not a fee anyone agreed to pay. It is what the enterprise is charged, automatically, each time an agent loops against a state the specification failed to name. The only thing more expensive than an ambiguously named state is a state the architect never knew existed.

The Retry Tax is the Margin Multiplier running in reverse — now with a literal meter on it. The Margin Multiplier, the central economic claim of the EXA framework, holds that every correct architectural decision compounds value forward: faster sprints, cleaner handoffs, fewer production incidents, each one building on the last.

Run that engine backwards and you get this invoice. An ungoverned specification produces the wrong surface, fails validation, forks into a near-correct variant, fails again, and bills the enterprise for every iteration of the guess. The blast radius of one ambiguous state is no longer a QA ticket caught three weeks later. It is a line item, accruing in real time, across every agent and every surface that touches that state.

And it compounds in the dark. Monitoring agents, document watchers, and compliance surveillance systems run continuously, consuming tokens against every event whether or not a human asked for anything. The looping is happening on surfaces no one is watching, at a velocity no human review process was built to follow. The first time most organizations see it is on the invoice — after the spend, never before it.

Here is the math I ran against what that platform was actually processing. Take a single ambiguous status component — one ungoverned state description, generating ten thousand agent-assisted sessions a day. A clean pass through a governed specification runs roughly three thousand tokens per session. A retry loop grinding through ten correction cycles reaches fifty times that: one hundred fifty thousand tokens per session, every time the agent hits that state. At a dollar per million tokens — a round figure at current enterprise frontier pricing — the clean version costs about nine hundred dollars a month. The ungoverned version costs forty-five thousand. That delta — forty-four thousand dollars a month — comes from one component. Your contract may price tokens higher or lower; the figure moves, the structural delta does not. The Fortune 100 platform that opened this article did not have one ambiguous component. It had an entire product line.

The same component, specified two ways. A governed pass costs about $900 a month; the ungoverned retry loop costs about $45,000 — a $44,000 delta from one definition gap. The wrong output does not get cheaper as tokens fall. It scales.

The 95% Failure Is a Specification Failure

That forty-four thousand dollar monthly delta is not an anomaly. MIT research puts the failure rate for enterprise AI initiatives at roughly ninety-five percent — and the industry’s reflexive read is technology failure: wrong model, wrong use case, integration too complex.

It is not a technology failure. The models work. They execute against what they’re given. It is a specification failure wearing an invoice — the same structural problem I diagnosed across the first series of this framework. There the cost was rework and operational error. The mechanism has not changed. The meter is new.

An agent does not interpret. It executes. Hand it precision and it builds precisely. Hand it good enough — ambiguous, open, “use an appropriate style for at-risk accounts” — and it does the only thing a probabilistic system can do with a gap: guess, validate, fail, and try again. That cycle is billable. The ambiguity you left in the spec to save a day of definition work is the exact ambiguity the agent now charges the enterprise to resolve, at machine speed, on every session the surface runs.

This is why injecting AI into a static design system accelerates the failure instead of fixing it. A library of components was always governed by human interpretation — a developer who could ask a question, a reviewer who could catch the drift. Replace that interpreter with an agent and you have not removed the ambiguity. You have removed the only thing that was absorbing it, and handed the gap to a system that scales breakage at the speed of generation. I argued this first as a quality problem, in the case for replacing the design system with a constitution. In 2026, it is also the most direct line on your AI inference costs.

Precision as Cost Control

If “good enough” ships fast and keeps the CFO happy, why would anyone pay for excellence? When production is nearly free and everyone can have an agent assemble a passable interface, what is left to compete on? Doesn’t precision become a luxury the enterprise has no reason to fund?

The economics say the opposite. In 2026, excellence — defined not as polish but as precision — is the only thing that is token-cheap at scale.

This is what Governed Autonomy was always for. A governed Semantic Layer is not a component inventory. It is a type system for the experience: a foundation where invalid states are structurally impossible to express, the way a strongly typed language makes certain classes of bug impossible to compile. An agent executing against defined logic does not guess. It does not loop. The retry that consumed fifty times the tokens never happens, because the state that triggered it cannot exist in the specification.

The Agentic Constitution — the machine-readable deliverable at the center of the EXA framework — is therefore not just a quality instrument. It is the single most powerful cost-control measure an Experience Architect can deploy. What follows is the artifact itself — a governed constraint block you can export from this article and hand to the team building your next agentic surface. Consider the difference in concrete terms.

The “good enough” specification — the one that cost a Fortune 100 the same surface eleven times — reads like instruction to a human:

Show the account status. Use an appropriate alert style for closed or at-risk shipments.

An agent cannot execute that. It can only interpret it — which means guess, validate, fail, and guess again. The governed specification reads like this instead:

# EXA Constraint — Shipment Status Surface
# Governed by: Semantic Layer v3.x

- WHEN account_status = "CLOSED" AND demurrage_clock_running = true
  → token: status-critical   (NEVER status-info, NEVER status-warning)
  → tier: 1 (top 8px of component boundary)
  → surface action-primary: "Re-route Shipment"

- WHEN account_status = "AT_RISK" AND hours_to_breach < 72
  → token: status-warning
  → inline alert-banner REQUIRED above the status grid

- No status value may resolve to more than one token.
- Any state not enumerated here is a specification gap.
  → escalate to the architect. DO NOT render a guess.

The same surface, two specifications. The prose version leaves “appropriate” and “at-risk” for the agent to interpret — so it guesses, validates, fails, and loops. The governed version names the exact state and forbids the guess. One invites the retry loop; the other forecloses it.

Read the last line again, because it is where the money is. Do not render a guess. The governed specification does not just tell the agent what to build. It forecloses the loop. There is no ambiguous state for the agent to thrash against, and where a genuine gap exists, the agent is instructed to stop and escalate rather than burn a hundred tokens approximating an answer. The wrong output does not get cheaper. It stops being generated at all.

That escalation instruction needs a triage model behind it. At enterprise scale — a trading grid tracking a thousand vessels, a health insurer processing millions of eligibility events a month — specification gaps are not rare exceptions. They are continuous. A constitution that routes every gap to the architect’s queue has not solved the retry problem; it has traded a retry bottleneck for a review bottleneck. That triage model — the consequence tiers that separate a hard stop from a governed fallback, the amendment protocol, the signal-to-noise standard that keeps the architect’s queue from becoming the new constraint — is the operating discipline Article 3 builds. For this article, the point is narrower and economic: the instruction that forecloses the loop is what takes the retry off the invoice.

The engineering world has arrived at a parallel insight under the name Spec-Driven Development — GitHub Spec Kit, AWS Kiro, Cursor, and BMAD, all centering specification files as the primary artifact of agent-driven delivery. That framework governs code correctness: syntax, test coverage, API contracts, dependency rules. This one governs experience correctness: the states an enterprise carries liability for when they render wrong. The distinction matters to any CFO who assumes the VP of Engineering already has this covered. One missed token binding is a linting error. One missed eligibility state is a claims liability. The engineering constitution does not know what a Medicaid redetermination state is — and it was not designed to. This is not a competition to win. Engineering has solved the code side of the agentic enterprise. The experience side is the unsolved half — and the two constitutions together, authored by different people against different consequences, are what a governed agentic enterprise actually is.

The first question this raises in any engineering org is where the file lives. The answer is deliberately unglamorous. The Agentic Constitution is a text file — .md, .cursorrules, or a structured equivalent — version-controlled in the repository beside the code it governs, consumed directly at runtime by Claude Code, Cursor, GitHub Copilot, and every MCP-connected agent. It enters the CI/CD pipeline the way a linting configuration enters it, as a governed reference artifact — not as a new gate bolted on top of existing process. The infrastructure does not multiply. The constitution governs the infrastructure that already exists.

The Author, Not the Artifact

The harder question is who authors it. Writing governed constraint logic — enumerating states, pricing the failure of each one, specifying the fallback behavior — is not an evolution of wireframing. It is adjacent to software architecture, and a 200-person global design team does not convert to that mode of working through a process-change memo. The discipline already carries the distinction this requires: a Design Systems Lead does not expect every product designer to author the token system. The architect who has mapped the states and priced their failure is the one who writes the constitution. The product designers execute against it. What is new is that blurring that line now has a line item attached.

The transition is a multi-year investment in a senior specification function, not a sprint-scope decision. But the definition work is already funded — downstream, invisibly, at machine cost, as rework cycles and QA flags and production incidents and inference overruns. Moving it upstream does not add the work. It moves the work to where it costs a fraction of what the retry loop costs to resolve. The choice is not specify now or skip it. The choice is pay the definition cost once, upstream, in a role staffed for it — or pay the retry cost automatically, downstream, at agent speed, for every session the surface runs.

Precision is not the enemy of speed. Precision is the cheapest way to be fast.

The Boundary: Know Your Surfaces

This argument has a limit, and pretending it doesn’t would cost me your trust.

“Good enough” is the correct economic call for a real and large category of work. The internal dashboard three people will use for a quarter and abandon. The throwaway tool that scaffolds a one-time migration. The ephemeral surface where the cost of being slightly wrong is a shrug. Forcing constitutional rigor onto those surfaces is its own kind of waste — over-engineering a structure no one will ever load. Craft has a domain, and so does good enough.

The discipline is knowing which surface is which.

Because the same indifference applied to a sustained-use, high-consequence surface is not a saving. It is a deferred liability with interest. The commodity-trading grid an operator reads in the eighth hour of a shift, where a status that resolves to the wrong token sends a vessel to a closed terminal and starts a six-figure demurrage clock. The eligibility view where “good enough” surfaces a lapsed member as active and turns a specification gap into a compliance exposure. On those surfaces, the ambiguity does not just generate retries. It generates the kind of error that does not show up in the inference costs at all — it appears on the income statement.

The one thing that does not commoditize, the thing no falling token price ever touches, is the judgment that tells the two apart: which states matter, what each one costs when it is wrong, and how to specify them so precisely that no agent ever loops on them. Every organization will soon have agents that can build. Almost none will have the architecture that tells those agents what is worth building correctly. That gap is the whole game.

The Infrastructure of Intent

Production capacity has been retired as a competitive category. When the marginal cost of a business logic surface approaches zero, everyone has it — the incumbent, the challenger, the offshore team, the weekend experiment. The constraint flattens.

What does not flatten is the quality of the specification the agents execute against. The organization running cheap tokens against a vague spec is not saving money. It is compounding rework at the exact velocity it is compounding output, and it will not find the source on the invoice until the spend is already gone. The organization running those same cheap tokens against a governed Infrastructure of Intent is doing something structurally different. Every correct decision it encodes makes every future agent cheaper to run. It is converting deflation into leverage instead of converting it into volume.

The commoditization of production is exactly what makes the architecture the only moat worth having. When anyone can generate the surface, the value migrates entirely to whoever can specify it correctly the first time — and that person is no longer a cost the enterprise tolerates between funding rounds. They are the cost control the CFO has been hunting for, and looking in the wrong department to find.

The next meeting about AI inference costs will have the engineering team in the room. The finance partner. The product owners. The business leads. The delivery management team. Design will not be on that invite. The causal connection exists — the cost traced directly back to the specification layer, and the specification layer belongs to design. What does not exist is the measurement that makes that connection legible in the language of a budget review. The argument is correct. The meter has not been built. Leaders do not wait to be asked for the math. They bring it. Design has not brought it.

That is the entire gap. Not the value — the legibility of the value. A cost lever the CFO cannot measure is a cost lever the CFO will cut.

So consider the layer itself. The experience specification is the one place on that bill where the cost is both enormous and unclaimed. Engineering owns the code constitution. Finance owns the forecast. No one owns the layer where an ungoverned state becomes forty-four thousand dollars a month per component — and that layer is the design specification. It is not contested ground. It is empty ground with a meter running on it. The organization that staffs a senior function to own it converts the deflation into leverage. The organization that leaves it empty keeps paying the Retry Tax on every surface, in the dark, until the quarter closes and the number is already spent.

Cheap tokens don’t make a bad specification affordable. They make it scale.

Precision is not the enemy of speed. Precision is the cheapest way to be fast.

When production costs nothing, the only thing left worth paying for is the specification that makes production correct. This is not an argument about whether design deserves a seat at the table. It is an argument about a cost driver that is already running, already on the invoice, already producing a number someone in that budget meeting cannot explain — and that the design function is the only one positioned to own. The architect who has built the measurement earns a seat at every future review where inference costs are on the table. The architect who cannot prove it governs nothing.

Next in The Specification Economy: the causal argument is established. The harder problem is proving it — not philosophically, but in the currency a CFO trusts and can act on. The meter that does that tracks four lines: the Retry Rate burning on ungoverned states right now; the Deviation Caught Before Merge that prices the gap between errors caught upstream versus errors discovered in production; the Escalation Rate that translates an ungoverned state into a liability figure finance can read; and the Onboarding Velocity delta of a squad entering a governed system. Not a telemetry dashboard. A CFO-legible instrument. Article 2 builds it.

Enterprise Experience Architecture presents: The Specification Economy — Article 1 of 4. Explore the full EXA framework at reidexa.design/exa.