跪拜 Guibai
← Back to the summary

Fable 5.2: Make It the Brain, Not the Wallet-Burner

Fable 5.2 Complete Masterclass: These Prompts Will Fucking Change You

X blogger codila (@0xCodila) published a long post "Fable 5.2: Prompts for Most Dangerous LLM In History That Will F*cking Change You". The author is an AI researcher and software engineer. The post combines Anthropic's official Claude Fable 5.2 prompt guide with real usage data. It answers the question: how to actually use Fable 5.2 well inside Claude Code without burning through your budget and quota. It is written for people who find Fable too expensive to touch, and also for developers and heavy users who run every daily task with it and exhaust their quota quickly.

The post positions Fable 5.2 clearly: it is the 'brain' that makes decisions, not the 'hands' that do physical labor. It should be used for top-level planning, architecture design, and the hardest root-cause debugging, not for renaming files or writing routine code. Underneath it relies on Anthropic's official four-level model ladder (Fable 5.2 → Opus 5.5 → Sonnet 5.5 → Haiku 5.5) and Advisor mode. What actually changes the usage are the peripheral configuration and a set of practical prompts that control when to enable high thinking effort, how to clean up harmful instructions left over from old models, how to let cheap models do the work and ask Fable for advice, and how to hand big tasks to it overnight to run by itself.

cover image

Fable 5.2 is currently the strongest AI model in the world, but 99% of people have no idea how to use it:

If you think Fable is just 'a smarter but more expensive Opus', you're not alone. I used to think so too.

But Fable 5.2 was built to solve the hardest problems on Earth.

Used properly, it will completely change your work and life, even on the $20 subscription plan.

In this post I'll show you exactly how:

Figure 1

It takes one evening to set up. Bookmark this post now; you will keep coming back.


Part 1 · Understanding the models (skip if you know this)

→ 01. Meet the model Anthropic keeps on a leash

On November 9, Anthropic released two names: Fable 5.2 and Mythos 5.2.

They are actually the same model.

Official explanation:

"Claude Fable and Claude Mythos are the same underlying model. Fable has strict cyber-safety and bio-safety guardrails to prevent abuse, which lets us open it to all users."

Mythos is the version with these safety guardrails removed, and is only available to organizations that have passed Anthropic's cyber-safety or life-science qualification reviews.

What you get is Fable:

Reference: Anthropic

https://x.com/i/status/2119867114450268322

Figure 2

→ 02. See what it has already done

Remote Labor Index (end-to-end evaluation on real paid remote work):

Its score more than doubled over the previous generation.

Before official release, it had already done these:

"I had Claude Fable 5.2 run a 10-12 hour security audit. It dispatched about 170 review agents..." — Andrew Mager, Uber

https://x.com/i/status/2119916954337349737

Reference: Anthropic

Figure 3

→ 03. Wait... isn't it just an expensive Opus?

Honestly, sometimes yes.

Remember the 4.3x cost on research tasks. Anthropic's launch page also recommends: most daily tasks should start with Opus 5.5 ("our strongest everyday model"), and only upgrade to Fable when the task really needs it.

But look at hard task performance.

FrontierCode 2.0 tests only one thing: would maintainers of a real open-source repo merge this code?

Same score, but each task costs about half of what Opus costs.

And at xhigh effort, Fable hits 49.1%, the highest score of any released model Anthropic has tested (Anthropic).

The conclusion is clear: on simple tasks it burns your money; on the most hardcore tasks it is actually cheaper than pushing Opus to its limit.

Figure 4

The whole game is knowing which work goes to whom.

→ 04. Figure out what each Claude model is for

Claude Code's official docs assign each model a clear role. Prices are per million tokens (input / output):

Per token, Fable costs 80x more than Haiku. Every time you have Fable rename a file, you are paying 80x for nothing.

Reference: Claude Code model config · official pricing

Figure 5


Part 2 · 100% full configuration

→ 05. Turn on Fable and choose the right effort level

Update and switch:

claude update
/model fable

Fable 5.2 requires Claude Code v2.1.321 or later.

