On a March evening in 2026, Boris Cherny — the engineer who built Claude Code, the agentic coding system that now writes approximately four percent of the code committed to GitHub — posted a short technical clarification to Hacker News on the behavior of prompt caches.1 To a general audience the post read as routine engineering prose. To readers familiar with the underlying infrastructure, it functioned as the inadvertent autopsy of an entire genre of business reporting.

“Normally, when you have a conversation,” Cherny wrote, in the patient cadence of someone who has explained the same thing too many times, “the system hits the prompt cache for N-1 messages…”1

What followed was a brief lecture in modern infrastructure economics. Claude Code, like every serious agentic coding tool, holds context — repository files, conversation history, tool definitions — in a prompt cache that lasts an hour. Walk away from the workstation for sixty-one minutes, and the cache evicts itself. The next prompt requires the model to load the entire million-token context back into high-performance GPU memory in a single, full-context write.

That, Cherny was explaining, is the structural source of the billing surprises. The bills come from idleness — from a coffee break, a Slack message, a sandwich — not from the underlying unit economics of inference.

It was the kind of footnote on which careers in software are quietly built. It was also the precise answer to a question that had become, depending on the audience, either the most thrilling or the most expensive question in the technology business: is AI coding actually real?

The reigning answer in May 2026 depended almost entirely on where the question was asked. In the offices of Futurism, where a writer named Frank Landymore filed a piece arguing that the economics of AI coding were “looking worse than ever,” the answer was a confident no.2 The bills were apocalyptic. Compute, an Nvidia executive had told Axios, was now more expensive than employees.3 Companies were spending fortunes chasing productivity gains that ninety-five percent of pilot programs failed to capture.

On the platform formerly known as Twitter, a tightly networked cohort of approximately thirteen hundred AI founders, agentic-orchestration evangelists, and a faction known to itself as “vibe coders” reached a conflicting conclusion. AI coding, in their reading, was not just real but a category-redefining, ten-to-one-hundred-x productivity revolution.

Both groups were looking, more or less, at the same data. They reached opposite conclusions. They could not agree on whether something terrible or something miraculous was occurring. The answer, on inspection, is both — and neither — and, mostly, something more structurally interesting.

Consider Claudiu. Claudiu is, or was, a developer in Romania. His story surfaced on Reddit in late spring 2026, in an r/programare thread that travelled in the local fashion. Claudiu had been operating Claude through an automated pipeline — the kind of agentic loop where the system is given a task, attempts it, observes its own failure, and tries again. In Claudiu's case, the loop had no hard ceiling. It ran for an entire billing cycle. By the time anyone noticed, he had accumulated €150,000 — approximately $160,000 — in API charges. He was, predictably, fired.

The €150,000 figure, transmuted into dollars and stripped of context, became a centerpiece of the Futurism piece.2 Bills, the article warned, were running into six figures a month per employee.

This was, in the way the most rigorous-looking journalism is sometimes most dangerously off-target, the wrong fact for the argument it was being asked to support. Claudiu's bill is not the cost of using AI to write software. It is the cost of leaving an unattended runaway agentic loop running for a billing cycle — the way a five-figure utility bill is technically the cost of electricity but is more accurately the cost of leaving every appliance in the home running for a year while on vacation.

The infinite-loop bill is real. As a verdict on the unit economics of agentic coding, it is roughly as relevant as judging the economics of cloud computing by a forgotten EC2 cluster left running for nine months.

Then there are the so-called “tokenmaxxers.” Tokenmaxxing is a workplace phenomenon that emerged in early 2026 at certain large American technology firms. It was profiled in the New York Times that March and has since become a quiet fixture in compensation committees. It is, briefly, the practice of engineers competing on internal company leaderboards over who can consume the most AI compute in a given week. Some cross 10 billion tokens. Many cross it deliberately.

It is an old phenomenon in a new costume. In the 1990s, software developers were measured in lines of code, until management noticed that this incentive structure produced very long, very stupid code. The contemporary equivalent — measuring engineering productivity by the dollar value of AI compute consumed — has been gamed in approximately the manner one would expect. Tokenmaxxers' bills are real; they are also evidence of a compensation-design failure rather than a per-seat unit cost.

The Catanzaro quote — the assertion that compute is now more expensive than employees — has been deployed against the AI industry in approximately four hundred subsequent articles.3 The quote is real. The structural problem is what Catanzaro was actually discussing.

