Reducing Claude API Cost: Caching, Prompt Audits, and Effort Tuning

Anthropic's own developer platform team just told builders something counterintuitive: the biggest waste in most Claude-powered apps isn't the model choice — it's leftover prompting habits from a year of chasing weaker models, plus cache configuration nobody revisited after the last migration. On September 8, 2026, Anthropic's ClaudeDevs team — Lance Martin, Brad Abrams, Isabella He, and Ben Lehrburger — published "Reducing cost and improving performance with Claude Platform", a first-party playbook covering prompt caching mechanics, six prompting anti-patterns that actively hurt frontier models, and how to calibrate the effort parameter with real benchmark data — plus three new /claude-api slash commands that automate the audit.

This isn't a one-day product announcement. It's a technique guide you'll want to run against your own codebase more than once, so we're treating it as what it is: a how-to reference, reproduced here with the actual numbers and copy-paste commands.

TL;DR: the three levers, in order

Do these in order. Caching is free — it changes nothing about what the model does. Removing anti-patterns is close to free — it's deleting dead weight. Effort tuning is a real tradeoff that needs measurement against your own task.

How prompt caching actually works

Before Claude generates a response, it processes the entire prompt into an internal working state — the prefill — which is the expensive part of every request. Prompt caching saves that KV cache: a request that starts with the exact same prefix as a prior request reads the cached state back instead of recomputing it. Cache reads bill at a fraction of the full input price — as low as $0.25 per million tokens on Claude Fable 5.1, versus $1.00/MTok for Fable 5's cache reads, and both are a fraction of full input pricing (see Claude's current model pricing for the full table).

Three constraints govern whether a request can use the cache at all:

• The cache is pinned to a specific model. Switching models mid-conversation is a guaranteed miss.
• Cache reads must be byte-exact across the prefix. One changed character anywhere in the cached region invalidates everything after it — this is the same prefix-matching mechanic that governs Claude Code's own session cache.
• Cache entries have a limited TTL — 5 minutes by default, extendable to 1 hour on request.

The mistakes that quietly break your cache

Anthropic's guidance calls out specific, easy-to-miss ways teams burn their own cache without realizing it:

1. Changing effort mid-conversation. Effort settings render into the prompt ahead of content and become part of the cached prefix. Only Opus 5 and Fable 5.1 support updating effort mid-conversation via a per-message system entry without invalidating the cache — every other model treats an effort change like any other prefix edit. This is the single most common accidental cache-buster in agentic loops that dynamically escalate effort.
2. Volatile values in the system prompt. A datetime.now() call or a per-request UUID baked into the system prompt busts the cache on every single request — put timestamps and IDs after the cache breakpoint instead.
3. Tool definitions that reorder themselves. Tool defs render at the top of the prompt in a fixed order. Any reordering — even without changing content — is a byte-level change to the prefix.
4. Forking conversations carelessly. Subagents and conversation branches only inherit the parent's cache when the fork's prefix is byte-identical, on the same model, at the same effort. A subagent spun up with a slightly different system prompt starts cold.

How to fix it — the concrete moves

• Monitor hit rate, don't guess at it. Both the Claude Console and the cache diagnostics API surface why a request missed and exactly where two requests' prefixes diverged — check usage.cache_read_input_tokens on every response; if it's consistently zero across repeated calls, something upstream is invalidating you silently.
• Defer rarely-used tools with defer_loading: true so they sit outside the cached prefix and only get appended when Claude looks them up via tool search — this keeps a large tool catalog from bloating (and invalidating) every request's prefix.
• Apply mid-conversation instructions as messages, not system-prompt edits, on models that support it (Opus 5, Opus 4.8, Fable 5/5.1) — this preserves the cached history instead of rewriting the prefix.
• Layout matters: stable content (tool defs, system prompt) first, growing conversation behind it. Move the cache breakpoint forward as the conversation grows — Claude Platform can auto-apply it to the last cacheable block.
• Time model/effort switches for a moment the cache is already broken — right after a compaction event, for example. You're paying for a miss regardless, so it's a free window to change configuration.
• Pre-warm the cache by sending a request with max_tokens: 0 and an explicit cache breakpoint at the same effort as real traffic — this processes and writes the prompt to cache without generating output. Do this while a user is typing, so their first real request lands on a warm cache.
• Watch the TTL against your agent's own latency. The default 5-minute TTL counts from request start. If your agent blocks on tool calls or subagent requests that run longer than 5 minutes, the cache will have expired before the result even comes back — request a 1-hour TTL on the prefix for that shape of workload.