About the $20 Pro plan: before November 16, Pro includes Fable quota (up to half of the weekly limit); users who paid before the launch can reset Fable quota once for free in Settings > Usage. After November 16, Pro runs Fable against usage credits; the /model selector will show "Requires usage credits". Max and Ultra plans include half the weekly limit of Fable quota on an ongoing basis (plan details).

Next is the setting most people never touch. In Claude Code, Fable starts at medium effort by default:

/effort high

Anthropic's official guide: "Most of the capability jump is fully present at high." Above that, gains are not consistent, but the bill absolutely goes up consistently.

My practical tiering:

Figure 6

One pitfall: at medium effort, Fable is more likely to stop early. The next step solves that.

This step's result: Fable gets the right effort level for each task.

Reference: model config · Fable 5.2 prompt guide

→ 06. Paste a core CLAUDE.md

This is the heart of the whole course!

Anthropic tested single-sentence instructions on Fable 5.2 and published the exact effect of each sentence. Here they are sorted by impact:

Figure 7

Top three:

I consolidated the best parts into one file. Paste this directly into Claude Code:

Append the following configuration block to my user-level instruction file ~/.claude/CLAUDE.md. If it doesn't exist, create it; if it exists, show the diff and wait for me to confirm yes. If after merging it exceeds 200 lines, tell me which old content could move to a separate file, and leave the rest alone.

Then ask me: which projects are fully mine and can be freely refactored? Add only the sentences under "Ownership" to the project CLAUDE.md I name, again showing a diff for my approval.

===== Block to write to ~/.claude/CLAUDE.md =====
# Finishing work
As long as any part of the requested task is unfinished, avoid stopping. Keep going; do not stop unless necessary.
Short status syncs or questions on undecided decisions are welcome, but for work that doesn't depend on a user answer, push forward without unnecessary pauses.
If you find yourself about to ask the user to redirect or proposing to wait, keep executing the next part instead. When you hit common obstacles like errors, timeouts, locked files, empty results, or failed tools, diagnose first; as long as it isn't a hard dead end, use your existing permissions to solve it (retry, fix the request, switch tools or sources), and don't stop easily.
If something is explicitly set as a hard limit (like files marked do-not-touch, intentionally revoked permissions, or safety guardrails), don't force past it; state it honestly and find another safe path to finish. Except for missing user input or an intentional hard block, you should rarely stop before the task is done. High-risk or destructive operations still require confirmation first.

# Approvals
Before deleting data, force-pushing, deploying to production, incurring paid expenses, or sending/publishing anything outside this machine, get my go-ahead. Once I approve a step, execute it directly.
No approval needed for: reading files, running tests and read-only commands, creating and editing files in the current project, retrying safe repeatable commands.

# Updates
Say in one sentence what you're going to do before starting; short updates in between help me follow. At the end, finish with a self-contained short summary (what you found, what you did, what's next) so someone who only reads the last message can see the whole picture.

# Communicating clearly
Write for a smart reader who lacks the current context. The reader can't see your tool calls, internal reasoning, or opened files. Messages should be self-contained, put the key point in the first few sentences, and expand progressively; don't use concepts on line 1 that you only explain on line 12.
Use plain words and short complete sentences. No made-up jargon or abbreviations. Follow ASD-STE100 simplified technical English: short sentences, one thing per sentence, active voice, consistent wording for the same thing. Use coherent paragraphs for related ideas and lists for separate items. Cut redundant detail but keep key context.

===== Ownership (only for projects I name) =====
This codebase is yours: its purpose and construction are up to you, and you will keep iterating on it.

It adds the modules to your user-level CLAUDE.md and shows a diff first. The ownership statement is only placed in projects you say are fully yours, because it makes Fable refactor code proactively.

Keep the file under 200 lines—Anthropic docs note that overlong instruction files eat context and reduce adherence.

This step's result: Fable pushes tasks to completion, reports progress proactively, asks only when there is real risk, and writes human-readable reports.

Reference: prompt guide · CLAUDE.md docs

→ 07. Delete these old instructions from your prompts

Fable 5.2 follows old instructions more literally than any previous Claude, so many things you wrote for old models now work against you. From Anthropic's official guide, the pitfalls to avoid:

Figure 8

