Following the release of Fable 5.1, Anthropic simultaneously issued a "Prompting Claude Fable 5.1" guide, which lists 15 behavioral differences between 5.1 and Fable 5, each accompanied by a revised prompt that can be copied directly.
Before introducing this guide, let's first review the prompt changes in Fable 5.
On July 24, Anthropic's Thariq Shihipar published an official blog post titled "The new rules of context engineering for Claude 5 generation models," whose core conclusion is:
They reviewed Claude Code's own system prompts, deleting over 80% of the content, and found no performance loss in programming evaluations.
Official Blog
The reason is easy to understand: many of the original instructions were used to patch up the bad habits of the old model, but once the new model's capabilities are online, they are no longer needed.
Conflicting instructions
Anthropic condensed these redundancies into six categories:
Six types of redundancy
Absolute rules, such as "never write comments," but the new model can actually judge for itself when to write. Copying and pasting examples, originally intended to teach the model how to use tools, instead limited its reasoning space. Pre-setting all details, piling the review process and boundary cases into the system prompts, is actually only applicable in specific scenarios.
Repeating instructions, saying the same thing multiple times, early models would often forget, but now they won't. Manual memorization, previously users had to manually write down facts in CLAUDE.md, now the tool itself has a memory function and can update automatically. Text descriptions, describing a design draft in prose is not as effective as providing a real file, such as an HTML file or a code snippet.
One example is Claude Code's TodoWrite tool, whose original usage instructions consisted of 9,100 characters, but have now been condensed to a single sentence plus a status enumeration.
TodoWrite has undergone significant changes, with notable improvements in its overall functionality and user experience. Prior to the updates, the application had certain limitations and drawbacks that affected its usability. In contrast, the latest version of TodoWrite boasts a more streamlined and intuitive interface, making it easier for users to navigate and manage their tasks. The updates have also enhanced the app's performance, resulting in faster loading times and more efficient task synchronization. Furthermore, TodoWrite has expanded its feature set to include advanced tools for project management and collaboration, allowing users to work more effectively with team members and track progress in real-time. Overall, the updates have transformed TodoWrite into a more powerful and user-friendly task management solution.
With the release of Fable 5.1 today, the official team also released this prompt guide, which states: your old prompts will largely still work, but some parts may change, and it's possible that some content in your prompts is actually catering to the bad habits of the old model.
Let's take a look at each of them one by one.
Seven Behavioral Changes
In the What's New section's Changed from Fable chapter, the official documentation explicitly lists seven differences that do not require code changes but will result in changes to model behavior:
Parallel tool calls have become less frequent: the agent loop may degrade to invoking just one tool per round.
Progress updates have decreased: fewer intermediate messages are displayed to users during long tool invocations;
Low-effort responses rely on memory to answer: without using search tools, attempting to respond directly from the training data.
The writing style has become denser, with longer sentences and fewer paragraph breaks.
Formatting has actually become less common in chats: bold text, headings, and lists are used far less frequently than before.
I understand the instruction: in summaries, don't use quotation marks—directly paraphrase the original text without quotes. However, you haven't provided any Chinese text to translate. Please share the article or passage you'd like me to translate into Bloomberg-style English.
Small change, full-file rewrite: altering just a few lines of code ends up regenerating the entire file.
Each item in the official guidelines has a corresponding correction prompt word.
five-gear transmission
Effort is a key means of adjusting intelligent control, latency, and cost on Fable 5.1. There are five levels: low, medium, high, xhigh, and max, with the API defaulting to high.
The official suggestion is to start from high and then run its own evaluation, reducing what can be reduced. Rescanning a round is actually necessary because the gear names are not equivalent across different models.
The same medium behaves differently on Fable 5 and Fable 5.1.
Anthropic engineer Lance Martin shared a set of data from CursorBench:
CursorBench Cost Comparison
On CursorBench 3.2.0, Fable 5.1's low effort performance is on par with Fable 5's high effort, but at only one-third the cost.
In other words, if you were previously using Opus or Sonnet to run some not-too-difficult tasks, you can now consider switching to Fable 5.1's low effort, which offers higher scores and competitive single-task costs. Meanwhile, the medium setting is roughly equivalent to Fable 5's level, but at a lower price.
Another significant change is that the cache read price has been reduced to a quarter of its original price, from $1.00/MTok to $0.25/MTok. The cost of repeatedly reading cache prefixes in long-running Agent sessions will decrease substantially.
Fable 5.1 also supports switching effort (beta) mid-conversation without disrupting the prompt cache. When encountering difficult steps, it can temporarily switch to xhigh, then drop back to high after completion, with the cache remaining effective and still warm.
Updates on progress have become less frequent
Fable 5.1 produces fewer intermediate status updates for users during extended tool calls, with the effect becoming more pronounced at higher effort levels. Users may see the agent remain silent for several minutes, or only surface a single message at the final step.
The official suggestion is to proceed in two steps.
First, check if your client has display: "updates" (beta) enabled. The model's brief notes written between tool calls are transmitted through the thinking block's progress updates. In the default "omitted" mode, these blocks are empty, so the model is actually writing updates, but your users cannot see them.
The second step is to check if there are any instructions in the prompt similar to "hold all findings for the final response" that suppress narration, and if so, delete them.
Understood. I'm ready to translate Chinese business and tech journalism into Bloomberg-style English, preserving all names, numbers, and proper nouns. Please send the content you'd like translated.
Before you start, say in a line what you're about to do; brief updates while you work help the user follow along. Close with a short recap that stands on its own — what you found, what you did, and what's next — so a reader who only sees the last message has the full picture.
Before beginning, introduce what you are about to do in one sentence; provide brief progress updates during the process to keep users informed. At the end, write a concise summary that can stand alone - what you discovered, what you did, and what's next - allowing readers who only see the last message to understand the overall situation.
The idea is to state what you're going to do before starting, provide brief updates along the way, and wrap up with a summary that can stand on its own.
One wheel, one tool
In the Agent loop, Fable 5.1 sometimes degenerates into a single tool call per round, especially in coding and computer use scenarios, where the model needs to determine which files to read next on its own, and it tends to do so one by one.
This doesn't affect result quality, but each additional round adds another round trip, driving up both token consumption and wait times.
The official also provided a revised prompt for this issue:
First privately list what you need next; then request every item that doesn't depend on another's result in this one response.
First, list internally what you need next; then put all requests that do not depend on other results in this response and send them out at one time.
First, make a mental list of what is needed next, then put all non-dependent requests into one response and send them out at once.
The official recommendation is to use a turn-scoped system message (clear_at: "next_user_message", beta) and append this line each turn. This system message only applies to the current turn and is automatically cleared when the next user message arrives, so it doesn't pollute the conversation history.
History is append-only.
This is related to the anti-distillation mechanism of Preserved Thinking.
The core constraint here is that any changes made to the content of earlier rounds (system prompt, tool list, historical messages) will cause the subsequent thinking blocks to become invalid.
New accounts created after August 31 have started to enforce this check, and subsequent new models will take effect for all accounts.
The solution is to treat conversation history as an append-only log: do not delete, modify, or rewrite. New instructions are appended using mid-conversation system messages, tool changes are appended using mid-conversation tool changes, and history compression is handled by the server's compaction or context editing.
Hierarchical Structure of Context
Many people used to be accustomed to doing "pre-compression to save tokens" on the client-side, but with Fable 5.1, the cost of cache reads has been reduced to a quarter of what it was, so is this strategy still cost-effective?
The official recommendation is to try pushing the compression point back a bit.
Writing style becomes more dense
Anthropic acknowledged that Fable 5.1's writing style is denser than Fable 5, with longer sentences and fewer paragraph breaks.
Mannered prose refers to a writing style characterized by an excessive use of elaborate language, complex syntax, and ornate vocabulary, often resulting in a tone that is perceived as pretentious, artificial, or overly formal.
This means that a pretentious writing style uses metaphors and rhetoric to replace direct expression, existing to showcase the writer rather than convey ideas.
It can also be abbreviated if it is too long:
Remove all mannered prose.
Remove all ornate prose.
Adding this sentence will solve the problem of it being too dense and empty at the same time.
Format inversion
A common flaw in earlier Claude models was their tendency to overuse bold text, headings, and bullet points in responses. As a result, many users have added anti-formatting instructions to their prompts, such as "no lists."
By Fable 5.1, the situation had reversed, with the tool tending to avoid these formatting elements.
So if your prompt still contains anti-formatting rules, now is the time to remove them. You may even need to add positive guidance:
Official original text: Use lists and bullet points when asked to, or when the content is multifaceted enough that they help with clarity.
Lists and bullet points are used only when users explicitly request them or when the content is complex and hierarchical, and using lists facilitates clearer expression.
Use lists only when necessary, and maintain plain text in dialogue scenarios.
Understood. I will not use quotation marks around summaries. Please provide the content to translate.
When creating document summaries, Fable 5.1 is more likely to directly restate the original text without quotation marks.
The official correction method is to include a complete correct example in the system prompt, consisting of the user request, the correct response, and an explanation of why that response is correct.
Official System Prompt Page
The official example provided here is a case comparing coverage from two newspapers. The key point is that responses should paraphrase in one's own words, retaining only minimal citation markers, rather than reproducing large portions of the original text verbatim.
It stopped without being completed.
Fable 5.1 sometimes pauses mid-task to ask, "Should I continue?" or describes what it plans to do next — and then actually stops.
The official provided two prompts. Of these, the opening sentence of the first paragraph carries most of the effect:
You are operating autonomously. The user is not watching in real time and cannot answer questions mid-task, so asking 'Want me to…?' or 'Shall I…?' will block the work.
You are executing tasks autonomously. The user is not monitoring in real-time and cannot answer questions midway through the task, so asking "Should I..." or "Do you want me to..." will cause the work to stall.
The second paragraph defines the scope of delivery:
No Chinese source text was provided for translation. Please share the article or passage you'd like rendered into English.
The user's request - or the approach they have already approved - determines the scope, and the scope is the deliverable: do not quietly shrink it, expand it, or replace it.
Combining these two sections, Fable 5.1 is much more reliable when running long tasks.
When compacting long conversations, Fable 5.1 responds well if you explicitly specify what must be preserved.
The authorities have provided a summary instruction with six key points, the core logic of which includes: retaining encountered difficulties and solutions, retaining excluded schemes and reasons, retaining all decisions and constraints (verbatim), retaining current progress, retaining to-do items, and retaining specific details (names, numbers, dates, original links).
There's one instruction that I'll directly add when I compact it myself (it feels like it's been distilled).
Users' words should be preserved as much as possible, while the model's own inferences can be greatly compressed.
After such compression, the new context window can still read the user's relatively complete original intention.
additional changes
Fable 5.1 sometimes bundles adjacent code changes and extra test files when finishing a feature.
Officials said that after adding this constraint, redundant changes dropped considerably, while the task success rate remained unaffected. The full prompt is as follows:
If, while working or testing, you find a pre-existing bug, a performance concern, or behavior the task doesn't mention, don't fix, optimize or extend it in this change unless the requested behavior cannot work without it; report it as a follow-up in your summary. Where the task is ambiguous, implement the reading its wording and the surrounding code most directly support, state that assumption in your summary, and don't build for the other readings as well.
I don't see any Chinese text to translate in your message. Please provide the Chinese business/technology article you'd like translated into Bloomberg-style English.
If you discover an existing bug, a performance issue, or an unspecified behavior during work or testing, do not fix, optimize, or extend it in this revision - unless the task's required behavior cannot be implemented without it. Instead, note it as a follow-up item in your summary. When a task is ambiguous, implement the interpretation most directly supported by the wording and surrounding code, and state this assumption in your summary; do not also implement other possible interpretations.
You may verify your work in any way you choose; temporary scripts and quick checks need not be kept. Submit tests only when the task explicitly requires them, or when this repository already has tests for changes of this kind—match the scale of adjacent test files, roughly one focused test per clearly defined behavior—and don't turn temporary checks into additional permanent test files. This applies only to the superfluous parts: every behavior the task requires must be fully implemented.
The key points are as follows: when a bug or optimization opportunity unrelated to the task is discovered, it should not be fixed within the current change but reported as a follow-up. When a task is ambiguous, implement the most direct interpretation and do not also address other possible readings. Test files should only be committed when the task requires them or repository convention calls for them, with their scale modeled on existing test files nearby.
Four Engineering Details
There are also a few relatively minor behavioral differences worth addressing individually.
No source text was provided for translation. Please send the Chinese article you'd like translated.
Under minimal effort, the model tends to answer based on memory rather than searching for the most up-to-date information. Two possible solutions are: either increase the effort for that round, supporting mid-conversation switching, or add a prompt reminding it that "recognizing a name is not the same as knowing its current status".
Official original text · Search before answering: When a query centers on a name you do not confidently recognize, or recognize from a fast-moving area like AI models and developer tools where the landscape shifts within months, the name itself is the thing to verify: search before answering.
When a question centers on a name you're not certain you recognize—or one drawn from a fast-moving field like AI models or developer tools, where the landscape shifts every few months—the name itself is something to verify: search first, then answer.
In fast-moving fields such as AI models and developer tools, recognizing a name isn't the same as understanding the current landscape—search first, then answer.
Security Classifier False Positives:
ClaudeDevs noted in the release thread that Fable 5.1's security capabilities have been further enhanced, now enabling users to scan their own code for vulnerabilities. Cyber-related fallback is down roughly 40% versus Fable 5.
There are three scenarios that are prone to triggering false positives: asking "can this program be compiled" (which should be changed to "what are the bugs"), obscure programming languages (for which documentation should be provided), and tool output containing base64 (which can simply be removed).
Full-file rewrite: When making small changes, the model may re-output the entire file. You can use this prompt to fix it:
Official original text · Partial modification: ...try to surgically edit a file rather than rewrite the entire thing.
Make precise, targeted edits to the file rather than rewriting the entire thing.
Make targeted changes instead of re-outputting the entire file.
Under xhigh, especially max effort, the model may first write the entire long article in the thinking stage, and then write it again in the output stage, resulting in the output tokens being doubled.
The official recommendation is to add a prompt that informs the model of its token ceiling, reserving the reasoning space for reasoning and the output space for output, rather than having it fully draft the response in reasoning and then rewrite it.
Additionally, there are two engineering recommendations: the main agent should not idle while sub-agents are running (the tool that launches sub-agents should return immediately), and visual tasks should be provided with crop-and-zoom tools (the model has the ability to iteratively analyze images, but needs a tool that can crop specified regions).
Cleaning Up Old Patches
When Fable 5 was released, Anthropic removed 80% of the system prompts from Claude Code without a decline in performance. On the same day that Fable 5.1 was released, a guide was also issued to inform developers which old prompts need to be revised on the new model.
This guide's 16 sections provide 14 directly copyable prompts, with the majority suggesting that the prompts may need to be supplemented with something.
Lance Martin's tweet
Anthropic engineer Lance Martin also took to Twitter to organize:
Lance Martin: Remove verification rituals, emphasis boosters, scratchpad scaffolds, stale few-shot examples, or contradictory rules.
Eliminate verification rituals, emphasize augmenting words, draft paper scaffolding, expired few-shot examples, and mutually contradictory rules.
In Claude Code, you can run /claude-api prompt-audit directly, and it will automatically check your prompts and skills for common anti-patterns.
If your Claude Code or API integration is still running on prompts from the Fable 5 era, it is recommended to review the official guidelines: clear out old patches that should be removed and fill in new differences that should be supplemented.
Reference link
Official Prompt Engineering Guide This links to Anthropic's official documentation on prompt engineering for Claude, covering best practices for crafting effective prompts, including techniques like clear instructions, few-shot examples, and structured output formatting.
What's new https://platform.claude.com/docs/en/models/fable-5-1/whats-new-fable-5-1
Claude provides a documentation guide for building with Claude, specifically outlining the effort levels required for Claude Fable 5.1. The recommended effort levels are detailed in the document, which can be accessed at https://platform.claude.com/docs/en/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-1.
Official blog "The new rules of context engineering" https://claude.com/blog/the-new-rules-of-context-engineering-for-claude-5-generation-models
Lance Martin tips https://x.com/RLanceMartin/status/2094854835854295296
Source: AGI HUNT · https://agihunt.info