Thoughts·Oct 12, 2026·14 min read

Understanding AI costs: a guide for mere mortals

Credits and flat subscriptions hide what AI really costs. At list price, my $200 Claude plan covered $11,158 of usage in September.

AI cost is complicated. There are several providers, each with a ladder of models, each model with its own price list, and on top of that a growing set of knobs: reasoning effort, context size, cache lifetimes, sub-agents. Some vendors bill in dollars, some in credits, and most sell a flat subscription that hides the meter altogether. And a few of the knobs only make sense once you understand, at least roughly, how these models work under the hood.

Most of us don't. We picked a tool, bought a plan and got on with the work, which is reasonable, but it means very few developers can say what their AI usage actually costs or which of their settings drive it. This is the guide I wanted when I started looking. It comes in two halves: how the price is presented to you, and what you can actually control.

What you are actually buying

Everything is tokens. You pay per million tokens, and every token is priced by what kind of token it is.

Not all tokens cost the same. Using Anthropic's Opus 5.5 as the example, here are the list prices per million tokens:

Output costs five times as much as input. Cache reads cost a twentieth of it. Hold on to both facts, because the whole bill comes down to them.

Coding is not chatting. When you chat with a model you send a paragraph, it sends a few back, and occasionally it runs a web search. A coding agent reads your files: hundreds or thousands of lines per task, then the test output, then the files again after it edits them. And because the model remembers nothing between steps, every step of an agent's work re-sends the entire conversation so far. A chat is a few thousand tokens. My busiest day of agentic coding was 4.4 billion.

Play money

The oldest trick in consumer pricing. Casinos worked it out first: you don't gamble with money, you gamble with plastic discs. Video games industrialised it. Fortnite sells V-Bucks, Roblox sells Robux, and every mobile game sells gems. The mechanics are well documented. A made-up currency breaks the link between spending and money, which takes the sting out of spending. Odd bundle sizes guarantee an awkward leftover balance, which nudges you towards the next top-up.

AI pricing has arrived at the same place. When GitHub moved Copilot to usage-based billing, it didn't bill in dollars. It billed in AI credits, and its own documentation is admirably frank about the exchange rate: one credit is one cent. They took the dollar amount and multiplied it by a hundred. The documentation also contains the sentence that sums up the whole practice: "Additional usage budgets are set in US dollars, and usage is shown in AI credits." You set your budget in one currency and watch it being spent in another.

The included allowances make it plainer still. Copilot Business comes with 1,900 credits a month, and Enterprise with 3,900. Those are the seat prices, $19 and $39, handed back to you as play money at a hundred to the dollar.

OpenAI did the same, at a different exchange rate. Codex credits are priced per million tokens: GPT-5.6 Sol costs 100 credits per million input tokens and 500 per million output. One credit is four cents. So GitHub converts at a hundred to the dollar and OpenAI at twenty-five, which means you can't compare the two without a calculator either. Even the conversion rates don't convert.

None of this adds information. A credit contains nothing a dollar doesn't. The only thing a credit adds is a conversion step, and a conversion step is where your intuition goes to die. You know what a dollar buys. You have no idea what 3,900 credits buy, and that is rather the point. Note the timing, too. The fake currency turns up at exactly the moment usage-based billing would otherwise have put an honest, alarming dollar figure in front of you.

Flat rates and the gym membership

Almost everyone sells a flat subscription. ChatGPT Plus is $20. Claude Max is $100 or $200. You pay the same whether you use it for five minutes or five hundred hours, and it feels like a good deal. That is because it is one, for now.

This is how gyms work. A gym can sell unlimited access for £30 a month because most members barely turn up. The members who never come pay for the ones who come every day. AI subscriptions run on the same arithmetic, with one addition: when there aren't enough light users to cover the heavy ones, investor money covers the rest.

A caveat, before anyone writes in. Everything below is valued at list price, which is what the vendor charges for API access. It is not what the compute costs the vendor, and list prices include a margin. So when I compare my usage to my subscription further down, I'm comparing it to what Anthropic would have charged me, not to what it cost Anthropic. The true cost sits somewhere in between, and nobody outside these companies knows where. The shape of the argument doesn't change. A subscription is a loss leader on heavy users, and loss leaders end.

The meter is still there, it's just in a different unit. Flat plans aren't unlimited. Claude Max has a five-hour session limit and a weekly cap, and they are shown as percentage bars. They're percentages of what, exactly? Nobody says. It's the same trick as credits, with a progress bar instead of a currency. To be fair to everyone, Anthropic included, as far as I can tell the consumer side of every vendor works like this.