Btw if you use a skill pack, be careful: hot skill packs with 300k stars were written for old models. The official guide suggests checking your skills and agent files for these old phrases.

Paste this prompt into Claude Code:

<goal>
Clean up my Claude Code instruction files for Fable 5.2. Find statements written for old models that now waste money, cause side effects, or are ineffective, and fix them after my approval.
Completion criteria: ./prompt-doctor/report.md lists all findings, ./prompt-doctor/backup/ holds backups of all original files before modification, and only fixes I approved are applied.
</goal>

<where_to_look>
- ~/.claude/CLAUDE.md, plus the current project's CLAUDE.md, CLAUDE.local.md, and .claude/CLAUDE.md
- Auto memory: ~/.claude/projects/*/memory/
- Skill files: ~/.claude/skills/*/SKILL.md and .claude/skills/*/SKILL.md (including plugin-installed skills)
- Agent files: ~/.claude/agents/ and .claude/agents/
- Current project's AGENTS.md or other instruction files
</where_to_look>

<what_to_find>
Anthropic's Fable 5.2 guide lists these harmful or ineffective statements:
1. Phrases asking to "think less" or "answer without deliberating" (ineffective at medium and above). Fix: delete, and lower effort instead.
2. Token or length budgets in prompts. Fix: delete.
3. "Never" rules whose reason is stale, especially "never retry" or "stop on error". Fix: delete, or rewrite with scope and reason.
4. Absolute rules without exceptions. Fix: write the exception into the rule itself ("get approval before doing X").
5. Instructions that default to pushing work to subagents (Fable already delegates proactively). Fix: delete, or limit to large independent tasks.
6. Reminders to verify, test, or double-check (Fable self-checks). Fix: delete.
7. Requests to show step-by-step reasoning in the answer (Fable may refuse). Fix: delete.
8. Rigid style or word-count limits (like "no more than 20 words per sentence"). Fix: delete or soften.
9. Statements that treat a previous answer as final (this stops Fable from pointing out its own errors). Fix: delete unless I explicitly need it.
10. Treating a lone "go" or "continue" as an approval rule. Fix: specify the concrete action.
11. Instruction files over 200 lines. Fix: propose splitting into separate files.
Also list any conflicting rules.
</what_to_find>

<rules>
- You may freely read and list files. Before any edit, back up the original file with its path to ./prompt-doctor/backup/.
- Any modification outside ./prompt-doctor/ requires my yes. Show diffs grouped by file, and only apply changes I approve.
- Keep genuinely cautious rules that protect production data, money, or other people's safety; when unsure, mark them "keep, you decide".
- Never write passwords, keys, or tokens into the report; always write [hidden].
</rules>

<report>
For each finding, list: file, line number, original phrase, matching number, cost caused, and proposed fix. End with a count: lines proposed for deletion, lines for rewrite, lines to keep.
</report>

First list all files you found and their line counts.

It scans your CLAUDE.md, memory, skills, and agents, backs up original files, and shows diffs. It never changes anything without your approval.

This step's result: the same Fable, but with fewer pointless follow-up questions and a smaller bill.

Reference: prompt guide


Part 3 · Making Fable the brain (the best configuration globally)

→ 08. Make Fable the brain, not the hands

This part will change the way you pay for AI.

Anthropic's launch page gives Fable two roles that almost nobody uses:

"Fable 5.2 can also act as an Advisor (where Haiku, Sonnet, or Opus consult it when stuck) or an Orchestrator (delegating simple tasks to smaller models)."

"It's like an incident commander who can send out faster models to gather quick signals and keep the big picture." — Matt Lee, Datadog

Anthropic ran a real test on a giant task that couldn't fit in one session: find a human-planted bug in a 22-million-token codebase.

Figure 9

Thinking is Fable's job; typing is not.

Reference: launch page · cost optimization guide

→ 09. Daily default: Sonnet works, Fable advises

The cheapest way to use the Fable brain all day:

/model sonnet
/advisor fable

Figure 10

The next team config will add a line to CLAUDE.md that tells the model when to ask the advisor.

Every professional developer and AI enthusiast should use this golden combination.

Reference: Advisor docs

https://x.com/i/status/2042308622181339453

→ 10. Build a 'four-model team' for large tasks

For large tasks that can't fit in one session, give Fable a team:

Paste this prompt into Claude Code once (it will create three subagents, a /brain skill running on Fable 5.2, and add advisor rules at the end of CLAUDE.md):

Configure a user-level Fable 5.2 team in Claude Code so it works across all projects.

1. Create the four files below. The content between each pair of ===== markers (starting at the first line of ---) is the exact file content.
2. If a target path already has a file, show old and new versions and ask my consent before replacing.
3. Add the Advisor rule below to the end of ~/.claude/CLAUDE.md (create if missing; show a diff and wait for yes if it exists).
4. When done, list the created files. If ~/.claude/agents/ or ~/.claude/skills/ didn't exist when the session started, remind me to restart Claude Code once.

===== ~/.claude/agents/opus-builder.md =====
---
name: opus-builder
description: Builds from a clear brief. Writes and changes code and files. Use for implementation work after the plan is decided.
model: opus
effort: medium
---
Follow the brief exactly and build in the specified files. Don't change anything outside scope.
If the brief is unclear or you hit a failure you can't fix, stop immediately and report the blocker; don't guess.
At the end, include a short report: what changed per file, how you verified, and what's unfinished.

===== ~/.claude/agents/sonnet-checker.md =====
---
name: sonnet-checker
description: Independently checks finished work against its brief. Runs tests and reads the code, and changes nothing. Use before any work is called done.
model: sonnet
effort: high
tools: Read, Grep, Glob, Bash
---
You didn't write this code and you won't modify it. Check it independently against the brief: run tests and code, read diffs, verify core scenarios.
Report only real issues (with file name, line number, or command and actual behavior). If everything passes, say so in one sentence and list what you checked.

===== ~/.claude/agents/haiku-worker.md =====
---
name: haiku-worker
description: Repetitive work across many items whose results are easy to check, such as renaming, extracting fields, tagging, sorting, and short summaries of many files. Not for writing or fixing code.
model: haiku
effort: medium
---
Execute each item strictly in the format the brief requires. Don't skip anything. If an item doesn't match the instruction, list it under "Unclear" instead of guessing.

===== ~/.claude/skills/brain/SKILL.md =====
---
name: brain
description: Runs a big job with Fable 5.2 as the brain and Opus, Sonnet and Haiku subagents as the hands. Use only when I type /brain.
argument-hint: "[the job and what done means]"
model: fable
effort: high
disable-model-invocation: true
---
You are the Brain for this task. You plan, break down, write briefs, and review results. Your team:
- opus-builder (Opus 5.5): builds code from a clear brief
- sonnet-checker (Sonnet 5.5): independently checks against the brief, only checks, never edits
- haiku-worker (Haiku 5.5): repetitive, easy-to-check grunt work across many items, never writes code

Subagents can't see this conversation and every token they read costs money, so delegate only when it's worth it:
- Only delegate modules that are independent, work too big for a single session, or repetitive tasks that are easy to verify.
- Single-chain sequential steps or work that fits in this session you do yourself. Planning, architecture, root-cause debugging, and final decisions stay with you.
- When you brief a subagent, assume it knows nothing: state the goal, exact files, completion criteria, red lines, and report format (short report with evidence, not full text).
- Never let two subagents edit the same file at the same time.
- If opus-builder fails twice on the same module, raise it to high effort and try once more; if it still fails, do it yourself.
- Before declaring done, sonnet-checker must do a full check against the overall goal and fix any issues found.

Require my yes before: deleting data, force-pushing, modifying things outside the project.
No approval needed: reading files, running tests, creating/editing files in the project, starting subagents, retrying failed commands.

Give a short plan first (module breakdown, assignments, order), then keep going until done, with a one-line progress update every few steps.

Current task: $ARGUMENTS

===== Append to ~/.claude/CLAUDE.md =====
## Advisor
When an advisor model is configured, consult it before finalizing a plan, when the same error appears again, and before declaring a task done. Save your work before the last consultation.

After configuring, hand it a big task:

/brain Migrate the API from Python to Rust. Completion criteria: all tests pass and the service starts.

Fable writes the plan, distributes work, and has Sonnet verify before declaring done. Type /tasks to see which model each assistant ran on. If a task needs multiple rounds of interaction, start a session with claude --model fable.

Two rules from Anthropic's real tests (already in the config):

This step's result: one command can coordinate four models, each doing its job.

Reference: Subagents docs · Skills docs


Part 4 · Prompts that completely change you

→ 11. Let Fable tell you who you actually are (The Mirror analysis)

Every prompt you type in Claude Code stays on your disk: ~/.claude/history.jsonl saves all prompts, ~/.claude/projects/ saves full sessions. Claude Code deletes them silently after 30 days by default (settings docs).

Figure 12

Nobody writes daily sessions for show, so they record what you actually did, not what you say you did.

Initialize and start:

mkdir mirror && cd mirror
claude
/model fable
/effort high

Paste the following (it reads local history, auto-redacts secrets, does not send data anywhere, asks 5 questions, and produces a personal profile, token breakdown, 30-day plan, and a 3-line share card):

<goal>
Read my history of working with AI on this machine, use evidence to show who I am and where my time goes, and help me adjust my configuration so agents fit the real me.
Completion criteria: ./mirror/ contains inventory.md, evidence.md, mirror.md, plan-30-days.md, changes.md, and share-card.md, and I've answered your interview questions.
</goal>

<sources>
- ~/.claude/history.jsonl: every prompt I typed, with time and project path
- ~/.claude/projects/<project>/<session>.jsonl: full session records (subagents are in <session>/subagents/)
- ~/.claude/projects/<project>/memory/: auto memory notes
- ~/.claude/settings.json: check cleanupPeriodDays (default 30 days), tell me how far back the records actually reach
- Other AI session dirs (like ~/.codex/sessions/ and any *.jsonl under ~/.config or ~/.local/share)
</sources>

<rules>
- Privacy: never write passwords, keys, tokens, emails, or other people's names into chat or files; always write [hidden]. Never send data to any website, API, or tool outside this session.
- Extract signal: use small read-only scripts (Python or jq) to extract only my messages, timestamps, project, model, effort, and token counts. Print only statistics and short excerpts, not tool results or full text.
- Evidence: every claim must be backed by a dated quote as evidence. A pattern requires 3 or more occurrences; if evidence is insufficient, write "insufficient data".
- Before starting, warn me in one sentence that the read text will be processed by the model provider like any normal conversation.
- If records are large, you may split the extraction among up to 4 subagents in parallel to pull dated short quotes and counts; if fewer than 20 sessions, say so and lower confidence.
- This is not a psychological diagnosis: only describe patterns, and I define meaning. If my responses show clear emotional distress, pause and say so honestly.
</rules>

<approvals>
Require my yes before: 1. reading message text after showing the inventory list and mining plan; 2. modifying any existing file outside ./mirror/ (show diff, apply only approved changes).
No approval needed: listing folders, counting files, running read-only scripts that output only numbers, reading/writing inside ./mirror/, retrying failed commands.
</approvals>

<phases>
1. Inventory: find all data sources (tools, paths, file counts, sizes, start and end dates, retention settings), save as inventory.md, show it with the mining plan, and wait for my yes.
2. Evidence: in evidence.md, list short quotes, dates, and counts by category (no subjective interpretation yet): things I come back to repeatedly; things I started and abandoned (disappear after 3+ occurrences); places where I often correct the AI (what I care about); things I repeatedly do by hand that should be automated; hours when I'm at my best vs. stuck (by hour and weekday); token allocation (by model and effort, and what types of tasks run on the most expensive models); what's missing from the record.
3. Interview: form 5 strongest hypotheses silently, ask 1 guiding question at a time and wait for an answer. If my answer contradicts the record, show the evidence and ask again, then record the result in evidence.md.
4. Mirror: tell me, based on evidence, what I truly value (by where time goes), where my thinking is fast and where it loops, what I'm good at, what I avoid (and what the avoidance protects), and one pattern that's on nearly every page but never said. Save the most painful point for last and say it once. If I push back, use evidence; if my evidence is better, revise your view. Save as mirror.md, readable on its own six months later.
5. Leverage: create plan-30-days.md from evidence, with a first action this week for each item: STOP (what to cut and its historical cost); HAND OFF (things permanently handed to agents, sorted by hours saved per week); KEEP (what's already working); ONLY ME (one or two things that best use my strengths); SCHEDULE (deep work and chores); MODELS (which task types should use Fable/Opus/Sonnet/Haiku and what the official prices save).
6. Setup: in changes.md, propose diffs for CLAUDE.md or AGENTS.md, up to 3 new skills that would eliminate frequent manual requests (~/.claude/skills/<name>/SKILL.md), and a suggestion to raise cleanupPeriodDays. Apply only items I approve.
7. Share card: write a share-card.md (3 public short lines) with no names, projects, companies, locations, amounts, or secrets: the most painful true sentence about how I work, one thing I decided to stop, and one thing I decided to hand to agents.
</phases>

<working_style>
Keep going between approval checkpoints. Diagnose and solve errors or empty directories. Start with a one-line statement and update every few steps. Use plain short sentences, lead with conclusion, be direct, no flattery (criterion: "In 4 months you asked for a 'quick landing page' 9 times with zero launches. What would launching actually cost you?")
</working_style>

Start with phase 1.

If you don't use Claude Code, upload your notes or ChatGPT/Claude exports to the regular web app and paste this lighter Mirror Lite:

<goal>
Read my uploaded notes, diary, or AI chat record attachments. Use evidence to show me who I am, where my time and attention go, and give me a 30-day plan.
</goal>

<rules>
- My own words are evidence: every claim must include a short quote and a date; three instances count as a pattern, otherwise write "insufficient data".
- Never repeat passwords, card numbers, addresses, or other people's names; write [hidden].
- Not a psychological diagnosis; only describe patterns. If the text shows clear emotional distress, pause and say so honestly.
- Be direct, don't flatter.
</rules>

<steps>
1. Evidence: list short quotes and counts under these headings: things I keep bringing up; things I started and abandoned; things I complain about but never change; moments that sound most alive; and what should be there but isn't.
2. Interview: form 5 strongest guesses silently, ask 1 guiding question at a time and wait for an answer. If my answer contradicts my words, show the quote and ask again.
3. Mirror: tell me what I truly value, what I'm good at, what I avoid (and what it protects), and one pattern that's everywhere but never said. The most painful point goes last and is said once.
4. Plan: list STOP (stop), HAND OFF (things handed to AI each week), KEEP (keep), ONLY ME (core strengths), each with a first action this week.
5. Share card: write 3 lines with no names, locations, amounts, or secrets: the most painful true sentence about me, one thing I'll stop, and one thing I'll hand to AI.
</steps>

Start with step 1.

This step's result: a personal profile worth rereading in six months, a 30-day plan, and a 3-line share card with the most uncomfortable truth.

Figure 13

→ 12. Build a "second brain" with Karpathy's design

https://x.com/i/status/2039805659525644595

Andrej Karpathy published a GitHub Gist called "idea file" meant to be pasted into an agent: let the agent organize everything you've read into a linked Wiki knowledge base, so each new piece of material makes it smarter. Long sessions across many files are exactly Fable's home turf.

Initialize a directory and put 3–10 raw docs (articles, PDFs, notes, transcripts) into raw/:

mkdir second-brain && cd second-brain
mkdir raw
claude
/model fable

Then paste:

Read Andrej Karpathy's LLM Wiki approach (https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) and build a knowledge base Wiki with me in the current directory.

<setup>
- raw/ holds raw material; never modify it, only reference it.
- wiki/ holds pages you write and maintain. Maintain index.md (one-line summary per page) and log.md (append-only; one entry for each import, query, or cleanup).
- Write the rules into ./CLAUDE.md so future sessions follow them.
</setup>

<first_job>
Digest all files under raw/. For each file, first explain the 3 most important points to me, write a summary page, then update the pages for people, concepts, and comparisons involved, and mark where new and old material disagree.
Completion criteria: every file in raw/ has a summary page, index.md and log.md are updated, and you ask me 5 synthesis questions that no single source can answer but the current Wiki can.
</first_job>

<working_style>
Creating and editing files in the current directory needs no approval; only ask me for subjective judgments (what matters most to me, how to view disputed claims). Start with a one-line statement and post a progress line after every few files.
</working_style>

This step's result: drop any new file into raw/ and your personal Wiki updates automatically.

Reference: Karpathy's Gist

→ 13. Move an entire army with one word

Two built-in commands most people never type:

ultracode: move every test file under tests/ from Jest to Vitest
/deep-research What changed in the Node.js permission model between v20 and v22?

ultracode makes Claude write a workflow automatically: spawn many agents in the background in parallel, then aggregate into a report. /deep-research does broader search, cross-checks sources, and drops weak claims.

Figure 15

https://x.com/i/status/2060042710753382816

Fair warning: one run burns far more tokens than a normal conversation. The official docs recommend trying it on small slices first.

Reference: Workflows docs

→ 14. Find out where your money goes (Bill Autopsy)

Anthropic found that total bills are often driven by very few tasks: in one test, 2 out of 20 questions ate 43% of the cost (cost guide).

Figure 16

Paste this prompt into Claude Code:

<goal>
Show me where my Claude Code tokens go, and help me adjust config to spend less for the same results.
Completion criteria: ./bill-autopsy/report.md and ./bill-autopsy/share-card.md exist, and I've approved each proposed change.
</goal>

<data>
1. Run npx ccusage@latest daily and npx ccusage@latest session; save output to ./bill-autopsy/.
2. Write a small read-only script to read ~/.claude/projects/*/*.jsonl, extracting for each session: date, project directory, model, effort, input/output/cache token counts, and the first 15 words of my first message.
3. Get prices from https://platform.claude.com/docs/en/about-claude/pricing (if unavailable, report only token counts).
</data>

