chase_ai

Anthropic's 10 New Rules for Prompting Claude Fable 5.2

Anthropic changed the rules with Claude Fable 5.2 — effort levels, sub-agents, and what you can prompt it to do. Here are the 10 prompting changes that actually matter.

By Chase Hannegan9 min read

Want to learn Claude Code?See the Claude Code Masterclass

On this page

If you're prompting Claude Fable 5.2 the same way you prompted Fable 5.1 or Opus 5.5, you're leaving most of its power on the table — and probably burning money doing it. Anthropic changed the rules with this model: how effort levels work, how it handles sub-agents, what it will and won't let you prompt it to do. I went through the system card and tested the changes, and here are the 10 prompting rule changes that actually matter so you can get the most out of one of the most powerful coding models available.

What Changed With Claude Fable 5.2?

Fable 5.2 is a new, extremely capable model, and the old habits that worked on Opus 5.5 and Fable 5.1 don't carry over cleanly. It follows instructions almost to the letter, it always thinks, and it spawns its own sub-agents when it decides it needs them. That combination means your old prompts and config files can actively hurt its output instead of helping.

The short version: give it room, tell it to verify its own work, and strip out the strict rules you wrote for weaker models. Here's the full breakdown.

Rule 1 — Run Fable 5.2 on High Effort

Start on high effort, not medium. Fable 5.2 defaults to high in the API, but inside the Claude Code desktop app it defaults to medium — and medium leaves real performance on the table.

High is where you get the most bang for your buck. Going from medium to high is the single biggest jump in performance per dollar. On the Frontier Code 2.0 agentic coding benchmark, high scores 45.3% at $6.72 per run. That beats Opus 5.5 on extra high and essentially matches Opus 5.5 on max — except Opus 5.5 on max costs $12.82. You're getting Opus 5.5 max-level results at roughly half the price.

Medium, by contrast, drops you to 37.6%. Yes, it's cheaper at $2.48, but if a task is hard enough to reach for Fable 5.2 at all, you want the power.

My rule of thumb:

  • Start on high for almost everything.
  • Push to extra high if high isn't cutting it on a technically brutal or long-horizon task.
  • Avoid max. Across multiple benchmarks you pay a ton more for performance that's sometimes below extra high.

If a problem is small enough that medium or low would do, you probably should've just used Opus.

Rule 2 — Tell It to Prove Its Work

Fable 5.2 hallucinates more than Fable 5.1 or Opus 5.5, so you have to make it verify. This model will state inference as fact and make claims the code doesn't actually support. At lower effort settings it also runs fewer tests than previous models did.

The system card backs this up. When a needed file was missing, Fable 5.2 made up a fake file to stand in for it about 2% of the time instead of admitting it couldn't find it. In those kinds of situations, it took shortcuts roughly six times more often than you'd want.

The fix is simple: add a line to your prompt telling it to run tests on its output and confirm the result before it reports back to you. Make it prove the thing it says it did actually works. Do that and the hallucination problem mostly disappears.

Rule 3 — Tell It to Finish the Job

On long agentic tasks, Fable 5.2 is more likely than 5.1 to stop before it reaches the finish line. This shows up most on low and medium settings and gets less severe as you climb the effort chain — but it's still worth guarding against even on high or extra high.

The system card gives a prompt for exactly this. Adding an explicit "finish the job, don't stop until it's complete" instruction cuts the premature-stop behavior roughly in half. One line in your prompt, half as many abandoned tasks.

Rule 4 — Audit Your Old CLAUDE.md and Rules Files

This is the most important rule on the list: your existing CLAUDE.md files and instructions were not written for Fable 5.2, and they're probably hurting it.

You've heard people like Boris at Anthropic say to delete your CLAUDE.md files or even your skills. That same idea applies here. Fable 5.2 is a fundamentally different model from Opus 5.5 or Fable 5.1, and — as you'll see in the later rules — it follows whatever rules you give it almost to a tee. So if you're feeding it stale, overly strict, or unnecessary instructions, you're hampering it.

What to cut:

  • Strict guidelines you don't genuinely need.
  • Rigid style rules that box the model in.
  • Anything overly prescriptive. These newer models are powerful enough that they need space to breathe and do what they were designed to do. Over-constrain them and you ruin the output.

Go back through your config files and be ruthless. If a rule isn't earning its place, delete it.

Rule 5 — You Can't Prompt It Not to Think

Fable 5.2 always thinks. You cannot prompt the thinking away. With Fable 5.1, if you said "just give me the answer, don't deliberate," it would bypass some of the under-the-hood reasoning and hand you a fast, cheap response. That trick is dead.

Fable 5.2 will always think. How much it thinks is a function of your effort level — throw it on low or medium if you want it to think less and cost less — but you will always pay for some thinking tokens no matter how you prompt it. Plan your token budget around that reality instead of fighting it.

Rule 6 — Don't Ask It to Explain Its Step-by-Step Reasoning

There's a classifier watching for distillation, and asking for detailed step-by-step reasoning can trip it. If you prompt Fable 5.2 to walk you through its exact step-by-step thinking, it may assume you're trying to distill the model and shut the request down.

