The Bills — The Rented Codebase

The first half named the rebounds; this half prices them. The second feature, the token meter, the offshore arithmetic, and the operations load that starts the day the factory works.

11.3 Why most companies will not get there (yet), continued

11.3f The second feature problem

The CEO's framing of wave two is the silver bullet: we went from idea to production in three days, with two engineers, instead of three months with twelve. The number is real, on the first emit. The follow-up question, and the next feature?, has a different answer.

How much does a successful product change between version 1 and end of life? Maintenance has been measured at 60% to 80% of total software lifecycle cost since Boehm's Software Engineering Economics (1981), and Lehman's first law is the harder one to ignore: an E-type system must be continually adapted else it becomes progressively less satisfactory (Lehman, 1980). Initial creation is the small fraction of the work. The factory's 10x lands on that small fraction.

Walk the math. Take Boehm's 80/20 split: creation is 20% of total cost, maintenance is 80%. Compress creation by 10x and the new total drops from 100 units to 82. The realisable gain on total lifecycle cost is therefore not 10x; it is roughly 1.2x, a ~22% improvement dressed in 10x marketing. The headline 10x is a 10x on the small slice, and the CEO buying it is buying a slim improvement on the new total, advertised at the old slice's compression rate.

A hand-drawn scene: a factory conveyor restarts its whole line to produce one small additional widget, the lone new widget teal at the end of a belt of identical items.

The second emit is structurally different from the first. The first emit took the brief and produced code that satisfied a freshly-emitted test stack; it ran fast because it had nothing to preserve. The second emit has to take the existing codebase, test stack, and customer expectations, and add a feature without breaking any of it. The agent that authored the codebase has no special memory of why it chose the patterns it chose; the next agent reads the source, reconstructs intent (sometimes wrongly), and emits a change that compiles, satisfies the new test, and quietly violates an invariant nobody had named.

There is a sharper version: drift on re-emit. Point the factory at a slightly-extended blueprint and the regenerated codebase is not the previous one plus the delta; it is a different codebase that also satisfies the old tests. Module boundaries shift, naming conventions update, every external API still works, and every internal contract a future feature might rely on has quietly moved. By v6 the customer is in production with the sixth codebase the factory has emitted, and only the external contract has been continuous.

"The codebase is rented" was supposed to make this acceptable: rent six codebases, ship one continuous product. True if the test stack covers the contract surface densely enough that no drift produces a regression. In practice, on every product more than a year old, some drift produces subtle behavioural change, the user notices, and the support team of Section 11.3e carries the ticket. Each re-emit pushes that load upward.

The honest version of the silver-bullet sentence is therefore: "we went from idea to production in three days. We will spend three months on every feature after the first, unless we built the iteration pipeline at the same time as the build pipeline." The slowdown is not a one-time tax; it is the new per-feature cost. The first emit is what wave-two CEOs are buying; the iteration discipline is what wave-three CEOs are building.

11.3g The compute-cost rebound: spend now, ration later

There is a second rebound underneath the headcount one, on the same clock. Section 11.3c's rebound is the cognitive load that did not fall when the team did; this one is the bill that did not stay small when the throughput grew. Both are invisible until the bill matures, and both are paid by the company that read the early number as the whole story.

The early number is intoxicating because it is genuinely small. A company turns its engineers loose on an agent runtime in 2026, watches throughput climb, and looks at the inference line: half a million dollars a year, against an engineering payroll in the tens of millions. The instruction that goes out is not be careful. It is use all the tokens you want; we are only spending five hundred thousand and getting this much back. The token budget is the cheapest growth lever on the board, and the company that rations it in 2026 looks like the company that rationed cloud spend in 2010: technically prudent, strategically asleep.

There is an old apology for this, Pascal's, usually mislaid to Twain: "I have made this longer than usual, only because I have not had the leisure to make it shorter." The token meter runs on the same grammar. The short version, the one clause that should exist, the feature withheld, is the expensive one, because it costs judgement instead of volume. A company desperate to build more is buying the long letter at industrial scale and reading the invoice as progress.

The early number is also produced by the early users, who are outliers: the enthusiasts who write their own harnesses on the weekend and whose tenfold token consumption genuinely returns tenfold output. The budget gets set by extrapolating them across an org chart that is not made of them. Measured across whole organisations, only about a quarter of AI initiatives return what was expected of them. The spend follows the mandate, which goes to everyone; the output follows the outliers the budget was calibrated on. The bill rises tenfold on schedule. The output does not.

A hand-drawn scene: a small factory building wired by a thick cable to an oversized coin-operated meter with a teal dial, a tall stack of coins leaning beside it, a hand reaching in from outside the frame to turn the dial.

