Make Fable 5 rebuild your Claude Code setup before it goes

The problem

The highest-leverage thing to do with a temporarily available top model is not another one-off task. It is a meta-task: have it audit how you have been using Claude Code and rebuild your configuration. Anthropic’s Fable 5, a Mythos-class model above Opus, is open in a limited preview right now. Any one-off result it produces stops mattering the day access ends. A rebuilt configuration keeps paying: it persists after the model is gone, and every cheaper model you run afterwards inherits it.

What did Fable 5 find in 800MB of my transcripts?

I ran exactly this today. Fable dispatched three parallel sub-agents across 3,339 transcripts from 28 projects: a stats agent and a repeated-instructions miner on Sonnet, a behavior auditor on the top model. The main session only orchestrated.

The honest part first: 8.6 billion cache-read tokens at a 91.4% hit ratio means caching already worked, and bash noise was not a problem. The waste sat elsewhere. Number one: marathon sessions, roughly 55 to 60% of all input volume. The worst single session ran 2,170 turns over 19 hours with 6 context compactions and 617M cache-read tokens. Number two: 236 full-resolution screenshots, about 51MB, read straight into the main context, some re-read 5 times while iterating. And the miner caught what I keep typing: “use sub-agents with right-sized models” appeared in 52 distinct sessions, yet only 25% of my work was delegated, and 90% of my output tokens ran on the top tier, just 2.6% on Haiku. The one project at 98% delegated, my automated nightly librarian, proves it: the pattern works when it is configuration, not typing.

The prompt to copy

Paste this into Claude Code while you still have a top model:

You have full access to my machine. Audit how I have been using Claude Code and rebuild my configuration so every future session is cheaper and better. Work as an orchestrator with an advisor: delegate everything delegable to parallel sub-agents with right-sized models (cheap ones for mechanical scans, your strongest tier only for judgment and synthesis), and before declaring done, review your own output adversarially.

1. INVESTIGATE. My past conversations live in ~/.claude/projects/ as .jsonl transcripts (one JSON object per line; assistant turns carry message.usage token counts; sub-agent activity is marked isSidechain). Dispatch at least three parallel read-only sub-agents:
   - a stats agent: token totals, cache hit ratio, model mix, share of work delegated to sub-agents, largest tool results
   - a behavior auditor: dissect the largest sessions for waste patterns (marathon contexts, images read into the main loop, re-reading the same files, zero delegation)
   - a repeated-instructions miner: find what I keep typing across sessions that should be configuration instead

2. SYNTHESIZE. Rank the waste patterns by token impact and tell me the single biggest lever first.

3. REBUILD. Propose, then implement:
   - a reorganized global CLAUDE.md: only standing behavioral defaults, written as overridable rules (my in-session instruction always wins; when I say nothing, the default applies)
   - skills for repeated procedures: anything I have asked for 3+ times that should run on demand instead of loading into every session
   - hooks in settings.json for enforcement: things I keep forgetting that a machine check can catch; guard every hook so it stays silent when not relevant
   - per-project CLAUDE.md notes for repo-specific policies that do not belong globally

4. VERIFY. Act as your own advisor before finishing: re-read everything you built, adversarially check that every new CLAUDE.md line earns its permanent context cost, and give me a before/after summary with the numbers.

Rules: the analysis is strictly read-only. Only configuration files may be edited. Never commit or push. Show me every change at the end.

What happens when you run it: the model dispatches the three read-only agents in parallel, returns a ranked findings report, implements the configuration changes, then reviews its own output before showing you every change. Read the findings before you approve the edits.

Where do the savings actually come from?

Ranked by token impact in my audit: session hygiene first. Persist state to a file and /clear instead of running marathons; save your Claude context is the same move. Second, images out of the main loop: full-resolution screenshots belong with a sub-agent that reports back in text. Third, model tiering: judgment on the top tier, mechanical work on cheap models. Fourth, the write-once effect: “finish the whole git loop” (21 sessions), “run a security audit before publishing” (15), “check for a PRD first” (14), and “keep repos private” (7) all stopped being things I retype.

Where each fix landed matters, because every CLAUDE.md line costs tokens in every future turn forever. Only standing behavioral defaults went into a lean global CLAUDE.md. Procedures became skills: the security audit is now an on-demand pre-publish-audit skill. Enforcement became hooks: a SessionStart hook now carries my PRD convention, the same mechanism as in make Claude Code follow your rules with hooks. Repo-specific policies moved into each project’s own CLAUDE.md.

The model goes away. The configuration it leaves behind runs in every session after it.

Do this now

1. While the Fable 5 preview (or whatever top model you can reach) is still open, run the prompt above instead of one more one-off task.
2. Read the ranked findings report before approving any edit: the waste list alone is worth the run.
3. Start a fresh session after the rebuild and watch what it does differently by default, at every tier.