Choosing & Tuning Claude 5.5 Models

The table everything else hangs on

What the source claims

• Sonnet 5.5: “smarter, more efficient and 30% faster” than Sonnet 5, same per-token price, fewer tokens per task — “up to 30%” cost savings. Model ID claude-sonnet-5-5; 1M context, 128K max output (300K on Batches with a beta header); thinking on by default; effort levels low/medium/high/xhigh/max; default high on the API, medium in Claude Code; minimum cacheable prompt dropped from 1,024 to 512 tokens.
• Opus 5.5: input and output 20% cheaper than Opus 5, cache reads 60% cheaper ($0.50 → $0.20). The Opus post says it “costs 40% less to run than Opus 5” for typical workloads.
• Who does what: Sonnet for well-scoped everyday work with “a clear spec and a way to check the result”; Opus for nuanced judgment and long-horizon work; Fable 5.1 (2.5× Opus price, $10/$50) for long unsupervised runs and problems with no codebase precedent.

Why the same token price gives different bills

Each turn re-sends the whole accumulated context. The Opus post’s example: 40 turns averaging 70K tokens of context processes 2.8M input tokens, even though the conversation never exceeds 120K. Cut to 25 turns and you process 1.75M. Three levers then decide the price: turn count, how much of that input is a cache read, and how many output tokens (thinking included) you pay for.

Output is the expensive half

At $20/M output versus $0.20/M cache read, an output token costs 100× a cached input token. The post’s figure: 60K output tokens = $1.20 = the price of reading 6M tokens from cache. “You pay for all of it, even when Claude Code only shows you a summary.” Thinking is billed output, which is why effort (Module 3) is a cost control as much as a quality control.

The habits the post recommends — and their price

• Compact before a break, not after (cache still warm): about $0.25 at 150K tokens, saves about $0.025 per later turn — breaks even in ten turns.
• Cache lifetime: 1 hour on subscriptions, 5 minutes on API keys. A 120K write costs roughly $0.60–$0.96, a read about $0.02.
• Cache breakers: switching model, connecting an MCP server, and (on cloud providers) changing effort. In Claude Code, effort changes don’t break the cache.
• Fast mode: 2.5× speed at 2× price ($8/$40); the first request after enabling reprices the whole uncached conversation, so enable at session start.
• Agent teams: roughly 7× tokens for a standard session. Batch API: 50% off input and output.

The source’s model of effort

The evidence

Notice the pattern: the extra minutes were spent on tests and references. Effort buys verification behaviour. By domain, pass-rate gains from low to top: hardware +41 pts, security +23, science +20, ML +19, software +13, media +12, operations +10.

Reading the failure breakdown critically

Pragmatic rule

Choose effort by hidden-edge-case density and autonomy, not by how much you care: low for sketches, renames and brainstorming; medium for routine features (the Claude Code default on both models); high for brownfield fixes and anything where a wrong answer looks plausible; xhigh/max for unsupervised work or security-critical review. On Sonnet 5.5, levels are recalibrated — the Sonnet post says a level “doesn’t produce the same amount of thinking” as on Sonnet 5, and the Opus post says Opus 5.5 thinks more per turn than Opus 5 at the same level, most at xhigh/max. Old settings do not transfer.

What the playbooks tell you to do

• Define “done.” “Migrate the payment endpoints… Done means: every endpoint uses the new client, the old client is deleted, and the test suite passes.” Then say when to pause: only if “a test fails for a reason you can’t explain.”
• Remove “think carefully.” Opus 5.5 reasons by default; the post says removing it made responses faster without hurting quality.
• Stop/continue rules in CLAUDE.md: keep going when no input is needed; pause before destructive operations (deleting data, force-pushing, touching external systems).
• Persist the plan: “Keep a checklist in TASKS.md” so a compaction doesn’t lose it. Fan out large audits to subagents and validate their evidence before accepting it.
• Design by negation: list what to avoid (“no cream background, no italic accent words, no 01/02/03 labels…”) rather than asking for “distinctive.”
• Ask for blockers: “List only problems you’d block the merge for… why it’s wrong, and how to show it fails.” And “mark anything you couldn’t confirm, and say where you looked.”
• Delete rituals. The Sonnet post: if your prompts carry “refusal steering, tool-call retry shims, or ‘do not be lazy,’” remove them and re-run evals before tuning anything else. The cost post’s audited benchmark cut another 9% after removing mandatory procedures, scratchpad rules, verify-twice patterns and contradictory instructions.

client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    thinking={"type": "between_tools"},   # was {"type": "disabled"}
    output_config={"effort": "high"},     # between_tools: low/medium/high only
    messages=[...],
)

The cost post ends: “your own numbers are the ones to trust.” Its protocol: pick realistic backlog tasks, alternate models with /model, note turns, output tokens and cost per run, and finish 3–4 tasks before concluding. That is directionally right and statistically thin.

The break-even rule

Cheaper model S beats stronger model O when cost_S / p_S < cost_O / p_O, i.e. when p_S / p_O > cost_S / cost_O. With the reference session (Sonnet $1.40 vs Opus $2.40, ratio 0.58), Sonnet must finish at least 58% as often as Opus to win on tokens — before counting your review time, which almost always dominates.

Five improvements to the post’s protocol

1. Randomize order. Alternating A/B invites drift (you learn the repo between runs). Coin-flip which model goes first per task.
2. Use a checkable outcome (tests pass, eval score), not “looked fine.” Sonnet’s own prescription for when to use it is “a way to check the result” — use the same check for the experiment.
3. Measure time-to-accept, not just tokens. A cheap run you rewrite is the expensive run.
4. Hold out tasks. Tune effort on some tasks, confirm on others — the lesson of the sibling post on hillclimbing: changes that help the tasks you tuned on but not new ones are overfitting.
5. Expect variance. Terminal-Bench reports k/5 attempts for a reason. Three or four single runs cannot separate a 10-point gap from noise.

Quiz

Flashcards (click to flip)

Monday checklist

1. Pick your default: Opus 5.5 at medium for supervised multi-file work; Sonnet 5.5 at medium/low for repeatable, checkable jobs.
2. Put a real check (tests/build/type-check) and explicit done- and pause-criteria in every long-running prompt.
3. Delete “think carefully”, “do not be lazy” and verify-twice rituals; re-run an eval; then tune.
4. Build a 10-task held-out backlog; A/B models and effort with randomized order; record pass, tokens, cost and minutes-to-accept.
5. Audit cache behaviour: compact before breaks, enable fast mode at session start, avoid mid-task model switches.
6. Migration PRs: iterate content blocks by type; never ship a model-ID-only swap.