Then the meter runs. Every feature after the first is a re-emit, and a re-emit is the factory regenerating against the whole blueprint again, not a diff: the second feature costs a full run, so does every bug fix that triggers a regeneration, every dependency bump, every nightly regression sweep. The drift surface of Section 11.3f is also a spend surface. The half-million becomes a number with a comma in it around the point the product is mature enough that most of the work is re-emission. The instruction inverts: please be considerate with your token usage; use it wisely. The same operator, barely a year apart, asking first for more spend and then for less.

The inversion rhymes with the mandate that started the whole thing. Section P.1b named the first memo: reflexive AI use is the baseline, prove you cannot do the work with AI before you ask for a person. The second memo is the first one's bill coming due, ration the tokens, prefer the smaller model, justify any frontier call, and it is no longer a forecast: the clock we modelled at eighteen months ran in nine. By April 2026 Uber, agentic tools across more than eighty percent of its engineers and more than sixty percent of its code machine-written, had exhausted its entire annual AI tooling budget, its operations chief conceding that token usage "just didn't seem to have a direct correlation with useful consumer features." By May, Microsoft was revoking the Claude Code licences it had issued months earlier and steering developers onto a cheaper in-house tier. The two memos look contradictory and are not: the first chased the productivity, the second is paying for it. And the only thing that makes the cheaper model safe to be forced onto is the part of the system the company is most tempted to cut, the test stack that gates whatever the model emits.

The supply side says the measuring will not stop. Uber's adoption push had run an internal leaderboard ranking teams by total AI usage; four months later it capped agentic tools at $1,500 per engineer per month, the metric inverting from reward-maximum-usage to reward-restraint. The same month GitHub moved Copilot to token-metered billing. Gartner forecasts AI agent software at $206.5 billion for 2026, up from $86.4 billion; the spend is not shrinking, it is being measured for the first time by the people who sign for it. The frontier vendors cannot discount their way out: the largest lost $1.22 for every dollar of revenue in Q1 2026, on course for a $14 billion loss, and filed to go public all the same. Those losses are structural, compute is paid again on every request, so a vendor whose unit economics bleed on every call has exactly one direction to move prices. The second memo is the customer's accounting catching up with the vendor's.

A timeline titled "from the first memo to the second", subtitled "mandate to meter, in fourteen months": April 2025, the first memo, reflexive AI use as the baseline expectation; April 2026, the budget burns; May 2026 in teal, the second memo, licences revoked, the leaderboard inverted, a per-engineer cap; June 2026 in teal, the meter spreads to metered credits at API rates. Rendered deterministically from the appendix's verified dates.

What changed is that the cost stopped being a rounding error and the company found it had no lever, because of a decision made when the spend still felt free. When the inference line was half a million, nobody argued about which runtime to standardise on; the company picked one proprietary agent and built the whole factory around it. That is right for velocity and wrong for price: velocity bills in month one, price bills when the vendor moves to consumption billing, a shape the book documents spreading across the AI-IDE category inside twelve months. 2026 is the year the price turned: two years of per-token deflation reversed, OpenAI's flagship launching at double its predecessor's list rate with independent analysis netting the efficiency gains out to tasks costing half again to nearly twice as much, while Goldman Sachs forecast token demand rising twenty-four-fold. The assumption under every euphoria budget, that unit price falls faster than volume grows, stopped being true the year the budgets were set. The one-runtime company cannot route the cheap eighty percent of its calls to a commodity model; it standardised on one meter, and the meter belongs to someone else.

The token bill is the headcount you thought you cut, re-billed by a meter you no longer control.

This is where the chapter's two rebounds rhyme. The headcount cut of Section 11.3c paid every cost and earned none of the benefit; the single-runtime commitment does the same trick in compute, buying the velocity, keeping the lock-in, and reaching the consumption-billing flip with no portability to spend in its own defence. The pitch was fewer engineers, higher margin. The reckoning is same product, astronomical compute, no margin, and the gross margin the book predicts compresses by a third is simply not there. The reckoning has a salary attached, and it lands on the executives who chose the lock-in. The operator move, treating the runtime as a portability decision while the spend is still small, is the same one Section 11.3h walks in full.

: IBM's 2026 CEO study: only ~25% of AI initiatives deliver the ROI expected of them. Just 16% have scaled enterprise-wide. S&P Global found 42% of companies abandoned most of their AI initiatives in 2025. See Appendix A for the full citation.