<analysis>
- Total cost by model, project, week.
- What share of total cost the most expensive 10% of sessions account for, and what those tasks were.
- How much simple tasks running on Fable or Opus (renames, small edits, formatting, queries) could save if moved to Sonnet or Haiku.
- Cache hit rate, and sessions where switching models or effort invalidated the cache.
- Sessions where big tables or long logs were pasted directly into chat instead of being provided as files.
</analysis>

<fixes>
Sorted by savings, with log evidence:
- Effort: run normal tasks on low first, rerun only failures on high (Anthropic measured about 40% savings with similar pass rates).
- Store data as files: hand tables and logs to Claude as files and have it write code to process (measured accuracy from 7/25 to 25/25, cost only 1/12).
- Model assignment: assign each task type to Haiku, Sonnet, Opus, or Fable.
- Advisor mode: if Fable spends most of its time on concrete execution, suggest /model sonnet with /advisor fable.
Show diffs for settings or CLAUDE.md changes and apply only approved items.
</fixes>

<rules>
Read-only scripts and file reads/writes inside ./bill-autopsy/ need no approval. Never copy message bodies except the first 15-word excerpt. Passwords, keys, and tokens are always written [hidden].
</rules>

Finally write a share-card.md with no project names (3 public lines): most expensive model's token share, the single biggest waste, and one change I decided to make.

