Introduction

For two years, the cost of building software with AI was a rounding error. A $20 subscription, a few API calls, and the model did the typing. That era ended in the week of November 10, 2026 — not with a price rise, but with a budget. On November 14, Tony Dinh, the Vietnamese indie hacker behind TypingMind, wrote that he now rations tokens per product, and set one small app to $500 of Claude Code tokens a month. Three days later, OpenAI and Microsoft both published cheaper coding models, and a 27,280-run benchmark showed that nearly two-thirds of agent inference spending goes to runs that fail. In the same week, the maker of a free, open-source coding tool said it had cost him more than $800,000 to build.

The token bill has become a line item. This article lays out what happened that week, what the numbers actually say, and what a one-person builder should do about the bill now that it has a name.

The $500 cap: what Dinh did on November 14

Dinh's post was short. "I needed to ration my tokens for each product now," he wrote on November 14, 2026. One app was "set to $500 worth of claude code token per month for development & maintainance" — his spelling — followed by a second post in capitals: "NO WASTED TOKENS!!!"

The app in question is small. On November 13, Dinh launched an offline Hacker News reader — "I built an app so you can read HN offline while on a flight." He says he accidentally priced it at $19.99. It now sells for $10 on the App Store, according to Sam Whitaker's report on Indie Hackers the next day.

The arithmetic that followed is what made the post travel. On the Indie Hackers thread about the launch, Zane Berg ran the store math: at $10, with Apple's 15% small-business cut, $500 of tokens takes about 59 sales a month just to break even on the agent. That arithmetic is his, and it reframes the cap completely. The token budget is not a cost to minimise in isolation. It is a cost of goods sold, and the app's price has to carry it. A $10 app needs roughly two sales a day before the coding agent has paid for itself.

The same day, Dinh posted separately about servers: "Expecting to lower my infra cost by at least half." That expectation is about infrastructure, a different line from the token budget. The two posts together show a founder doing what founders do when a new cost appears: put a number on it, and put the number on one product at a time.

Dinh had also signalled where he thinks prices are going. On November 10, his list of predictions for 2030 included the line: "Tokens will cost more, not less." That is his prediction, not a fact. But it explains why he is capping spend now rather than waiting for the price to fall.

What $500 buys against the price list

The striking thing about $500 a month is how it compares with the published prices. Claude's pricing page, read on November 18, 2026, lists Pro at $20 a month billed monthly, or $17 a month when billed annually with $200 paid up front. Pro includes Claude Code. Max is $100 a month, with five times Pro usage and $100 a month in API credits. Ultra is $200 a month, with ten times Pro weekly usage, no five-hour limit for verified accounts, and $200 a month in API credits. Prices exclude tax and are subject to change.

Dinh's $500 sits above the Ultra price — on one app. A single small product is consuming more than the most expensive consumer plan, in tokens alone. That is the gap between a subscription and a token budget: a subscription is a set bill with a usage ceiling, while a token budget is a cap a founder chooses per product, and it can sit anywhere.

Anthropic's own cost documentation describes a different group: enterprise deployments. Across those deployments, the average is around $13 per developer per active day, and $150 to $250 per developer per month, with costs below $30 per active day for 90% of users. The enterprise averages are not Dinh's bill. They are a reminder that the same tool has at least three prices — a plan, an average, and whatever one founder's agent actually burns.

The documentation also gives the levers for controlling the burn. The /usage command shows a session's token usage and cost. /clear starts a fresh session, and the docs say that "costs nothing". /compact is itself a large request. Each subagent sends its own requests. Those four lines are the whole cost-control manual, and the week of November 14 showed how many builders were reading it.

November 17: the vendors answer

Three days after Dinh's cap, the vendors moved — all in the same direction, and all on price. On November 17, 2026, OpenAI released GPT-6.2 Astra and GPT-6.2 Sol. Astra's API input and output token prices are 20% lower than GPT-6 Astra's, with a 60% discount on cached input: $8 input, $0.40 cached input, and $40 output, per million tokens, against $10, $1.00, and $50 before. GPT-6.2 Sol keeps GPT-6.1 Sol's API token prices — $2 input, $0.10 cached, $10 output. On Cognition's FrontierCode 2.0, OpenAI says Sol comes within 0.5 points of Astra "at about one-fifth the cost". That sentence is OpenAI's comparison, on that benchmark.

