Anthropic
Blogcast

Alex: There's a new developer guide out from Anthropic this week, and it's about a question every Claude Code user has quietly asked themselves: where exactly is the money going?

Jordan: This is one of my favorites. It's called What a task costs on Opus five point five, and it's not a price announcement, it's a breakdown. It answers three questions: what your typical tasks cost on Opus five point five, which settings change that, and how to check your own session usage.

Alex: The framing is great. You never set out to buy millions of tokens. You set out to build a feature or finish a migration. The token count is just whatever the model needed to get there.

Jordan: And two models with the same cost per token can cost very different amounts on the same task. One reads the code once. The other reads it, tries a fix, and reads it again. Every one of those steps is a turn, and every turn resends the conversation so far. So the model that needs more turns costs more, even at the same price.

Alex: The post walks through the four things that set what a task costs. First, turns. A turn costs more than the tokens it adds, because it resends everything before it. So the cheapest turn is the one you don't need.

Jordan: Their example: a task starts with twenty thousand tokens of context and grows to a hundred and twenty thousand. At forty turns, that works out to roughly two point eight million input tokens for the whole task, even though the conversation never grew past a hundred and twenty thousand. With ninety percent read from cache, the input costs about a dollar sixty-two. The same task in twenty-five turns costs about a dollar and two cents.

Alex: Second factor, cache reads. That same two point eight million tokens costs eleven dollars and twenty cents with no cache, versus a dollar sixty-two at a ninety percent hit rate. No other setting moves input cost this much.

Jordan: Third, output tokens. On Opus five point five, an output token costs a hundred times what a cache read costs. Sixty thousand output tokens runs about a dollar twenty, the same as reading six million tokens from cache.

Alex: And here's the part that surprises people. Thinking is billed as output. You pay for all of it, even when Claude Code only shows you a summary. That's why the effort setting, which mostly changes how much the model thinks, moves the bill so much.

Jordan: Fourth, the model itself. Each model has its own prices, and the model you pick sets the price of every token.

Alex: Now what changed in Opus five point five? Two things: the price, and how much work the model does. Every price line is lower. Input and output are twenty percent cheaper than on Opus five, and cache reads are sixty percent cheaper.

Jordan: The actual numbers: four dollars per million input tokens, twenty dollars per million output, and twenty cents per million cache reads. On a Pro, Max, or Team plan, the lower price gets passed through to your limits, so they stretch about twenty-five percent further.

Alex: Now the headline number you've probably seen: Opus five point five costs forty percent less to run than Opus five. But that's an estimate for typical workloads at default settings. It assumes the model uses fewer tokens per task on top of the lower prices. It is not a forty percent cut to the price of a single token.

Alex: Let's talk effort, because this is where most people can save real money. Effort sets how many tokens the model spends per turn: its thinking, the text it writes, and its tool calls. Opus five point five has four levels, low, medium, high, and extra-high, plus max for a single session.

Jordan: Medium is the default, and it's the starting point for well-scoped daily work. When medium stalls, try high. It spends more per turn, but less than moving to a bigger model. Use low for mechanical work, like renames or applying a known pattern across files.

Alex: The pricing intuition is neat. Say high adds twenty thousand thinking tokens across a task. On Opus five point five that's forty cents. A retry loop of ten turns at a hundred thousand tokens of cached context, with ten thousand output tokens, costs about the same. So high pays for itself on any task where it saves one retry. On a task medium would have finished the first time, it's wasted.

Jordan: And the clearest sign you need more effort is a fix that stops at one layer. Their example: a field is renamed in an A P I handler. At medium, the model updates the handler, the tests pass, and the client still sends the old field. It just didn't read far enough to find the second caller. At high, it reads the call sites before it writes, and changes both layers in one pass.

Alex: Before you raise effort, though, check whether the model has a way to check its work. A test run costs one turn and its output. More effort adds thinking to every turn.

Jordan: Then there's model choice, which moves the bill more than effort does. Their rule of thumb: three models most days. A small one for lookups, Opus five point five for work you supervise closely, and a bigger one for the hardest tasks.

Jordan: Opus five point five is the daily driver: feature work across a few files, debugging, and code review with follow-up edits. Move up to Fable five point one when the result matters more than the token price. Long runs you won't supervise, problems with no existing pattern, and large changes coordinating many subagents. Don't wait for a third failure. If Opus five point five on extra-high hits the same problem twice, switch, and switch back once it's solved.

Alex: Fable five point one lists at ten dollars per million input tokens and fifty dollars per million output, two and a half times the Opus five point five price. And switch at a natural break. The cache belongs to the previous model, so the first turn on the new model pays the write price on the whole conversation. Run compact first, or start a fresh session with a short written plan.

Jordan: For lookups, move down to a smaller model. Use subagents that search and summarize, read logs and test output, and answer where things are defined. Each subagent runs in its own context window and hands back a summary, so its file reads stay out of your main conversation. But keep judgment calls on the main model. A small model that misreads a search result sends the main model after the wrong file, and the main model pays for the detour.

Jordan: On caching: a cached read costs five percent of a fresh input token, but writing to the cache costs more than a fresh read. At a hundred and twenty thousand tokens of context, a five-minute write costs about sixty cents and a read about two cents. So on an A P I key, a six-minute coffee break turns the next two-cent read into a sixty-cent write.

Jordan: Even with a warm cache, every turn resends the whole context, so long sessions cost more per turn. At a hundred and fifty thousand tokens of context, thirty turns spend about ninety cents on reads alone, much of it left over from earlier work.

Alex: That's where compaction comes in. Slash clear empties the conversation and costs nothing, so use it between unrelated tasks. Slash compact summarizes older history and costs one request, roughly twenty-five cents at a hundred and fifty thousand tokens, and each later turn saves about two and a half cents, so it pays for itself within about ten turns.

Jordan: Compact at a natural break, though. A compaction in the middle of a debugging session can drop the one log line that mattered. And compact before a break, not after one, because while the cache is warm the summary request reads from it.

Alex: Your CLAUDE dot M D file loads into context at the start of every session, so every line is part of what every turn resends. The docs suggest keeping it under two hundred lines. And turn off the M C P servers you're not using.

Jordan: So how do you measure all this on your own work? Run slash usage at the end of a task. The session block shows token use and an estimated dollar cost, and a prompt-cache line shows how much of your input came from cache. Check the cache share, output against input, and total input against the size of the conversation.

Alex: Then run the same task twice. Pick something from your backlog, not a toy example. Switch between Opus five and Opus five point five, note turns, output tokens, and cost, and do three or four tasks before drawing a conclusion.

Jordan: And try the effort ladder. Run one hard task at medium and then at high. Run one mechanical task at low.

Alex: Their final checklist: use medium effort for well-scoped daily work. Give the model a way to check its work. When medium stalls, raise effort to high. If extra-high hits the same problem twice, switch to Fable five point one. Keep long sessions moving so the cache stays warm, and use slash clear between unrelated tasks.

Jordan: And the one that matters most: run one real task on each model and compare what slash usage reports. Your own numbers are the ones to trust.

Alex: That's a dense post, but a practical one. If you're on Claude Code with Opus five point five, it's well worth your time.

Jordan: We'll talk to you on the next one.