Anthropic has changed how developers should prompt Claude again.
If you have been following the Claude 5 family, you probably remember the prompting changes introduced with Claude Opus 5.5. We discussed effort levels, defining completion criteria, reducing unnecessary thinking instructions, and giving Claude more specific instructions when building software.
Claude Fable 5.2 introduces another set of behavioral changes.
Some of the prompting techniques that worked well with Opus 5.5 can now produce unexpected results. An agent might stop before completing a task, ask for unnecessary approvals, delegate work too frequently, or spend more time and tokens than the task requires.
Anthropic has published a dedicated prompting guide for Fable 5.2, covering these differences.
For developers building coding agents, autonomous workflows, and AI-powered applications, there are several changes worth understanding before migrating existing prompts.
Let’s look at what changed, how to prompt Fable 5.2 effectively, and where it differs from Opus 5.5.
1. Calibrate effort instead of blindly using high reasoning
This is the first setting I would review when moving from Opus 5.5 to Fable 5.2.
Claude Opus 5.5 defaults to medium effort. Claude Fable 5.2 defaults to high.
Fable 5.2 supports five effort levels:

Anthropic recommends starting with high and testing other levels against your own evaluations.
There is an interesting detail here. Moving from medium to high improved scores across most of Anthropic's tracked coding and knowledge-work evaluations. Going above high produced smaller, less consistent gains while consuming considerably more tokens.
What developers should do
Don’t automatically use max for every coding task.
For example:
Simple code explanation → low
React component implementation → medium
API integration → high
System architecture design → high
Complex autonomous migration → xhigh
Experimental research → maxThese are starting points, not universal performance guarantees.
Also, don’t try to reduce thinking by adding instructions such as:
Don't think too much.
Answer immediately without deliberating.
Use minimal reasoning.Anthropic found that these instructions don’t reliably reduce thinking at medium and above.
Change the effort setting instead.
2. Explicitly tell Claude to finish the entire task
Imagine asking your coding agent:
Migrate this application from Next.js 14 to Next.js 16.
Update dependencies, fix breaking changes,
resolve build errors, and run the tests.The agent updates the dependencies, identifies a few remaining issues, and responds: “Two issues remain. Would you like me to continue?”
You now have to send another message to get the work finished.
Anthropic specifically identifies this early-stopping behavior in Fable 5.2, particularly at low and medium effort.
The recommendation is to establish a finishing policy in your system prompt.
Prompt pattern:
# Finishing work
Complete the work requested by the user.
Do not stop while there are actionable tasks remaining.
When you encounter ordinary obstacles such as:
- Build errors
- Test failures
- Tool timeouts
- Missing results
- Temporary service failures
Diagnose the problem and attempt a reasonable recovery.
Continue with independent tasks even when another
part of the work requires clarification.
Stop only when:
- The task is complete.
- A genuine decision requires user input.
- Access is unavailable.
- A deliberate safety or permission boundary prevents progress.
Before finishing, verify the implementation
and report any remaining blockers.Anthropic replayed recorded coding-agent sessions using a version of this instruction. About half as many sessions ended with doable work remaining.
There is a trade-off: output tokens increased by approximately 30% in that test.
Keep confirmation requirements for destructive or irreversible actions. Persistence should never become permission to modify production databases or delete files without authorization.
3. Define code ownership when asking for implementation
This is one of the more interesting changes for developers.
Suppose you ask Claude to implement a new authentication feature in an existing application.
You expect it to inspect the codebase, reuse existing utilities, remove duplication, and fix related problems.
However, Fable 5.2 can behave differently depending on how your prompt describes the codebase.
Anthropic found that when the prompt presented the codebase as someone else’s, or said nothing about ownership, the model tended to extend existing structures even when that introduced duplication.
When the prompt explicitly described the codebase as its own, it was more likely to merge repeated code and make related fixes.
Prompt pattern:
This codebase is yours: what it's for and how it's
built are your call, and you'll keep building on it.
When implementing features:
- Follow the existing architecture where appropriate.
- Consolidate duplicated implementations.
- Fix directly related bugs.
- Improve maintainability when necessary.
- Keep unrelated changes out of scope.Anthropic reported that the ownership instruction increased the rate of merging repeated code from under 10% to around 50% in its small coding-task tests.
However, there is a catch.
The same instruction increased output token usage by roughly 1.5 times. It also introduced additional changes that the user hadn’t explicitly requested, including changes to existing feature behavior.
Use ownership instructions when you want Claude to improve the codebase as it works.
Leave them out when you’re making a narrowly scoped change and want the existing implementation preserved.
4. Make approval rules specific
Developers building autonomous agents often include instructions such as:
Never perform an operation without user approval.This sounds safe, but it can create unnecessary interruptions.
For example, an agent might ask for approval before retrying a failed API request or performing an ordinary development operation.
Fable 5.2 follows approval instructions closely. The problem becomes more noticeable when multiple agents, reviewer instructions, and persistent memory rules accumulate.
Anthropic recommends naming the exact actions that require approval.
Instead of:
Always ask before taking any action.Use:
Require explicit user approval before:
- Deleting production data.
- Deploying to production.
- Sending external communications.
- Modifying production infrastructure.
- Performing irreversible operations.
The following actions do not require approval:
- Reading files.
- Running local tests.
- Retrying safe, idempotent requests.
- Fixing local build errors.
- Updating implementation code within the approved scope.There is another important detail.
When the user approves an action, make sure the approval exception is written into the rule itself.
For example:
Never deploy to production without explicit approval.
Once the user approves a specific deployment,
that approval authorizes the approved deployment.This is more reliable than scattering separate approval and exception instructions across different parts of the system.
5. Give subagents a clear purpose
If you’re building an AI coding agent, you probably already know how useful subagents can be.
One agent can inspect the frontend, another can review backend APIs, and a third can run tests.
However, spawning agents also increases token consumption and orchestration overhead.
Fable 5.2’s delegation behavior depends heavily on the task and the surrounding instructions.
Anthropic observed that Fable 5.2 can also use subagents to review its own work at higher effort levels such as xhigh and max.
For developers, this means delegation instructions deserve another review.
Prompt pattern for a subagent tool:
Use a subagent when:
- Work can be performed independently.
- Parallel execution reduces total completion time.
- A separate review provides meaningful value.
Avoid delegation when:
- The task is small.
- The work depends heavily on shared context.
- Coordination costs exceed the expected benefit.
Before starting a subagent:
1. Define its exact responsibility.
2. Provide the relevant context.
3. Specify the expected output.
4. Avoid duplicating work assigned to other agents.
Consider the additional token and execution cost
before delegating.Anthropic tested a revised subagent tool description that reduced delegation by approximately one-third on short tasks without reducing task success.
One more thing: check which model your harness uses for subagents. If every subagent runs an expensive model, your overall session cost can grow quickly.
6. Keep users informed during long-running tasks
Have you ever started an autonomous coding task and wondered whether Claude was still working?
Fable 5.2 introduces an interesting consideration for developers building the interface around Claude.
During long tool-use sequences, the model may produce very little user-facing text. Its progress updates can arrive in thinking blocks rather than ordinary text blocks.
If your application renders only text blocks, users might see what looks like a frozen agent.
Anthropic recommends configuring thinking display:
thinking.display = "updates"Or:
thinking.display = "summarized"These options allow clients to receive progress updates or summarized thinking information.
Your application must also render the relevant non-empty blocks.
If you cannot change your agent harness, Anthropic suggests adding an instruction such as:
Every few tool calls, give the user
a one-line update on where things stand.For interactive coding products, this is worth implementing.
A user watching an agent modify 20 files should have some indication of what it is doing, even when the underlying operations take time.
7. Remove accumulated caution from system prompts and memory
This is an easy problem to overlook.
Over time, AI applications accumulate instructions from:
System prompts.
Agent memory.
Project notes.
Skills and instruction files.
Reviewer agents.
Previous conversations.
Each instruction might have been introduced to prevent a particular failure.
Eventually, the agent has so many restrictions that routine operations become difficult.
For example:
Never retry a failed operation.
Always stop after an error.
Never modify existing files without approval.
Ask before making changes.Individually, these rules might make sense in certain situations. Together, they can prevent an agent from completing ordinary development work.
Fable 5.2 follows accumulated caution closely.
Anthropic recommends auditing persistent instructions and removing outdated restrictions.
A better approach is to define the scope of each restriction:
Never retry destructive operations.
Safe, idempotent API requests may be retried
after temporary failures.
Stop when an operation could cause data loss
or requires additional authorization.The difference is that the agent now understands which operations are restricted and which are permitted.
Don’t simply append another instruction saying “be more autonomous.” Fix the original restrictions that are causing the problem.
💡 Enjoying this article?
Every week day, I publish practical, production-ready deep dives covering Web development, System Design, Open source projects, Tech industry trends and AI Engineering and tools.
8. Write final reports for someone who wasn’t watching
An autonomous agent might spend 30 minutes inspecting files, changing implementations, running tests, and fixing errors.
At the end, it responds: “Completed successfully.”
That’s a poor handoff.
The person reading the result might not have seen any of the tool calls or intermediate updates.
Anthropic recommends adding a communication policy to your system prompt.
Prompt pattern:
# Communicating clearly
Write for an intelligent reader who has not seen
your tool calls, reasoning, or files.
Start with the outcome.
Explain:
- What was changed.
- Why the changes were necessary.
- Which files or components were affected.
- Which tests were executed.
- Whether the tests passed.
- Any remaining limitations or blockers.
Use clear, complete sentences.
Avoid unexplained abbreviations and internal terminology.
Keep the report concise while including enough
context for someone to understand the result.This is particularly useful for coding agents, automated code reviews, research agents, and workflow automation.
The final response should stand on its own. A developer shouldn’t have to inspect the entire agent session to understand what happened.
9. Remove outdated prompting instructions from Opus 5.5
This is probably the most important migration lesson for developers who already have production prompts.
Anthropic specifically recommends reviewing instructions written for earlier models.
Here are some worth checking:

One particularly interesting finding concerns instructions carried over from Anthropic’s Opus 5.5 prompting guide.
Those instructions encouraged Claude to treat an earlier answer as complete and focus on the latest message.
Anthropic found that, at high effort, these instructions reduced Fable 5.2’s tendency to reconsider earlier answers. Unfortunately, they also made it less likely to identify mistakes in its previous responses.
If your workflow depends on self-correction, don’t carry those instructions over without testing.
Also, Anthropic found that removing large token budgets written into prompts reduced cost in certain coding evaluations without reducing performance.
These findings are reasons to run evaluations before and after migration, rather than assuming an older system prompt remains optimal.
10. Handle refusals without asking for internal reasoning
Fable 5.2 uses safety classifiers that can decline certain requests.
When a request is declined through the API, the response can include:
response.stop_reason == "refusal"The refusal category is available through:
response.stop_details.categoryCategories include:
cyber: Requests that could enable cyber harm.bio: Requests that could enable biological harm.frontier_llm: Certain requests involving the development of competing AI models.reasoning_extraction: Requests to reproduce internal reasoning.general_harms: Other policy-related restrictions.
One thing developers should review is their existing system prompts.
If your instructions contain:
Show your complete internal chain of thought.
Explain every hidden reasoning step.
Reveal your private reasoning before answering.Remove those instructions.
When you need an explanation, ask for the decision, supporting evidence, alternatives, and trade-offs.
For example:
Explain your architectural decision.
Include:
- The selected approach.
- The main reasons for choosing it.
- Alternatives considered.
- Important trade-offs.If you need visibility into the model’s thinking, Anthropic provides thinking.display = "summarized" rather than requiring the model to reproduce its private reasoning in the response.
Claude Fable 5.2 vs Claude Opus 5.5: What’s different?
Since we already covered Opus 5.5 in the previous article, I want to highlight the differences that matter when developers migrate their existing prompts.