The same day, Microsoft published MAI Code 2, claiming it gives "98% of the performance of GPT 6.1 Sol at 40% of the cost", and 96% of Claude Opus 5.5's performance at 5% of the cost. Those percentages are Microsoft's benchmarks. A footnote says MAI Code 2's cost is shown at its 50% promotional price, and the post says the models are "explicitly not yet tuned for" harder problems such as very long horizon agentic work. Microsoft says MAI Code 2 is available in GitHub Copilot, and coming to OpenRouter, Vercel, OpenCode, and Kilo.

The price war had already started a week earlier. Anthropic released Claude Fable 5.2 on November 9 at $8 per million input tokens and $40 per million output tokens, down from $10 and $50 for Fable 5.1 — a 20% cut that now matches Astra's list price exactly. The pattern is now visible across all three vendors: the frontier model gets cheaper, and the cheaper model gets positioned as the sensible default. OpenAI's Tibo had already posted on October 29 that OpenAI is doubling usage limits for Pro tiers — more room inside a subscription, the same week the token price fell.

None of this settles whether coding is getting cheaper. A lower published price and Dinh's prediction that tokens will cost more, not less, are both on the record. What the vendors are competing on is no longer just capability. It is cost per task, and they are saying so in the announcement itself.

Where the money actually goes

The most useful number of the week came from neither a vendor nor a founder, but from a benchmark. Runta's FrontierHarness Eval v1.1, published November 17 and built with Baseten, ran 27,280 coding agent trials — 22 harness configurations, five open models, 62 terminal tasks, four attempts each — consuming 83 billion tokens in total. Its headline finding: 64.5% of the list-price inference cost went to trials that did not pass, 52.7% to failures and 11.8% to timeouts. Only about a third of the spend produced a passing result.

Two details make that number worse, and more useful. First, most failures did not time out. Among the five best-value harnesses, 68% to 82% of failed trials ended with the agent submitting a confident final answer that failed verification — a tighter time limit would not have stopped most of them. Second, spending more did not buy better results. With the model held fixed, the most expensive harness cost 1.9 to 4.9 times as much per pass as the cheapest, and the model explained 92.8% of the variance in cost per task. Steps per pass correlated with cost per pass at +0.51; prompt size, tool count, and cache hit rate correlated at roughly zero. Runta's advice to harness developers follows directly: "cut steps, not just prompt tokens", because every step sends the whole context again.

The same lesson showed up in a founder's own logs. On the Indie Hackers thread about Dinh's post, Mo, posting as AppsByMo, reported that a reply late in a long Claude Code session cost about 3.3 times a reply in a fresh session, so he starts a new session for each separate job. That multiple is self-reported, from his logs — and it matches the benchmark's finding exactly. The expensive part of an agent run is not the prompt. It is the accumulated context, re-sent on every step, in a session that has run too long.

Read together, the two sources say the same thing in different languages. The token bill is mostly the bill for work that did not succeed, and for context that did not need to be re-sent. That is why a cap per product is not just frugality. It is the only control a founder has over a cost that grows with every step the agent takes.

The other end of the same week: a free tool that cost $800,000

At the other end of the fortnight sits the opposite problem: a tool that charges its users nothing. On November 12, Theo wrote that T3 Code is "a free open source tool that has cost me $800k+ to make". On November 2 he had posted a shorter line: "We're broke and can't pay more people". The project runs coding agents such as Claude Code and Codex from one interface, users bring their own subscriptions, and its GitHub page says it "does not resell tokens". On November 11, per a chart Theo posted, agents running through T3 Code used 27.9 trillion tokens. The project passed 1,000 GitHub contributors. Its new guidelines say: "We are much more bottlenecked by review capacity than we are creativity, tokens or code."

Theo's numbers reframe the token debate. For the project, tokens are not the constraint at all — review capacity is. The same point came from Ilia Pomirchi on the same thread, who runs a few dozen Claude Code sessions and says tokens stopped being the limit months ago: reading what the sessions produced is the limit. He also notes that Google and Microsoft startup credits do not cover Claude, and that AWS credits do. That credit claim is his.

The contrast is the story. For Dinh, tokens are a bill to cap per product. For Theo, tokens are a river someone else pays for, and the scarce resource is human attention — his own, and his reviewers'. Both are true at once, because they describe different positions in the same stack: the founder who pays the model, and the maintainer who gives the model away.