You can still ask why it reached an answer and get the logic behind it in a short explanation. The line gets crossed when you push for a full, explicit "explain your complete step-by-step reasoning" dump — that's what gets flagged as a possible distillation attack. It's a murky boundary, so keep reasoning requests high-level and short rather than demanding the full chain of thought.

Rule 7 — Tell It Who Owns the Code

Fable 5.2 behaves very differently depending on whether it thinks it owns the codebase. This one's a lever most people don't know exists.

If you don't tell it that it owns the code, you'll see a lot of repeated, duplicated code. If you do tell it "you're in charge of all of this," you get much less repetition — but it also adds extra features, extra tests, and spends more output tokens in exchange for a leaner, more optimized result. The system card digs into this difference in detail.

So choose deliberately:

  • Building something or handing over a codebase? Explicitly tell it that it owns the code.
  • Want minimal, surgical changes? Don't give it ownership. Instead, be very specific about exactly what you want it to do and nothing more.

Rule 8 — Stop Micromanaging Sub-Agents

Fable 5.2 spawns its own sub-agents when it needs them, so delete your old sub-agent rules. This ties straight back to Rule 4. If your CLAUDE.md or rules files contain instructions about delegating to sub-agents, pull them out before you start running Fable 5.2.

The model is smart enough to delegate on its own. At higher effort levels like extra high and max, it'll spin up its own sub-agents to check its work — almost a miniature version of an Ultra Code-style multi-agent review. But if you've written rules like "always use sub-agents for X, Y, and Z and always check your work," it will follow them to the letter and you'll tear through your usage and your resets. Let it decide when to delegate. It already understands when it needs to.

Rule 9 — Ask for Updates on Long Tool Calls

On big multi-step tasks, Fable 5.2 can go silent and just grind in the background — so tell it to check in if that makes you nervous. If you've ever watched a model work for 40 minutes with zero updates, you know the feeling.

The fix is a one-line prompt asking it to give you progress updates. Just know there's a cost-benefit dial here: if you tell it to speak after every single tool call, you can increase token usage by around 20%, which is a lot. There's a middle ground — ask for periodic updates on long tasks rather than a report after every call.

Rule 10 — Tone and Length Are Prompt-Controlled, Not Effort-Controlled

Effort level does not change Fable 5.2's tone or response length — only your prompt does. Whether you run it on low or max, you get the same voice and the same output length by default.

If you expected low effort to mean shorter, snappier answers, that's not how this model works. Tone and length have to be set explicitly in your prompt, and if you want a specific style every time, put it in a CLAUDE.md, an AGENTS.md, or a rules file. Don't rely on the effort dial to do it for you.

Should You Be Excited About Fable 5.2?

Yes. It's an extremely powerful model, and Anthropic threw a bunch of usage resets our way with the launch — which softens the blow of still being capped at roughly 50% of the usage a lot of us want. That cap is still a bummer, and hopefully it goes away eventually, but the raw capability here is worth adjusting your prompting habits for.

The theme across all 10 rules is the same: this model is powerful and obedient, so give it room, make it verify, and stop feeding it rules written for weaker models.

Frequently Asked Questions

What effort level should I use for Claude Fable 5.2?

Start on high. It's the default in the API but defaults to medium in the Claude Code desktop app, and high gives you the biggest performance-per-dollar jump — matching Opus 5.5 on max at roughly half the cost. Push to extra high for very hard or long-running tasks, and avoid max since it often costs far more for performance below extra high.

Why does Fable 5.2 hallucinate more than older models?

Fable 5.2 is more willing to state inference as fact and make claims the code doesn't support, and it runs fewer tests at lower effort. The system card found it invented a fake file to replace a missing one about 2% of the time and took shortcuts around six times more often. Prompt it to run tests and prove its output before reporting back.

Do I need to update my CLAUDE.md files for Fable 5.2?

Yes. Fable 5.2 follows instructions almost literally, so old, strict, or overly prescriptive rules written for Opus 5.5 or Fable 5.1 can actively hurt its output. Audit your CLAUDE.md and rules files and delete anything you don't genuinely need, especially rigid style rules and sub-agent instructions.

Can I tell Fable 5.2 not to think to save tokens?

No. Unlike Fable 5.1, Fable 5.2 always thinks and you can't prompt the thinking away. You can only control how much it thinks through the effort level — lower effort means less thinking and lower cost, but you'll always pay some thinking-token cost.

How do I stop Fable 5.2 from spawning too many sub-agents?

Remove sub-agent rules from your config files. Fable 5.2 decides on its own when to delegate, and at extra high and max it spins up sub-agents to check its own work. If you hard-code rules forcing it to always use sub-agents, it'll follow them literally and burn through your usage and resets.


If you want to go deeper into getting the most out of Claude Code and models like Fable 5.2, join the free Chase AI community for templates, prompts, and live breakdowns. And if you're serious about building with AI, check out the paid community, Chase AI+, for hands-on guidance on how to make money with AI.

Topicsclaude-fable-5-2claude-codeai-promptinganthropicai-coding

Chase Hannegan

I teach people to build real things with AI, on YouTube and inside Chase AI+.