It runs ccusage on your local logs, identifies tasks using the wrong model, and sets up the two most cost-effective moves Anthropic measured:

On a monthly subscription, this saves your precious weekly quota cap.

This step's result: a ledger showing exactly where every token went, plus a plan to save money starting tomorrow.

→ 15. Hand it tasks before bed (Night Shift)

Start with:

claude --model fable --permission-mode auto
/effort high

While you're still awake, paste:

I'm going to sleep in 15 minutes. Tonight you run the task independently. Let's prepare together first:

1. Ask me everything you need confirmed in one single message now: exact task, completion criteria, red lines, verification method.
2. Write NIGHT-SHIFT.md: global goal, subtask checklist, precise verification for each item (test commands, build, or file existence), and red lines not to cross.
3. Create a new Git branch for tonight's work. Commit after each completed subtask.
4. If the task splits into independent modules and opus-builder, sonnet-checker, haiku-worker exist, distribute to them and have sonnet-checker verify each item; otherwise do it yourself.
5. Tonight's bans: deploy to production, push to main branch, delete anything outside the project, incur any paid cost. If something is blocked waiting on my decision, note it and move to the next item.
6. When all checks pass, write MORNING-REPORT.md with three headings: Done (with proof), Blocked on me, Found along the way.

When NIGHT-SHIFT.md is ready, print a /goal command for me to paste, in this format:
/goal Every item in NIGHT-SHIFT.md is checked off with its proof shown, and MORNING-REPORT.md exists, or stop after 40 turns