There is also a counterweight in the same week's news: proof that an agent-built app can cover its own token bill. Rasty Turek, an engineer from a small village in Slovakia who worked on Gmail at Google and later founded and sold Pex, built Vaultaire — a privacy-first iPhone app for hiding photos, videos and files — in about three full-time weeks with coding agents. It was his first iPhone app. The numbers he shared with Indie Hackers: $66 at the start, more than 40,000 downloads within five months, $26,384 in gross App Store sales in July and $41,425 in August. The token bill is real, and so is the revenue on the other side of it.

Lessons: three mechanisms for a solo builder

The week produced more than news. It produced three mechanisms a one-person business can set up now.

  1. Cap tokens per product, and price the app to carry the cap: Dinh's mechanism is a ceiling with a number on it — $500 of Claude Code tokens a month on one app — not a vague intention to spend less. The executable version is to give every product its own monthly token cap, check it with /usage, and treat the cap as a cost of goods sold when setting the price. Zane Berg's math is the test: at $10 with Apple's 15% small-business cut, $500 of tokens needs about 59 sales a month to break even. If the price cannot carry the cap, either the price or the cap is wrong. The guardrail is honesty about which one you change. A cap that is never hit is a decoration; a price that cannot carry the cap is a slow loss.

  2. Start a fresh session for each job, and watch the hidden multipliers: The benchmark says steps drive cost, and Mo's logs say a late reply costs about 3.3 times a fresh one. The executable version is one job, one session: use /clear to start fresh — the docs say it costs nothing — and treat a long session as a cost, not a convenience. Watch the two multipliers the docs name: /compact is itself a large request, and each subagent sends its own requests, so a session that spawns subagents is several bills, not one. The guardrail is review capacity, which is Theo's lesson as much as Dinh's. A fresh session is cheap; reading what a dozen stale sessions produced is the real bottleneck.

  3. Route routine work to the cheaper model, and cut steps before prompts: November 17 gave builders a cheaper frontier model and a cheaper everyday model on the same day, and the benchmark says the model explains 92.8% of cost variance while the harness multiplies it up to fivefold. The executable version is to split the work by difficulty: the frontier model for the hard reasoning, the cheaper model — Sol at one-fifth the cost of Astra, or Microsoft's MAI Code 2 where it fits — for routine edits, and a harness chosen for steps, not for prompt size, since steps correlate with cost and prompt size does not. The guardrail is the fine print. Microsoft's 5%-of-the-cost claim is shown at a 50% promotional price, on models not yet tuned for very long horizon work, and OpenAI's Sol comparison is on one benchmark it chose. A cheaper model for a routine edit is the pitch. Test it on your own tasks before moving the whole workload.

What is not settled

A hot week deserves a clear list of what is still unknown. The vendor price cuts are real, but Microsoft's headline comparison uses a promotional price, and OpenAI's Sol claim rests on a single benchmark. Dinh's prediction that tokens will cost more, not less, directly contradicts the direction of the week's prices, and both are on the record. Two shutdowns are already dated: Claude Sonnet 4.5 stops working on November 30, after which API requests naming it will fail, and Google reroutes Gemini 2.5 on December 1, with calls to 2.5 Pro answered and billed by Gemini 3.8 Flash. A founder who hard-codes a model name into a product or a workflow will pay for that choice twice — once in migration, once in the new price.

The subscription-versus-tokens question is also unsettled. A subscription is a set bill with a usage ceiling; a token budget is a cap that can sit on one product. Dinh's $500 sits above the $200 Ultra plan, and Anthropic's enterprise averages describe yet another group. Which costs less depends on the month you actually run, and no vendor publishes one price that fits every builder.

And the benchmark itself carries its own caveats. It covers open models served by one provider, each pass rate carries a margin of about ten points, and its costs are list-price estimates, not invoices. The 64.5% figure is a signal from coding work, not a measure of every AI tool.

Closing

A year ago, the cost of building software with AI was a subscription you forgot about. This week it became a number on a spreadsheet: $500 a month, per app, with 59 sales to break even, and nearly two-thirds of the spend going to runs that never passed. The vendors answered with cheaper models on the same day the benchmark showed where the money goes. The founders who will do best are not the ones who find the cheapest model. They are the ones who cap the spend per product, start fresh sessions, and cut steps before they cut prompts — because the token bill is not really a price problem. It is a process problem, and the process is now the product.

Sources

Thematic placeholder: this hot-event article pictures no person.