Deep Dive · XiaoHu Explains

Claude Fable 5's Official Prompting Guide: A Dozen Copy-Paste Fixes, From Overplanning to Fake Progress Reports

Anthropic's official doc teaches you how to tune system prompts and engineering scaffolding for the new model — the same methods apply to Claude Mythos 5
60-Second Overview
  • Anthropic released an official prompt-engineering guide for Claude Fable 5 and Claude Mythos 5, listing this generation's behavioral differences from Claude Opus 4.8 and how to adjust your prompts and engineering scaffolding accordingly
  • The guide gives a dozen-plus instruction snippets you can paste straight into your system prompt — for curbing overplanning, blocking unsolicited refactors, trimming verbose output, and drawing the line on when the model should actually stop and ask
  • One audit-style instruction requires the model to verify its progress claims against this session's actual tool-call results before reporting. Anthropic says this nearly eliminated fabricated status reports on tasks specifically designed to elicit them
  • The guide recommends adding a send_to_user tool for long-horizon async agents, so content that must reach the user verbatim skips summarization entirely
  • A warning: if your prompt asks the model to restate its internal reasoning inside the reply text, it may trigger Fable 5's reasoning_extraction refusal category, causing the request to auto-downgrade to Claude Opus 4.8
⚑A note on stance: this is Anthropic's own official product documentation, written to help you get the most out of their new model. The capability claims in it — and conclusions like "nearly eliminated" or "correct on the first try" — come from the vendor's internal testing and early-tester feedback, unverified by any third party. What follows is a faithful retelling of the document's content and its copy-paste instructions, nothing more.
1Background · What It Is

What Problem This Doc Solves

Anthropic recently released an official prompt-engineering guide for Claude Fable 5 and Claude Mythos 5, summarizing how this generation's behavior differs from Claude Opus 4.8, and what to change in your prompts and engineering scaffolding as a result.

In plain terms, this is a tuning manual: the new model is more capable, but a few default behaviors have changed, and reusing your old prompts and old engineering frameworks as-is will trip you up. The doc pairs every behavior change with an instruction snippet you can paste straight into your system prompt.

🎯Why it's worth reading: it doesn't just talk technique in generalities — it hands you a dozen-plus ready-to-use instruction snippets, one of which (the audit-style instruction) nearly wiped out fabricated status reports on internal test tasks specifically designed to induce the model to make things up. You don't have to trial-and-error your way to these settings yourself.
lowmedhighxhigh
First, pick the right effort tier
→
✓✓✓✓
Then get it to run the long haul — minutes to hours — verifying evidence before every progress report. Those two things are the spine of this whole guide

Where it beats the previous generation (quick pass)

The doc lists seven improvements over Claude Opus 4.8. Quick one-liners each, no deep dive:

  • Long-horizon autonomy: works unsupervised for hours to days without losing the thread of what it originally set out to do
  • Correct on the first try: systems that used to take days of iteration reportedly came out right in a single pass for early testers (per tester accounts)
  • Visual understanding: reads dense technical diagrams, web apps, and detailed screenshots more accurately, with more token-efficient output; uses bash and cropping tools to handle rotated, blurry, or noisy images
  • Enterprise workflows: sticks to instructions better and produces more professional output on financial analysis, spreadsheets, slides, and documents, with less drift
  • Code review and debugging: notably higher bug-recall than Opus 4.8 (except in cybersecurity), and can search across codebases and history
  • Ambiguity handling: can take a messy, multi-threaded complex request and figure out the next step on its own
  • Subagent collaboration: dispatches parallel subagents more readily, and holds up better in sustained async communication with long-running subagents and peer agents

It also runs safety classifiers that block three categories of requests: offensive cybersecurity (building exploits, malware, attack tools), biology and life sciences (experimental methods, molecular mechanisms), and extracting the model's internal summarized reasoning. Legitimate adjacent work can get caught by mistake too. You can configure a server-side or client-side fallback so refused requests automatically fall back to Claude Opus 4.8.

2Fixing Overplanning

Fixing Overplanning: One Line to Make It Act Once It Has Enough

Whenever a task gets ambiguous or effort is set high, Fable 5 tends to overthink: re-deriving facts already established in the conversation, listing options it was never going to take anyway, dragging out the preamble. The instruction below tells it to act as soon as it has enough information.

Without the instruction
  • Re-states known facts, re-litigates decisions already made in the conversation
  • Lists a bunch of options it was never going to pursue
  • Long-winded root-cause explanations, way more preamble than conclusion
With "act once you have enough"
  • Acts as soon as it has enough information
  • Gives one recommendation for a trade-off, not an exhaustive list
  • Leads with the conclusion, keeps reasoning in the thinking block
Stops it from overplanning, re-stating known facts, or narrating options it won't pursue
When you have enough information to act, act. Do not re-derive facts already established in the conversation, re-litigate a decision the user has already made, or narrate options you will not pursue in user-facing messages. If you are weighing a choice, give a recommendation, not an exhaustive survey. This does not apply to thinking blocks.

A related engineering-side note that pairs with this section: long-horizon autonomy means the model can work unsupervised for a long stretch — hours or even days without losing the thread. The trade-off is that a single request runs longer: at higher effort, on tasks that require gathering context and self-verification, one request may take dozens of minutes, and autonomous runs may stretch to hours. Before migrating, tune your client-side timeouts, streaming display, and user-facing progress indicators accordingly — ideally switch your engineering framework to periodic async polling of task status instead of blocking and waiting for a hard return.