: AI costs begin to bite, Tom's Hardware, 27 May 2026. This covers the Goldman Sachs 24× token-demand forecast, Uber's exhausted 2026 AI tooling budget and the Macdonald quote, and Microsoft's licence revocations. See also Fortune, 22 May 2026, on Microsoft's internal cost reporting. See Appendix A for the full citation.

: GPT-5.5 may burn fewer tokens, but it always burns more cash, The Register, 8 May 2026. Quoted figures: GPT-5.5 launching at $5/$30 per million tokens, double GPT-5.4's $2.50/$15; real per-task costs 49–92% higher once the claimed efficiency gains are netted out. See Appendix A for the full citation.

11.3h The offshore arithmetic: the cheapest developer is still priced in dollars

Section 11.3g priced the runtime and found the lock-in. There is a second meter the euphoria budget never reads, and it sits next to a lever the company has been pulling for thirty years.

Start with the objective, stated plainly, because the slide deck never does. The wave-two pitch does not optimise for efficient engineers; it optimises for the fewest engineers. "More efficient" is what gets said on the call; "fewer heads on the next payroll run" is what gets modelled in the sheet. The implied limit is zero, and AI is sold as the road to it. What that ignores: the company already had a way to do the same work for less money, and has been using it since long before the first model shipped.

The cheaper-developer lever already exists, and it is called offshore. The routine tier of software work, the next ticket against the calcified codebase, has been arbitraged across labour markets for three decades. The offshore engineer is the original commodity tier. AI has its own version one tier down again: the lint pass, the boilerplate, the dependency bump, the test scaffold go to a commodity model, and the frontier model is reserved for the twenty percent that earns it. This is the same logic the company already runs on its humans, ported into the model layer, not a new idea it has to learn.

The frontier model is the senior engineer you put on the hard twenty percent. The commodity model is the offshore tier you put on the routine eighty. A company that runs one rate for both overpays for the routine and starves the hard.

Here is the catch. The token is priced in dollars; the offshore human is not. The frontier call is billed in US dollars at a rate a US-priced vendor sets and re-sets; the offshore engineer is paid in a currency whose cost-of-living is a fraction of that dollar. So the comparison the CEO is actually making, once the inference line stops being a rounding error, is not cheap-AI against expensive-human. It is dollar-priced compute against locally-priced labour, and across a wide band of the routine work the locally-priced human clears cheaper than the metered machine. The model did not abolish the labour market; it introduced a competitor that bills in the most expensive currency of the two.

The arithmetic stopped being hypothetical in May 2026. Fortune's reporting on Microsoft's internal numbers, at the company that had mandated the tools as hard as anyone, concluded that using the technology was costing more than paying the employees it was meant to replace. Nvidia's VP of applied deep learning put it in one sentence: "For my team, the cost of compute is far beyond the costs of the employees." "The least humans, via tokens" did not minimise cost; it minimised headcount while maximising spend. The org chart looks leaner on exactly the slide where the P&L looks worse.

And the offshore salary at least had arbitrage left in it: renegotiate it, re-source it, move it to a cheaper country, bring it in-house when the maths changed. The proprietary token meter has none of that left, and Section 11.3g already showed you cannot easily move it once the factory is built around one runtime. So the company that optimised for the least humans optimised, without noticing, for the one cost line on the P&L with no arbitrage remaining in it, and handed its rate card to a single vendor whose incentive, the moment the lock-in is real, is consumption billing. The board was promised a smaller, cheaper engineering organisation. It got a smaller one. The cheaper part went to the vendor.

Three decision gates left to right. Decision 1, primary business driver: fewer humans or lower cost (teal question mark). Decision 2, model requirements: frontier model (small slice) or commodity model (routine 80%). Decision 3, offshore strategy and cost arbitrage: a high-human-dependency failure (red cross), local offshore labour, and a single-vendor lock-in padlock that removes the arbitrage, with dollar-compute versus local pricing curves. Hand-drawn lines, single teal accent on the first decision point.

The operator move is to fix the objective function before the meter does it for you. Least humans was never the goal; least total cost at an acceptable level of risk is. That keeps both cheap levers in play: the offshore tier for the routine incremental work, and the commodity model for the routine machine work. The floor under the commodity tier is deeper than a discounted API: the strongest open-weight models, most of them Chinese, price the same work at one to two orders of magnitude under the frontier list rate, and past a volume threshold the move is to bring the models home entirely, run the open weights in-house, and meter the routine eighty percent in electricity and depreciation, a rate card no vendor can re-set. Run behind the gates this book has been building, that work does not need the frontier tier; the gate, not the model, makes the cheap emit safe. It reserves both expensive tiers for the work that earns them, the frontier model for the hard twenty percent and the high-cost engineer of Section 11.2 for the operational tail Section 11.3e showed never compresses to zero, and refuses to let any single meter become the only one the company can read.

