Original Reddit post

In Claude, type this prompt: /claude-api Please read the bundled reference file shared/model-migration.md from this skill’s base directory and dump it to a new file ~/model-migration.md . Thank you! It’s a long document with Anthropic’s guidance about how to use each different model to best effect. Here’s the section for Fable.

Behavioral shifts (prompt-tunable) Claude Fable 5’s biggest gains are on work above what prior models could do (long-horizon autonomous runs, first-shot implementations of well-specified systems, end-to-end enterprise deliverables — financial analysis, spreadsheets, slides, docs — code review/debugging and repository-history search, vision on dense or degraded images — it’s explicitly trained to use bash and crop tools on flipped/blurry/noisy inputs — navigating ambiguity, parallel sub-agent delegation and collaboration — it reliably sustains ongoing communications with long-running sub-agents and peer agents; note bug-finding gains exclude security-focused analysis, where the cyber classifiers apply) — don’t evaluate it only on workloads older models already handled. Longer turns by default — the biggest structural shift. Individual requests on hard tasks can run many minutes at higher effort (a 15-minute single request is normal when the task involves gathering context, building, and self-verifying). Before migrating, plan timeouts, streaming, and user-facing progress indicators; structure work so callers check in on runs asynchronously rather than blocking inside one request. On ambiguous tasks Claude Fable 5 may need a small nudge to avoid overplanning: 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. Consider all effort levels. output_config.effort is the primary intelligence/latency/cost control. Recommended defaults: high for most tasks, xhigh for the most capability-sensitive workloads, medium / low for routine work. Lower effort settings — including low — still perform very well on Claude Fable 5, often exceeding the xhigh or even max performance of previous models. Reduce effort if a task completes correctly but takes longer than necessary, or for a quicker interactive working style. At higher effort on routine work, Claude Fable 5 can gather context and deliberate beyond what the task needs (the flip side: higher effort buys excellent verification behavior and the most rigorous outputs). To prevent unrequested tidying or refactoring at higher effort: 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. Don’t design for hypothetical future requirements - do the simplest thing that works well. Avoid premature abstraction. Avoid half-finished implementations either. Don’t add error handling, fallbacks, or validation for scenarios that cannot happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs). Don’t use feature flags or backwards-compatibility shims when you can just change the code. Instruction following is strong — use it. Claude Fable 5 is very responsive to explicit communication-style sections in system prompts; invest in them rather than fighting output style downstream. Un-steered — especially at higher effort — it can elaborate beyond what the task needs: heavily-structured PR descriptions, sections on alternatives that weren’t chosen, comments narrating what the next line does. You don’t need to enumerate these behaviors by name; a brief instruction is just as effective: Lead with the outcome. Your first sentence after finishing should answer “what happened” or “what did you find” — the thing the user would ask for if they said “just give me the TLDR.” Supporting detail and reasoning come after. Being readable and being concise are different things, and readability matters more. The way to keep output short is to be selective about what you include (drop details that don’t change what the reader would do next), not to compress the writing into fragments, abbreviations, arrow chains like A → B → fails, or jargon. Ground progress claims on long runs. Require progress claims to be audited against tool results — in testing this nearly eliminated fabricated status reports on tasks designed to elicit them: 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. State boundaries explicitly. Claude Fable 5 sometimes takes unrequested-but-adjacent actions (e.g. composing an email straight to drafts, creating backup git branches). Define what it should not do: 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. Let it delegate — asynchronously. Parallel sub-agents are dependable on Claude Fable 5 — instead of suppressing delegation (a common prior-model guardrail), use sub-agents frequently and give explicit guidance on when delegation is desirable. Sub-agents that communicate asynchronously with the orchestrator outperform spawn-and-block: long-lived agents keep their context instead of re-establishing it per subtask (cache-read savings), the orchestrator isn’t bottlenecked on the slowest sub-agent, and context persists across subtasks. Delegate independent subtasks to sub-agents and keep working while they run. Intervene if a sub-agent goes off track or is missing relevant context. Give it a memory surface. Claude Fable 5 performs notably better when it can write learnings somewhere for future reference — even a plain .md file. Tell it where, tell it to consult that file in future sessions, and give it a format: 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. Rare: early stopping. Deep into long sessions it can occasionally end a turn with a text-only statement of intent (“I’ll now run X”) without the tool call, or ask permission it doesn’t need. A “continue” recovers it interactively; for autonomous pipelines add a system reminder: 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. Rare: context anxiety. In very long sessions it can worry about running out of context — suggesting a new session or trimming its own work — most often when the harness surfaces a remaining-token countdown. Avoid showing explicit context-budget counts; if you must: You have ample context remaining. Do not stop, summarize, or suggest a new session on account of context limits – continue the work. Give the reason, not just the request. Claude Fable 5 performs better when it understands the intent behind a request — it connects the task to relevant information rather than inferring intent on its own. This matters most for long-running agents juggling context from disparate workstreams: I’m working on [the larger task] for [who it’s for]. They need [what the output enables]. With that in mind: [request]. Readability in long agentic sessions. Deep into extended conversations (many tool calls, large working context) Claude Fable 5 can produce text users find hard to follow — dense arrow-chain shorthand, implementation-level detail, references to thinking the user never saw. A communication-style addendum strongly mitigates this; adapt: Terse shorthand is fine between tool calls (that’s you thinking out loud, and brevity there is good). Your final summary is different: it’s for a reader who didn’t see any of that. If you’ve been working for a while without the user watching - overnight, across many tool calls, since they last spoke - your final message is their first look at any of it. Write it as a re-grounding, not a continuation of your working thread: the outcome first, then the one or two things you need from them, each explained as if new. The vocabulary you built up while working is yours, not theirs; leave it behind unless you re-introduce it. When you write the summary at the end, drop the working shorthand. Write complete sentences. Spell out terms instead of abbreviating them. Don’t use arrow chains, hyphen-stacked compounds, or labels you made up earlier — the reader doesn’t have the context to decode them. When you mention files, commits, flags, or other identifiers, give each one its own plain-language clause saying what it is or what changed — never pack several into one parenthesized run or slash-separated list. Open with the outcome: one sentence on what happened or what you found. Then the supporting detail. If you have to choose between short and clear, choose clear. Long-running agent recommendations Make self-verification explicit. For long-running builds, instruct it to establish and run its own checking harness on a cadence (“Establish a method for checking your own work as you build; run it every [interval], verifying against the specification with sub-agents”). Separate fresh-context verifier sub-agents tend to outperform self-critique. De-prescribe migrated prompts and skills. Prompts and skills written for prior models are often too prescriptive for Claude Fable 5 and reduce output quality. After migrating, A/B the workload with older step-by-step scaffolding removed — prefer stating the goal and constraints over enumerating the steps. Claude Fable 5 is also good at updating skills on the fly from what it learns mid-task — let it. Start at the top of your difficulty range. The teams with the best early-access outcomes gave it their hardest unsolved problems first — have it scope the problem, ask questions, then execute. Add a send_to_user tool for verbatim mid-task delivery. When an asynchronous agent must deliver something the user sees exactly as written mid-run (a deliverable, a progress update with specific numbers, a direct answer), give it a client-side tool whose input you render directly in the UI — tool inputs are never summarized, so content arrives intact. Return a simple acknowledgement as the tool result: ​ { “name”: “send_to_user”, “description”: “Display a message directly to the user. Use this for progress updates, partial results, or content the user must see exactly as written before the task finishes.”, “input_schema”: { “type”: “object”, “properties”: { “message”: { “type”: “string”, “description”: “The content to display to the user.” } }, “required”: [“message”] } } For agents that only narrate routine progress, the model’s default progress narration is typically adequate without this tool. submitted by /u/lucianw

Originally posted by u/lucianw on r/ClaudeCode