Credit where it's due. I'm sceptical of Anthropic by default, so it's only fair to point out where it has held the line. The Anthropic API console shows you real dollar amounts. When a Claude subscriber runs past their plan limit, the top-up (confusingly also called "usage credits") is denominated in dollars and billed at standard API rates. There is no Claude-Buck. That matters beyond fairness. The usual defence of made-up currencies is that token pricing is too complicated for normal people to see in dollars. Anthropic's console proves otherwise. Showing the real number is a choice, and some vendors chose not to.

Taking the mask off

There is an npm package called ccusage that reads the local logs your coding agents already write and reprices every token at list price. It's the single most useful thing you can run if you want to know what your subscription is actually worth.

npx ccusage@latest daily

One catch: ccusage only sees about the last month of your Claude Code usage, because Claude Code deletes its transcripts after 30 days. To keep a longer history, set cleanupPeriodDays in your Claude Code settings to something large, such as 3650.

Here is what mine says.

My numbers

That is 56 times the Claude subscription and 13 times the ChatGPT one. My busiest single day, 7 October, was 4.4 billion tokens, worth $1,478.

I'm not a typical user. In September I used Claude Code every day for about twelve hours, most days reaching three sessions at a time, with around 60 sub-agents a day working for them. So if the Claude figure looks absurd, look at the ChatGPT one instead. Thirteen times a $20 plan, from fairly light use through OpenCode, an open-source tool that logs in with the ChatGPT account. The subscription doesn't even require you to use the vendor's own app.

Where the money goes. 97% of all my Claude tokens were cache reads. Fresh input, meaning what I actually typed plus anything new, was 0.007%. On 8 September the log records 112 input tokens. If your dashboard shows "input tokens", it is showing you almost nothing, while you consume billions.

Here is the list-price bill for Opus 5, which accounts for two thirds of my spend:

If you priced only what I typed and what the model wrote back, you'd get about $1,187, one eighth of the real figure. Cache reads are the cheapest token on the price list, and they are two thirds of the bill because the same context gets re-read thousands of times. That's the cheap line and the big line at once, which is exactly why a dashboard can mislead without technically lying.

The vendors don't agree on how to show it. My OpenAI traffic has the same shape, 93% cache reads, but the logs disagree about everything else. OpenAI reports no cache writes at all, because Codex doesn't charge for them separately. Its fresh input comes out at 6.5% instead of Anthropic's 0.007%, because the two vendors book uncached context differently. Same activity, two incompatible ledgers.

The buffet

My typed prompts barely changed this year: about 1,000 in January and about 1,300 in September. At list price, January's work came to roughly $2,000 and September's to $11,158.

This is the all-you-can-eat buffet effect. When the marginal cost of another plate is zero, you take another plate. A flat price removes the price signal, and without a price signal nobody learns to be efficient. Nobody tunes settings, nobody asks whether a task needed the most expensive model, nobody notices the agent re-reading the same file forty times. The only meter a subscriber ever feels is the session limit, and it measures patience, not money.

That's worth remembering for the second half. Everything below is about levers, and a flat rate is precisely the arrangement under which nobody bothers to pull them.

Reasoning you can't see

Modern models think before they answer. That thinking is tokens. You usually see a summary of it or nothing at all, and it is billed as output, which is the expensive side of the price list at five times the input rate.

So the most expensive tokens in your bill are frequently ones you never read. It's the purest gotcha in the whole system. It is also the first lever that's actually yours, because in most tools you can choose how hard the model thinks. I wrote more about that in How LLM reasoning works.

Two dials: class and effort

Every vendor sells the same ladder under different names. There is a light, cheap model, a workhorse, a flagship, and increasingly a heavyweight above the flagship. The names are poetry and tell you nothing. What matters is which rung you are standing on.

The rungs don't line up perfectly. GPT-6.1 Sol costs half as much as Opus 5.5, for a start. But the structure is the same, and so is the price spread. The heavyweight is the one that can eat a five-hour session limit in ten to fifteen minutes.

The second dial is effort. On top of choosing the model, you choose how much it reasons: low, medium, high, maximum. More effort means more of those invisible output tokens.

The dials multiply. The intuitive setting is "smartest model, maximum thinking". It feels responsible. It is also the most reliable way to set money on fire. You pay heavyweight rates per token, then multiply the token count with reasoning the task may not have needed.