The single-vendor risk stopped being theoretical in 2026. In May, Anthropic announced that from mid-June programmatic use, the agent SDK, the headless CLI, the third-party harnesses, would draw on a separate monthly credit at full API rates rather than the flat subscription. In February, OpenAI retired a model roughly 800,000 people were still choosing every day, on two weeks' notice. Neither is a scandal; both are a vendor managing its own economics, which is the point: the terms of the rented layer change on the vendor's clock, not yours, mid-quarter. One practitioner's response to the re-metering is the most concise statement of this book's argument I have met in the wild: "model is not the moat," you are paying to get your work done, and the models are interchangeable "if you are somebody who knows how to specify instructions clearly." The company whose intent lives in clauses and whose quality lives in gates reads either announcement, edits a routing table, and re-runs the factory.

Above the terms layer sits an equity layer nobody can price. Anthropic raised at $380 billion in February 2026 and $965 billion in May, then confidentially filed to go public days later. Strip the AI names out of the S&P 500 and the index's 142 percent two-year gain collapses to 16, a concentration stark enough that Goldman Sachs launched an ex-AI index to measure it. From the operator's chair the frontier layer is unpriceable in both directions: it may re-rate downward and take its roadmaps with it, or be propped into a quasi-utility on political timelines, and no blueprint clause can hedge which. What a blueprint can do is make the exposure small. The Section 11.1b discipline of choosing a less capable model on purpose pays a third time here: not only safer against the maintenance ceiling and cheaper against the bill, it keeps the cheap tier exercised, so the company never forgets it had a lever that was not the frontier vendor's to price.

: Fortune, 22 May 2026, reporting Microsoft's internal numbers; the headline finding: "Using the tech is more expensive than paying human employees." The Catanzaro quote is from the same report. See Appendix A for the full citation.

: Fortune, 24 Apr 2026, on DeepSeek V4's pricing and positioning, with 2026 self-hosting TCO analyses. Quoted figures: DeepSeek's API at ~$0.14/$0.28 per million tokens against GPT-5.5's $5/$30; in-house inference beating API economics past roughly a billion tokens a month. See Appendix A for the full citation.

: Fortune, 26 May 2026: the usage leaderboard, the $1,500 per-engineer per-tool monthly cap, and COO Andrew Macdonald's quotes verbatim. See Appendix A for the full citation.

: GitHub's own billing announcement (1 June 2026 effective date) and TechCrunch, 30 May 2026, for the documented post-flip bills. See Appendix A for the full citation.

: Gartner press release, 19 May 2026: AI agent software spending $206.5B forecast for 2026, from $86.4B in 2025. See Appendix A for the full citation.

: Q1 2026 operating-margin analysis of OpenAI's disclosed figures (negative 122%) and reporting on its internal projections (~$14B 2026 loss; confidential S-1 filed May 2026). See Appendix A for the full citation.

: Anthropic's June-15 programmatic-credit change as covered by The New Stack and VentureBeat; the quoted practitioner analysis is Mehul Mohan (YouTube, 14 May 2026). See Appendix A for the full citation.

: OpenAI's retirement notice and TechCrunch, 13 Feb 2026: two weeks' notice (29 Jan announcement, 13 Feb retirement), ~800,000 daily selections, the reversed August 2025 first attempt. See Appendix A for the full citation.

: Anthropic's own Series G and Series H announcements ($380B Feb 2026; $965B May 2026; confidential S-1 1 June) and Goldman Sachs's ex-AI S&P index with the 142%-vs-16% two-year split. The too-big-to-fail reading is one analyst's attributed thesis. See Appendix A for the full citation.

11.4 The real scaling problem starts after the factory works

A hand-drawn diagram: a central factory emits a stream of product packets along a high-throughput conveyor; above it four parallel monitoring lanes each end in a small autonomous-agent silhouette with a magnifying glass, their connectors accented in teal; below, a single human figure at a desk reads one summary sheet.

Most of the book to this point has been about getting the factory to produce the product. The harder problem starts the moment it does. A factory that ships 10x features and 100x systems introduces a new class of problem at a scale your existing operations did not have to solve: continuous distribution at the new throughput, monitoring thousands of changes without drowning the dashboards in noise, security when the emit rate outruns the human review rate by an order of magnitude, and issue resolution fast enough that nothing waits for a human to wake up and triage.

