Prompt Caching and Modular Prompt Layout

1.Reuse starts with a stable prefix

Many prompts share most of their text across calls: the same system instructions, the same examples, the same reference material, with only the user's question changing at the end. Prompt caching lets the API skip reprocessing that shared part. When a request arrives with caching enabled, the system checks whether the prompt prefix up to a cache breakpoint is already cached from a recent query. If it is, the cached version is used, which cuts both processing time and cost. If it isn't, the full prompt is processed and the prefix is written to the cache once the response begins, ready for the next call.

The documentation lists where this pays off most: prompts with many examples, large amounts of context or background information, repetitive tasks with consistent instructions, and long multi-turn conversations. In each case a large block stays the same while a small part varies. Caching is available on every active Claude model, so the deciding question is how much of your prompt is genuinely stable, not which model you use.

Sources1

2.Automatic caching and explicit breakpoints

You can turn caching on in two ways. With automatic caching, you add one cache_control field at the top level of the request. The system puts the breakpoint on the last cacheable block and moves it forward as the conversation grows. On each turn, everything up to the previous turn is read from cache and only the new turn is written. You never edit markers by hand, which is why automatic caching suits multi-turn chat. With explicit breakpoints, you put cache_control on individual content blocks, so you decide exactly where a cached segment ends.

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
     ? ={"type": "ephemeral"},
    system="You are a helpful assistant that remembers our conversation.",

The two approaches can be combined. A common pattern is to put an explicit breakpoint on the system prompt, which is the reusable module, and let automatic caching follow the growing conversation. Two rules come with this. First, a request has 4 breakpoint slots, and the automatic breakpoint takes one of them. Second, if the last block already carries an explicit cache_control with the same TTL, automatic caching adds nothing. Pricing, minimum token thresholds, ordering requirements and the 20-block lookback window are identical for both approaches, because they run on the same infrastructure.

{
  "model": "claude-opus-5-5",
  "max_tokens": 1024,
  "cache_control": { "type": "ephemeral" },
  "system": [
    {
      "type": "text",
      "text": "You are a helpful assistant.",
      "cache_control": { "type": "ephemeral" }
    }
  ],
  "messages": [{ "role": "user", "content": "What are the key terms?" }]
}

Sources1

3.TTLs and what caching costs

By default a cache entry lives for 5 minutes, and every hit refreshes it at no extra cost. That lifetime starts when the request begins, not when its response ends, so a long generation eats into the window before your follow-up can arrive. If requests come in less often, you can set a 1-hour TTL with "ttl": "1h". Writes at that TTL cost 2x the base input price.

{ "cache_control": { "type": "ephemeral", "ttl": "1h" } }

Cache writes cost more than base input and cache hits cost much less, so caching saves money only when a prefix is read more often than it is written. The discount on reads also varies by model. Most models charge 0.1x base input for a hit, but Claude Opus 5.5 charges 0.05x, and Claude Fable 5.1 and Claude Mythos 5.1 charge 0.025x.

Sources1

4.Modular prompts: stable modules first, variables last

These sources do not describe a dedicated prompt-template syntax. They treat a modular prompt as a matter of structure: split the prompt into self-contained blocks that stay the same across calls, and keep them separate from the content that changes. Anthropic's customer-support guide works this way. It defines each body of product knowledge once as a named constant wrapped in a <static_context> tag, then repeats the pattern for each product line, and assembles the prompt from those modules.

STATIC_CAR_INSURANCE = """
<static_context>
Car Insurance Coverage:
Acme's car insurance policies typically cover:
1. Liability coverage: Pays for bodily injury and property damage you cause to others.
2. Collision coverage: Pays for damage to your car in an accident.
3. Comprehensive coverage: Pays for damage to your car from non-collision incidents.
4. Medical payments coverage: Pays for medical expenses after an accident.
5. Uninsured/underinsured motorist coverage: Protects you if you're hit by a driver with insufficient insurance.

Optional coverages include:
- Rental car reimbursement
- Roadside assistance
- New car replacement
</static_context>
"""

Caching determines where those modules should go. The cache follows a fixed prefix hierarchy, tools → system → messages, and a change at any level invalidates that level and everything after it. Put the most stable modules (tool definitions, then system instructions and static context) at the front, and let per-request content come last in messages. That way the variable part changes on every call without disturbing the cached prefix. Some request settings can also break the cache even when your text is unchanged.

Sources23

Exam traps

Each one states something that sounds right. Open it to see what is actually true.

1. 1.The 5-minute cache TTL starts counting when the response finishes.Why is that wrong?

   The lifetime runs from the start of the request that wrote or read the entry, so time spent streaming a long response uses up the window.

   Covered in TTLs and what caching costs

2. 2.Cache hits always cost 10% of base input on every model.Why is that wrong?

   0.1x is the standard multiplier, but Opus 5.5 hits cost 0.05x, and Fable 5.1 and Mythos 5.1 hits cost 0.025x.

   Covered in TTLs and what caching costs

3. 3.Top-level automatic caching is free, on top of the four explicit breakpoints.Why is that wrong?

   When it is combined with explicit breakpoints, the automatic breakpoint takes one of the 4 available slots.

   Covered in Automatic caching and explicit breakpoints

4. 4.Editing a tool definition only invalidates the tools part of the cache; the cached system prompt and messages survive.Why is that wrong?

   Tools sit first in the prefix hierarchy, so modifying them invalidates the entire cache.

   Covered in Modular prompts: stable modules first, variables last