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.
Fable 5.2 is currently the strongest AI model in the world, but 99% of people have no idea how to use it:
- 49% have never touched it because they think it's too expensive
- 49% run every task on it and burn their quota on Haiku-level simple chores
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:
- 10 copy-paste ready practical prompts
- Anthropic's official Claude Code model ladder: Fable 5.2 → Opus 5.5 → Sonnet 5.5 → Haiku 5.5
- Configuration that runs Fable on the $20 subscription plan
- How to make Fable the 'BRAIN' (strongest brain) of a cheap model team
- A 'Mirror' prompt that can see through you and know you deeply
- How to hand tasks to it before bed and wake up to finished work
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:
- $8 per million input tokens, $40 per million output tokens (down from $10 / $50)
- Up to 30% faster than Fable 5.1
- Optional fast mode: up to 2.5x speed, priced at $16 / $80
Reference: Anthropic
https://x.com/i/status/2119867114450268322
→ 02. See what it has already done
Remote Labor Index (end-to-end evaluation on real paid remote work):
- Fable 5.2: 41.3%
- Opus 5.5: 21.3%
- GPT-6 Astra: 20.8%
- Fable 5.1: 17.9%
Its score more than doubled over the previous generation.
- Hardware design (BenchCAD 2.1): 83.5 (vs. Opus 5.5 65.3, Fable 5.1 44.4)
- Human-like computer operation (OSWorld 2.1): 89.3%
Before official release, it had already done these:
- Wrote an operating system from an empty folder: called 1,000+ subagents, took 8 days, booted on a real laptop
- Designed 3 electronic hardware devices from scratch: all three worked on the first try, zero circuit modifications
- Completed a Python → Rust service migration: service startup speed improved about 26x
- Solved 2 unsolved problems in black hole physics
"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
→ 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?
- Fable 5.2 (high effort): 45.3%
- Opus 5.5 (run at absolute limit): 45.5%
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.
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):
- Fable 5.2 · $8 / $40: The hardest, longest-running work. Planning, architecture design, root-cause debugging, large tasks that cannot be done in a single session
- Opus 5.5 · $4 / $20: Complex reasoning and actual building. Anthropic's recommended daily workhorse
- Sonnet 5.5 · $2 / $10: Daily coding, code review, verification checks
- Haiku 5.5 · $0.10 / $0.50: Simple, high-concurrency work whose results are easy to verify. Renaming, tagging, extracting file data
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
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:
- medium: discussions, planning, quick fixes
- high: tricky bugs, deep research, any task that needs to run unattended
- xhigh: only for the hardest long-running tasks where you know it pays off
- Just one hard question and don't want to change the session? Add
ultrathinkto that prompt
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:
Top three:
- "Finishing work" module: sessions that stop without finishing dropped by half (at a cost of about 30% more output tokens)
- Write exceptions directly into rules: "get approval before doing this" makes Fable execute 9 out of 10 times after approval; written as a "never" rule with a separate "approved" note, it only executes 1 in 10
- Code ownership statement: with it, Fable proactively cleans up duplicate code in about half of attempts; without it, fewer than 1 in 10
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:
"answer without deliberating": useless at medium and above. To save time, lower effort, not this.- Token budget limits in prompts: removing large limits changes nothing and lowers cost.
- Outdated "never" bans: a stale "never retry" rule cuts reasonable retry rates to about 4/10.
- Just saying "go": name the concrete approved action, e.g. "Agreed, run the migration on staging."
"double-check your work": Fable already self-checks."show your reasoning step by step": Fable may refuse entirely.- Rigid style limits like "no more than 20 words per sentence": produces choppy, broken prose.
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.
- Fable alone (high): highest score, $563 per run
- Fable as brain + Sonnet as hands: $165, 71% cheaper, slightly lower score
- Opus as brain + Sonnet as hands: roughly same score as Fable brain, $139
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
- Sonnet does every step and only consults Fable at critical moments: before finalizing a plan, when the same error repeats, before declaring "done"
- This is the combination documented in Claude Code's official docs: "get Fable guidance at critical decision points without running Fable the whole time"
- Hidden trap: the advisor only works when consulted. In Anthropic's tests, if the prompt didn't say when to consult, the advisor was consulted 0 out of 198 problems
The next team config will add a line to CLAUDE.md that tells the model when to ask the advisor.
- Extra bonus: toggling the advisor does not clear the prompt cache! Switching /model midway does. And Fable reads cached input at 1/40 the normal price.
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:
opus-builder(Opus 5.5): builds actual code from a clear briefsonnet-checker(Sonnet 5.5): independently reviews finished work, only checks, never editshaiku-worker(Haiku 5.5): handles high-volume, easy-to-verify repetitive work; never writes code/brain(Fable 5.2, high): plans, breaks down the task, writes briefs, reviews results
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):
- Assigning a team only pays off when the work exceeds a single session or splits into independent parallel modules; for single-chain sequential tasks, a single model at lower effort is cheaper
- Having Haiku write code is not better than lowering the effort of the main model, so haiku-worker never touches code
- If the hard part isn't planning, change the
fablein the brain file toopus; the score is similar and you save another 19%
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).
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.
→ 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.
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).
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:
- Run low first and rerun only failures with high: saves about 40%
- Save data as files instead of pasting tables/logs into chat: accuracy goes from 7/25 to 25/25, cost is 1/12
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.
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
code-review(official): a second pair of review eyes on every code changeanthropics/skills(192k stars): handles Word, Excel, PDF, PPT, made for non-programmersmattpocock/skills(320k stars): built-ingrill-meskill that interrogates you deeply before you build. Install:/plugin install mattpocock-skills@claude-plugins-officialobra/superpowers(315k stars): brainstorming → planning → testing → subagents, heavy for small tasks. Install:/plugin install superpowers@claude-plugins-officialwshobson/agents(42k stars): ready-made agent collection that can be mounted onto Fable. Install:/plugin marketplace add wshobson/agents
Warning: none of these plugins were written for Fable 5.2, so run Prompt Doctor after installing!
https://x.com/i/status/2054808143041908936
What it can't do
- Most cyber-security and bio-sensitive work: Fable's safety guardrails block these; Claude Code automatically falls back to Opus for the blocked request
- Accelerating AI research itself: Anthropic deliberately withheld core kernel optimization and LLM architecture design ability; here it's only Opus 5.5 level
- Cheap simple chores: using it on simple tasks is pure money burning; follow the model ladder
- Unlimited free use on the $20 Pro plan: after November 16, Pro consumes usage credits; Max and Ultra include half the weekly limit
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
- Run
claude update, then/model fableand/effort high - Paste the Start Here master prompt below, or paste the prompts from steps 06 and 10 one by one
- Run Prompt Doctor on all existing configs and plugins
- Run The Mirror and share your 3-line share card
- Give Night Shift a real task before bed
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:
- Let Haiku do the grunt volume
- Let Sonnet review and verify
- Let Opus build and implement
- Let Fable think deeply
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.
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!