Six prompting anti-patterns hobbling your frontier model

Prompts accumulate defensive instructions written to patch an older, weaker model's specific failure modes. Frontier models don't need the patch — and taken literally, the patch actively hurts them. Anthropic names six recurring patterns:

Anthropic's benchmark makes the cost of ignoring this concrete. Migrating a customer-support benchmark from Opus 4.8 to Opus 5, they tested six legacy prompts — each seeded with exactly one of the anti-patterns above. Running /claude-api prompt-audit once per prompt, before touching anything else:

• Cost fell 14.6% and accuracy rose 5.3% on average versus the anti-pattern-laden Opus 5 baseline.
• The retired thinking setting made Opus 5 reject every routing request outright — a dated budget_tokens config that the newer model's API simply refuses.
• The contradictory refund rules made Opus 5 withhold four owed refunds while asking the customer for confirmation it didn't need — the literal-instruction-following that makes frontier models powerful also makes them brittle against contradictions.
• The manual scratchpad collided with Opus 5's built-in thinking, causing it to write tool calls inside its own reasoning text instead of emitting proper tool_use blocks — on three tickets, those calls simply never executed.

Fix it: /claude-api prompt-audit

Run this against prompts, skills, tool descriptions, or any application code that calls the Claude API — including your own CLAUDE.md and skill files:

/claude-api prompt-audit

The command establishes scope and a target model from your request and repository, inventories every prompt surface, checks provenance (was this written for an older model?), and runs the pattern scan. It produces both a findings report — file, line, the pattern, why it's obsolete for your target model, and a confidence score — and a proposed diff, without pausing for confirmation. It only applies edits if you explicitly ask it to. This is the same command referenced in explainx.ai's master prompt engineering guide as the fastest way to catch drift after a model migration.

Run it any time you migrate models — see our Claude Opus 5 migration guide — since prompting written for the source model doesn't announce itself as stale.

Calibrating effort: higher is not always better

"Effort" controls how hard Claude works before answering — low effort reaches a conclusion faster; high effort deliberates, verifies, and explores alternatives before committing. We've covered the mechanics of the effort parameter and Anthropic's own model-vs-effort framing before; this post adds the cost-performance curve data.

The benchmark curves

Both directions of miscalibration cost you:

• Assuming higher is always better. Once there's no more evidence left to find, extra deliberation just burns cost and latency without improving the answer — the Humanity's Last Exam curve above flattens hard past high.
• Defaulting to low effort everywhere. Claude stops before gathering enough evidence, makes fewer tool calls, and skips its own self-checks. The output looks finished. It's built on partial information, and that failure mode is invisible until something downstream breaks.

The counter-intuitive finding: newer model at lower effort beats older model at higher effort

On CursorBench 3.2, Fable 5.1 at low effort matches Fable 5 at high effort — for about a third of the cost. Part of that is Fable 5.1 genuinely doing less work per task at low effort; part of it is that Fable 5.1's cache-read pricing ($0.25/MTok) undercuts Fable 5's ($1.00/MTok) even before the effort difference. Even priced at Fable 5's rates, Fable 5.1 at low effort would still run about 40% cheaper. The practical implication: before building a multi-model cost cascade, test the newest model at a lower effort level first. It's one model, one cache namespace, and often the actual winner.

Fix it: measure your own curve, then /claude-api hillclimb

A flat cost-performance curve on a non-saturated eval is itself the finding — it means your task isn't thinking-compute-bound, and raising effort won't help no matter how far you push it. Don't guess; measure.

/claude-api hillclimb

hillclimb splits your evaluation into train and test sets, proposes configuration changes, and reads failing train examples to decide what to try next. Anthropic's own worked example, starting from Opus 4.8 at high effort on a customer-support benchmark:

1. First attempt — Opus 5 at low effort plus prompt-audit (removing the mandatory tool-call rituals, scratchpad steps, and contradictory rules from the prompt): cleared the Opus 4.8 baseline at 98.9% train accuracy, cost fell to 2.6¢/ticket.
2. Second attempt — stepped down further to Sonnet 5 at low effort: cost dropped to 1¢/ticket, but accuracy fell to 88.9%.
3. Iteration — after reading the failing tickets, the hillclimber added explicit routing rules and a refund-cap cross-reference to the prompt: accuracy recovered to 98.9% at the same 1¢ cost.
4. Held-out test — on 14 test tickets never seen during the search, the final config scored 90.5% versus 78.6% for the original Opus 4.8 setup, at roughly one-fifth the cost.

That's the shape worth internalizing: the win wasn't "pick a cheaper model," it was cheaper model + prompt-audit + iteration against real failures, each step measured against held-out data so the gain isn't an artifact of overfitting to the train set.

Automating the whole audit: /claude-api cost-optimize

For a full spend review rather than one specific lever, /claude-api cost-optimize profiles where your money is actually going — from the Admin API's usage/cost reports if you have Admin access, from your app's own logged response.usage objects if you're tracking those, or estimated from your request-building code if neither is available. It then ranks savings in order: prompt caching first, trimming request payload (including a prompt-audit pass), bounding output length, and batching unattended work. Give it an evaluation and it additionally computes cost/performance tradeoffs across effort levels and models.

/claude-api cost-optimize

Results on four public benchmarks (Sonnet 5 baseline)

The SWE-bench result is worth sitting with: the default configuration was already caching correctly. All 55% of the savings came from output-length discipline and a single effort-level change — reinforcing that caching is necessary but not sufficient, and that the prompting/effort levers matter even in an already-cache-optimized app. This mirrors what Uber's engineering team found running coding agents at scale: cost is a multiplicative equation across cache hit rate, effort, model choice, and output length — not a single knob.

Getting started: the three commands in one place

# After migrating to a frontier model — scan for anti-patterns first
/claude-api prompt-audit

# Full cost audit of an app calling the Claude API
/claude-api cost-optimize

# Search cost/performance tradeoffs against your own eval
/claude-api hillclimb

Run them in that order on a mature app: prompt-audit first because it's nearly free and catches outright bugs (rejected requests, silently-dropped tool calls), cost-optimize next for the full spend picture including caching, and hillclimb last once you have an eval and want to search model/effort space with confidence the result isn't just noise.

FAQ

What did Anthropic publish about reducing Claude API cost? On September 8, 2026, Anthropic's ClaudeDevs team published "Reducing cost and improving performance with Claude Platform" — see the FAQ entries above for the full breakdown, and the official post for source detail.

Does this replace model migration guidance? No — it's a complement. If you're moving to a new model generation, follow a migration guide first, then run prompt-audit to catch prompting habits the migration didn't fix on its own.

Related reading

• Prompt Caching: Decision Framework for LLM Cost, Latency, and Security — the deeper mechanics of KV-cache reuse and multi-tenant security tradeoffs
• Claude's Effort Parameter: Complete Guide to Low, Medium, High, and Max — how effort levels work end to end
• Claude Code Model vs Effort: Knowing More vs Trying Harder — Anthropic's own decision tree for when to change each
• Maximizing Claude Code Sessions: What Actually Costs You Tokens — the same cache-busting mistakes, seen from inside a Claude Code session
• How Uber Runs Coding Agents Cost-Effectively at Scale — the multiplicative cost-equation view of the same problem
• Claude Cookbooks: Complete Guide — official code recipes, including caching and structured-output patterns
• OpenRouter Model Routing for Cost Optimization — the multi-provider version of the same routing tradeoffs
• Master Prompt Engineering with Claude: Complete Guide — cache-friendly prompt structure this guide's caching section builds on

Pricing, benchmark results, and command names are accurate as of the publication date and may change as Anthropic updates Claude Platform. Verify current behavior against Anthropic's official documentation before relying on specific figures in production planning.