It asks all its questions in one message while you're awake, writes the plan, then gives you a single /goal command to paste. /goal uses a separate model to check after each turn whether the task is actually done; auto mode has a second model review operation safety for you. All code stays on a separate branch; it never deploys on its own.

This step's result: wake up to a three-section morning report: Done, Blocked on me, Found along the way.

Figure 17

https://x.com/i/status/2063792263067754658

Reference: /goal docs · Auto permission mode


Free curated plugin stack (The Free Stack)

Install at most 2-3, then run Prompt Doctor once. Prefer official plugins:

/plugin install code-review@claude-plugins-official
/plugin marketplace add anthropics/skills
/plugin install document-skills@anthropic-agent-skills

Warning: none of these plugins were written for Fable 5.2, so run Prompt Doctor after installing!

Figure 18

https://x.com/i/status/2054808143041908936


What it can't do

Figure 19

Reference: launch page · model config

But there are some very impressive early experiments:

https://x.com/i/status/2120174844822298730


Your "one-night setup" action list

  1. Run claude update, then /model fable and /effort high
  2. Paste the Start Here master prompt below, or paste the prompts from steps 06 and 10 one by one
  3. Run Prompt Doctor on all existing configs and plugins
  4. Run The Mirror and share your 3-line share card
  5. Give Night Shift a real task before bed