Traditional tools assume human monitoring and manual response. That assumption breaks at factory throughput. A Grafana alert designed for a 50-engineer SLO violation surfaces three times a year and pages the on-call. A factory shipping 100x changes a day produces thousands of alerts a day; the on-call cannot read them, let alone act on them. The same tool, used the same way, becomes noise that drowns the signal.

What the factory's operator needs, in the same shape as the gate-stack from earlier chapters, is autonomous operations: AI-driven detection, AI-driven diagnosis, AI-driven remediation. The systems the factory ships must self-observe, self-correct, and avoid cascading failures, because no human team can hand-stitch fixes at the rate the factory introduces them.

Two things have to be true for autonomous operations to be safe. First, the operating AI must be able to understand the systems it is operating on, the converse of Section 5.3b's collapse argument: the same architectural simplicity that made the codebase legible to the authoring AI is what makes it operable by the operating AI. Complex, inconsistent systems cannot be safely automated; the operating AI lacks the context to predict the blast radius of a fix. Second, the operating AI must be gated the same way the authoring AI is. Every fix runs through the same deliverable test corpus the factory used to validate the original emit; a remediation that satisfies the corpus is acceptable, one that does not is rejected even if the alert is real. The blueprint makes both the factory and the autonomous-operations layer trustworthy against the same standard.

A hand-drawn scene: a factory floor at night under a skylight crescent moon, machines running, one human silhouette watching from a catwalk with a teal-glowing lantern.

This is why simplicity becomes critical, not aesthetic. AI can only safely operate on systems it can understand. The 100x throughput is liveable iff the systems are simple enough that an operating AI can hold them in context, predict its own changes, and let the gate catch the rest.

11.5 Core principle

Pull the chapter to one line. The factory is not about generating more. It is about:

Standardising the patterns the system uses.
Simplifying the systems the patterns produce.
Automating the operations the systems require.

Only when those three are in place does AI scale development, scale operations, and reduce total cost rather than increase it. A factory that produces 10x more code without standardising, simplifying, or automating around it is the Phase 1 trap of Section 11.1. A factory that does all three is the Phase 2 outcome.

The operator reading this in 2026 has the chance to skip Phase 1. The operator reading it in 2028 will have lost the option.

AI adoption has two phases with a discontinuity between them. Phase 1 ships 10x more code and produces disillusionment as the maintenance bill arrives. Phase 2 ships 10x less code against the same product surface, and that is where AI becomes transformational rather than merely disruptive.
The wave-2 headcount cut is the costliest mistake on the board. The CEO reads the throughput dashboard, infers a 2x-faster team is 2x oversized, and cuts on the belief, not the productivity. Cut the headcount and the cognitive load does not halve with it, so the remaining engineers carry 200% of the accreted context, and the company re-hires within eighteen months at higher salaries, having paid the cut twice. Simplify the system first, then cut from a lower cognitive-load baseline.
The support team is the question the 10x never answers. The 10x is a delivery number; the product still has to be carried in production for years. The tickets the spec did not anticipate, the regulator's PDF, the deprecated API, the 3 a.m. on-call, none of these run at AI speed. The post-factory team is sized for the operational tail, not for the build.
The second feature costs what the first did not. The 10x lands on creation, the small slice of lifecycle cost; maintenance is the 60% to 80% the factory does not compress. Every feature after the first is a re-emit against the whole blueprint, drifting the internal contracts even when the external contract holds. The build-pipeline-only CEO watches the second feature slip from days to months, and so does every feature after it.
The compute bill is the second rebound, and in 2026 it arrived early. The early inference line is intoxicatingly small, so the company spends freely and standardises the factory on one proprietary runtime. Right for velocity, wrong for price: frontier prices reversed, the meter flipped to consumption billing, and the single-runtime company became a price-taker that cannot route its cheap calls to a commodity or open-weight model. The fix, per Sections 9.3g-9.3h, is to treat the runtime as a portability decision while the spend is still small, and to remember the models can come in-house past a volume threshold.
The real scaling problem starts after the factory works. Distribution, monitoring, security, and issue resolution have to become autonomous, gated against the same blueprint the factory uses. Simplicity becomes critical because AI can only safely operate on systems it can understand.
Beware AI-washing in the layoff cycle. The 80,000 big-tech cuts in Q1 2026 were largely a ZIRP-era unwind dressed in AI vocabulary; the genuine AI-driven restructuring lands later. CEOs following CEOs is not a strategy; the operator's job is to do the structural work the herd is only claiming to have done.

If the factory makes a few companies this much stronger, it makes the rest of the field structurally weaker. The next chapter studies who is exposed, and why.