The counterintuitive part is that the dials trade against each other. A higher-class model at low effort often beats a lower-class model straining at high effort, and costs less doing it, because the better model gets there without the long detour. Equally, a higher-class model at very high effort, pointed at a problem that needed neither, is a very good way to waste credits.

Price per token is the wrong unit. What you actually pay for is the finished task. A model that's cheap per token but needs three attempts and a lot of thinking can cost more than an expensive one that gets it right first time. That's why "GPT-6.1 Sol costs half as much as Opus 5.5" means nothing on its own. Leaderboards quote price per token because it's easy to measure. Your bill doesn't care.

Why nobody can give you the manual

Here I'll defend the vendors, because I don't think this part is deliberate obfuscation. Nobody publishes "use this model at this effort for this task" because no such guidance could be true.

The right combination depends on your project. A messy codebase with poor instructions needs far more effort from the model than a clean one with good instructions, because the agent spends its budget working out what you meant and where things are. The size of the project matters. So does how you work. With spec-driven development, you write down what is being built and where it lives before the agent starts. That can save the agent reading dozens of files or spinning up sub-agents to go and look. Two teams using the same model on the same kind of task can reasonably need completely different settings.

On top of that, the ground keeps moving. Anthropic's Opus 5.5 came out on 22 September at $4/$20 per million tokens, cheaper than the Opus 5 it replaced, and it outscores the heavyweights on most published benchmarks. In my own logs, Opus 5.5's blended cost per million tokens is roughly half of Opus 5's. That's less than three weeks of data, so treat it as an early observation. OpenAI is moving just as fast: it cut GPT-5.6 Sol from $5/$30 to $4/$20 on 21 August, and GPT-6.1 Sol, a month later, lists at $2/$10. Whatever setting was right last month may now be overpaying. The manual isn't hidden. It can't be written, and any version of it would go stale before it was published.

Two quieter costs belong here. First, sessions get more expensive as they go on, because every step re-sends everything that came before. A long-running session is paying to re-read its own history, so starting fresh or compacting the context is itself a lever. Second, everything that sits in the context permanently is paid for on every single request: the system prompt, your project instructions, the definitions of every tool and MCP server you've installed. Each plugin you add is a small tax on every step.

The cache has a timer

The cache reads that make up most of the bill are a discount. Instead of paying full price to reprocess the same context, you pay a tenth or less. The discount has an expiry date.

A cached context lives for a fixed time after it was last used. Anthropic's default is five minutes, with an optional hour. While you keep working, every request resets the timer and the cache stays warm. Stop for longer than the timer and the cache is gone. Your next message rebuilds the whole context from scratch at the cache-write price, and then the cheap reads resume.

The vendor may tell you what the timer is. It can also change it whenever it likes. The main takeaway is simply that it exists, and what it does. It punishes you for leaving your coding agent unattended. The natural rhythm of real work is to think, read, go to a meeting and come back. That's the expensive rhythm. The machine rewards the operator who never steps away.

My own logs hint at this. My Opus 5 cache writes are priced at about one and a half times the input rate. That falls between the five-minute rate of 1.25 and the one-hour rate of 2, which suggests a mix of both. I never chose either.

The best case is to hand the agent a task, go to the meeting, and come back to finished work. While it works, the cache stays warm. That works best when the agent knows where things are and what you want, so it never has to stop and ask. I described my own setup in The agent loop that ships while you are away.

What we learned

The mechanics are complicated, some of them are deliberately obscure, and none of them come with instructions. There is no right combination of model and effort you can look up. So the only honest advice is to experiment, and to do it in a particular direction.

Start low and escalate. Try the lighter model and the lower effort first. If the result is wrong, turn the dial up. You can always escalate a task that genuinely needs it, and failing cheaply costs almost nothing. Most people start at maximum and never come down, so they never find out what the task actually required.

Watch what the agent reads. If it is opening files it doesn't need, or searching the whole codebase at the start of every task, ask why. Tell it where things live. Give it the spec up front instead of letting it rediscover the project every morning. Every file it doesn't have to read is money you don't spend.

None of this is new. Tidy code, good documentation and a written spec have always made a project easier for people. They make it cheaper for an agent too, because it reads less and guesses less. Good code hygiene pays off, and now it shows on the bill.

And the ground will keep moving. Opus 5.5 showed that the frontier resets every few months, so any specific workflow advice has a shelf life. Understanding the mechanics doesn't. Tokens, cache, effort and class will outlast every model name in this article.

For now it is still perfectly convenient to buy a $200 subscription, set the effort to maximum and stop thinking about it. Someone else is paying for that. They won't be forever.