With Claude Fable 5, the way of prompting changes again. The latest from Anthropic, already very autonomous, requires a simpler and more elegant prompting structure.
As is often the case, a new family of models means a new way of prompting. Equipped with unprecedented agentic abilities and trained to reason with an autonomy almost never before achieved, Claude Fable 5 reshuffles the cards. Anthropic calls for completely reviewing the way it prompts AI and adapting your existing prompts accordingly.
Good use of Claude Fable 5
Before presenting the main changes in the prompting approach, we still need to know when and how to properly use this new model. With a cost of 10 dollars per million tokens for entry and 50 dollars for exit, reasonable use is essential. Claude Fable 5 should be used primarily for complex and long tasks. Develop a new application from scratch, migrate code, generate in-depth analyzes from a wealth of information… Fable 5 is designed to work on the longest possible tasks, which would normally take a human days or even weeks.
For simple and relatively quick tasks, the use of Claude Fable 5 is not justified. Claude Opus 4.8 or Claude Sonnet 4.7 will be more than sufficient. The AI is capable of working in complete autonomy for several hours, without any human giving it instructions. By default, she understands which tools to use, when, and how to check her own productions. Before any migration, Anthropic recommends adjusting timeouts and adding progress indicators. AI’s thinking times are such that early adopters have often been limited by their own running management.
Clear and sober prompts
Claude Fable 5 arrives with even more advanced follow-up of instructions (prompt adherence). To prevent the model from reasoning beyond reason, favor short and clear instructions. Don’t guide the model through a complex problem, just provide it with the minimal context needed. With prompts that are too long or too detailed, the model will tend to be verbose and think longer without much interest, especially at high effort. Cutting out the unnecessary is the key to prompt optimization with Fable 5.
Alignment problem or bug in training, Claude Fable 5 has, according to Anthropic’s technical report, a tendency in certain situations to lie, and in particular about his current progress. His greater willingness to respond to requests and his lower resistance under pressure therefore make him a slightly more difficult model to evaluate on paper. To limit this bias (quite rare according to Anthropic), the editor recommends adding the following instructions to your prompt system (or CLAUDE.md):
Before reporting progress, audit each claim against a tool result from this session. Only report work you can point to evidence for; if something is not yet verified, say so explicitly. Report outcomes faithfully: if tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging.
Limit the model in its capabilities
This is quite counterintuitive advice, but a real game-changer. Anthropic recommends explicitly limiting Claude Fable 5 with instructions. Its agentic capabilities are such that it can adopt unpredictable behaviors: send an email without being asked, create a new git branch, etc. It is therefore better to define in black and white, in your prompt system, what the model is authorized to do and what it is prohibited from doing.
Example :
When the user is describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment. Report your findings and stop. Don't apply a fix until they ask for one. Before running a command that changes system state (restarts, deletes, config edits), check that the evidence actually supports that specific action. A signal that pattern-matches to a known failure may have a different cause.
Claude Fable 5 will also use many sub-agents on its own, natively. Sometimes, it tends to delegate to too many sub-agents, which can slow down the entire process (the model then having to wait for a response from a sub-agent before carrying out the next task). To avoid this natural bias, the Anthropic teams recommend clearly indicating to the model how it should behave. Tell it to continue working while the subagents rotate and to intervene if a subagent deviates or lacks context.
Example instructions:
Delegate independent subtasks to subagents and keep working while they run. Intervene if a subagent goes off track or is missing relevant context.
A persistent memory
Claude Fable 5 works best when it has a history of previous sessions. He learns from it and does not repeat the same mistakes. In agentic configuration (notably with a Claude Code type harness), Anthropic recommends giving the model an MD file which it can use to log its lessons and update it continuously.
Example of instructions to add in the prompt system:
Store one lesson per file with a one-line summary at the top. Record corrections and confirmed approaches alike, including why they mattered. Don't save what the repo or chat history already records; update an existing note rather than creating a duplicate; delete notes that turn out to be wrong. Il faut également lui indiquer de bien prendre en compte les leçons apprises avant de se lancer dans une nouvelle tâche : Reflect on the previous sessions we've had together. Use subagents to identify core themes and lessons, and store them in (X). Make sure you know to reference (X) for future use.
Minimal reasoning, justification of decisions…
Anthropic also offers several more discreet tips, the impact of which may seem counterintuitive but which changes daily practice. First point often underestimated: the level of reasoning does not need to be pushed to the maximum by default, because Fable 5 in minimal mode already exceeds the performance of Claude Opus 4.8 in maximum mode. Then, getting into the habit of contextualizing one’s requests, that is, explaining why something is asked and not just what, allows the model to link the task to the real intention rather than inferring it alone.
Furthermore, it is worth explicitly asking Fable 5, in the system prompt, to remain concise between tool calls: the model naturally tends towards a verbose and jargonous style in its intermediate explanations, which considerably burdens the monitoring of long runs (and consumption). Finally, to maximize the autonomy of the model over runs lasting several hours, Anthropic recommends explicitly specifying in the system prompt that the agent operates without real-time supervision.
Example of instructions to add:
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. For
reversible actions that follow from the original request, proceed without asking.
Offering follow-ups after the task is done is fine; asking permission after already
discussing with the user before doing the work is not. Before ending your turn, check
your last paragraph. If it is a plan, an analysis, a question, a list of next steps, or
a promise about work you have not done ("I'll…", "let me know when…"), do that work now
with tool calls. End your turn only when the task is complete or you are blocked on
input only the user can provide.
The ideal prompt system
From these recommendations, we have created two examples: a ready-to-use prompt system for generic agentic use with Claude Fable 5, and a minimal CLAUDE.md to get the most out of the model for your code production.
Prompt system for a universal agentic harness:
You are operating as an autonomous agent. 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. For reversible actions that follow from the original request, proceed without asking. Pause for the user only when the work genuinely requires them: a destructive or irreversible action, a real scope change, or input that only they can provide. If you hit one of these, ask and end the turn rather than ending on a promise. End your turn only when the task is complete or you are blocked on input only the user can provide. 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. If you are weighing a choice, give a recommendation, not an exhaustive survey. Stay in scope. Don't add features, refactor, or introduce abstractions beyond what the task requires. Do the simplest thing that works well: no premature abstraction, no error handling for scenarios that cannot happen, no backwards-compatibility shims when you can just change the code. Trust internal code and framework guarantees; validate only at system boundaries (user input, external APIs). When the user is describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment: report your findings and stop. Before reporting progress, audit each claim against a tool result from this session. Only report work you can point to evidence for; if something is not yet verified, say so. If tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging. Delegate independent subtasks to subagents and keep working while they run. Intervene if a subagent goes off track or is missing relevant context. For long-running tasks, establish a method for checking your own work as you build, and verify against the specification with fresh-context subagents at a regular interval. Terse shorthand is fine while you work between tool calls. Your final message is different: it's for a reader who didn't see any of that. Open with the outcome (one sentence on what happened or what you found), then the supporting detail, then the one or two things you need from them. Drop the working shorthand: complete sentences, no arrow chains, no invented labels, spell out terms, and give each file, commit, or flag its own plain-language clause. If you have to choose between short and clear, choose clear. You have ample context remaining. Do not stop, summarize, or suggest a new session on account of context limits. Continue the work.
Instructions for a minimal CLAUDE.md:
# Working agreement
## Scope
When you have enough information to act, act. Don't re-derive established facts or
re-litigate decisions already made. Don't add features, refactor, or introduce
abstractions beyond what the task requires: a bug fix doesn't need surrounding cleanup,
and a one-shot operation usually doesn't need a helper. No premature abstraction, no
error handling for impossible scenarios, no compatibility shims when you can just change
the code. Trust internal code and framework guarantees; validate only at system
boundaries.
When I'm describing a problem or asking a question rather than requesting a change, the
deliverable is your assessment. Report findings and stop; don't apply a fix until I ask.
## Verification
Before reporting that something works, point to evidence: a passing test, a command's
output, a tool result from this session. If tests fail, show the output. If you skipped a
step, say so. State verified work plainly without hedging.
## Checkpoints
Pause only for a destructive or irreversible action, a real scope change, or input only I
can provide. Otherwise proceed. Before ending a turn, check your last paragraph: if it's
a plan, a question, or a promise ("I'll…"), do that work now instead.
## Communication
Lead with the outcome: your first sentence should answer "what happened" or "what did you
find." Supporting detail comes after. Be selective about what you include rather than
compressing into fragments, abbreviations, or arrow chains. Readability matters more than
brevity.
## Memory
Record lessons in `./notes/`, one per file with a one-line summary at the top. Log both
corrections and confirmed approaches, and why they mattered. Don't duplicate what the repo
or git history already records; update an existing note rather than creating a duplicate;
delete notes that turn out to be wrong. Reference this folder before starting new work.
The most important thing, according to Anthropic, remains to migrate all the prompts and skills inherited from Claude Opus 4.8 or earlier models. The most effective method involves two steps: first entrust Fable 5 itself with the rewriting of your prompts, so that it adapts them to its own way of reasoning, then take the result by hand, refining it according to the advice detailed above. The work can be long, but it governs everything else: it is at this price that the model really deploys its intelligence and that your tokens will work best.