Catanzaro is the Vice President of Applied Deep Learning Research at Nvidia. His team builds frontier models — multi-hundred-million dollar training pipelines that run for months on warehouse-scale GPU clusters. The compute he was describing was training compute, not the inference compute that runs in a developer's editor when Claude Code refactors a function.

Citing Catanzaro to characterize the per-seat cost of inference for a working developer is the analytical equivalent of citing the cost of building the first prototype of an automobile to argue that ordinary commuters cannot afford to drive cars. It is, technically, accurate. It is, as analysis, a category error — and the category error compounds with each citation.

To understand whether AI coding is actually too expensive requires the unfashionable step of doing the arithmetic.

The fully loaded annual cost of a mid-to-senior software engineer in the United States — base salary, benefits, taxes, hardware, real estate, recruiting amortized over expected tenure — runs between $200,000 and $250,000. That works out to between $16,666 and $20,833 a month. A nearshore engineer in Eastern Europe or Latin America runs $7,500 to $9,000 a month, fully loaded.5

Anthropic's revised estimate for heavy, unoptimized use of Claude Code — the figure that anchored the Futurism doom case — is approximately $13 a day, or $286 a month at twenty-two working days.4 Allowing a generous overhead for GitHub's new metered AI Credits and agentic code-review minutes, the upper bound for a fully-unleashed multi-agent setup lands at roughly $400 per developer per month.

That is 2.4 percent of the fully loaded cost of one US engineer. Approximately four percent of a nearshore one. To break even on that expense, the system does not need to deliver a tenfold productivity miracle, or even a doubling. It needs a conservatively-estimated fifteen percent gain in net engineering output. At which point the firm is realizing better than five hundred percent ROI on the API spend.

The question of whether AI coding is “expensive” reduces, on inspection, to whether one of the most leveraged inputs in the modern economy is too expensive at four cents on the labor dollar. The arithmetic is unambiguous.

What the Futurism piece does correctly identify — and this is the part the X cohort tends to glide over — is something subtler than runaway bills. It is the workslop problem.

“Workslop,” a term coined by Stanford's Jeff Hancock and BetterUp Labs' Kate Niederhoffer, describes AI-generated work that appears polished, reads as professional, and is in some deep, structural way useless. A 2025 survey of 1,150 American workers found that 40 percent had received workslop from a colleague or boss in the previous month; the average instance took two hours to resolve; the estimated cost was $186 per employee per month.7 At 10,000-person firm scale, that is approximately $9 million annually.

This is the critique that survives the math. Software engineering, traditionally, has had a single dominant bottleneck: generation. The act of producing the syntax. Agentic coding systems demolish that bottleneck. They produce thousands of lines of plausible code in minutes. What they do not always produce — what they cannot produce, without architecture and oversight — is the second-order judgment about whether the code is correct, secure, maintainable, or even conceptually pointed in the right direction.

The bottleneck does not vanish. It relocates from creation to curation. From writing to reviewing. From producing the words to determining which of the very confidently produced words can actually be trusted.

The 81 percent productivity gain on simple boilerplate is real. So is the 67 percent gain on API integrations. So is the much smaller 18 percent gain on complex algorithmic work. So is the embarrassing 12 percent gain on security-critical code, where every AI suggestion has to be audited twice by a human who understands what the AI did not.6 The numbers fall, gracefully, in proportion to the human judgment the task requires. This is not a failure of the technology. It is a description of the technology.

These are not vibe-coded toys. They are production systems, and they were not built by the 95 percent of enterprises whose pilots fail.10 They were built by the five percent that figured out the architectural prerequisites: caching strategy, subagent delegation, deterministic hooks for testing and validation, and an understanding that AI does not eliminate engineering discipline — it abstracts it. The discipline still has to live somewhere. In the successful five percent, it lives in the orchestration layer. In the failing 95 percent, it lives nowhere — and the workslop, the runaway bills, and the panicked headlines are what missing-discipline looks like at scale.

Implications for leaders

1. 01Institute architectural review for AI coding deployments before scaling beyond pilot.
2. 02Track curation cost — review hours per AI-generated PR — as a primary KPI alongside generation throughput.
3. 03Treat metered token billing as a forcing function for orchestration discipline, not a procurement obstacle.