Figure 20


The ultimate prompt: Start Here

Paste this once and it replaces the manual config from Part 2 and 3. It asks 3 questions, waits for one 'yes', then installs only the config that fits you. Below it, there's also a great course by Lance Martin on how to build everything in this post:

Do the following steps in order to make my Claude Code get 100% out of Fable 5.2:

STEP 1. Ask me these 3 questions in one message and wait for answers:
1. What do you mainly use Claude for: coding, research and writing, or running a business?
2. Do you handle large tasks that run for hours or cannot fit in one session? (yes / no)
3. Which projects on this machine are fully yours and can be freely refactored? (folder names, or "none")

STEP 2. Before changing anything, list all files you will create or modify, and wait for my yes. (This one yes covers all later steps; still show diffs as you execute each step.)

STEP 3. If ~/.claude/CLAUDE.md exists, back it up to ~/.claude/CLAUDE.md.backup, then append the core CLAUDE.md modules from section "06" above to the end. If it exceeds 200 lines, suggest old lines that can be split into separate files.

STEP 4. Add only the Ownership statement from "06" to the project CLAUDE.md files I named in question 3.

STEP 5. Only if question 2 was yes: create the four team files (opus-builder, sonnet-checker, haiku-worker, brain) at the exact paths from section "10", and add the Advisor rule to the end of ~/.claude/CLAUDE.md.

STEP 6. Scan my existing CLAUDE.md, memory notes, skills, and agent files. Find statements that harm Fable 5.2 (think less, token budgets, stale never rules, reminders to self-check, asking for reasoning steps, rigid word limits, default delegation to subagents). Only list file names and line numbers, and hand them to Prompt Doctor to handle.

STEP 7. Give a short summary report: what changed, what STEP 6 found, and, based on my answers, recommend the 3 prompts from this course I should run next (The Mirror, Bill Autopsy, Night Shift, Second Brain, Prompt Doctor).

https://x.com/i/status/2119069896327700956


The Shift

Before, Fable meant "that expensive model" → now it means the strongest brain directing cheap hands.

Real alpha isn't in benchmark leaderboards; it's in knowing which task deserves it:

Most people will keep paying the $40/M output price just to ask "are you ready?"

The few who spend one night setting up this system will drive a full four-model team for less than running Fable alone.

Figure 21

Hope this helps. Bookmark this course before starting your next project.


That's all for today. If you liked this post, remember to like and follow!