There are also important API differences.
Both models use adaptive thinking, and their Messages API and tool-use patterns are largely compatible.
However, when migrating from Opus 5.5:
Update the model ID to
claude-fable-5-2.Review your effort configuration because Fable 5.2 defaults to
high.Check the API’s 30-day data-retention requirement. Fable 5.2 is not available under zero data retention unless Anthropic expressly authorizes it.
Ensure your conversation history remains append-only. Fable 5.2 enforces thinking-block prefix validation for every account.
Re-evaluate token consumption, latency, and rate limits.
One important compatibility detail: Fable 5.2 can read Opus 5.5 thinking blocks on supported platforms, but Opus 5.5 cannot read Fable 5.2 thinking blocks. A fallback between these models therefore needs proper handling of thinking blocks.
My recommended migration checklist
If you’re already using Opus 5.5 in your development workflow, I would approach the migration in this order:
Set Fable 5.2 effort to
highinitially.Test
medium,high, andxhighagainst your existing evaluations.Add explicit task-completion instructions.
Review code ownership instructions.
Audit approval rules and accumulated restrictions.
Revisit subagent delegation policies.
Configure progress updates in your agent interface.
Improve final reporting instructions.
Remove outdated thinking and token-budget instructions.
Test refusals, fallbacks, latency, and token consumption.
Don’t change everything simultaneously. Migrate one behavior at a time and measure the difference.
Final thoughts
The biggest adjustment with Claude Fable 5.2 is how developers manage autonomous work.
Effort settings, task completion, code ownership, approval boundaries, and accumulated instructions have a direct influence on how your agent behaves.
If you’re using Claude through an IDE, an agent framework, or your own application, your existing prompts deserve another review.
I’d start with the system prompt and agent memory. Those are often where outdated instructions accumulate, and changing the model without reviewing them can introduce unexpected behavior.
A good AI agent needs clear ownership, an explicit definition of completion, and boundaries that make sense. Your prompting strategy should reflect all three.
Thank You for Reading!
I hope you found it helpful and informative. If you have any questions or feedback, feel free to leave a comment below. Your support and engagement mean a lot to me.
