Autonomous, high-reasoning operating mode for Claude Code — a drop-in skill that gives any model the working behaviors that made Claude Fable 5 valuable.
Long-horizon planning · proactive autonomy · self-verification · sub-agent delegation · evidence-grounded progress · persistent memory across a run.
Unofficial community project. Not affiliated with, endorsed by, or built by Anthropic. "Claude" and "Fable" are Anthropic's marks, referenced here only to describe what this skill emulates. This does not replicate Fable 5's capability — it reshapes how your model works, not which model is running.
Claude Fable 5 is Anthropic's most capable model — premium-priced and, at times, unavailable. But a large part of what made it feel different wasn't raw capability; it was a set of repeatable working behaviors: it planned across stages, kept going where weaker setups stopped to ask, tested its own output, and carried messy input all the way to a finished deliverable.
Those behaviors can be specified. Fable Mode specifies them as an operating contract plus eight concrete frameworks, packaged as a Claude Code skill. Run it on Opus 4.8, Sonnet, or whatever you've got — you get Fable's way of working, on the model you're already paying for.
It is honest about the gap: see Honest limits.
| Behavior | What it looks like in practice |
|---|---|
| Long-horizon planning | Decompose the whole goal into a sequence before acting, not one step at a time. |
| Proactive autonomy | Resolve inferable ambiguity and keep moving; stop only at genuine forks. |
| Self-verification | Check output against the goal and standards — ideally with a fresh-context reviewer — before declaring it done. |
| Delegation | Break large jobs into parallel sub-tasks, then synthesize. |
| Intent capture | Turn raw notes into a finished, review-ready deliverable in one pass. |
| Evidence-grounded progress | Report only what a tool result actually proves. Never fabricate "done." |
| Effort calibration | Go deep where it changes the outcome; stay light where it doesn't. |
| Memory & continuity | Persist state in PROGRESS.md so long runs resume instead of restarting. |
Full spec: docs/how-it-works.md.
This repository was produced by Claude Code operating under Fable Mode itself — the behaviors above, applied to the job of packaging them:
- Intent capture turned a one-line request ("package this for GitHub") into the full repo — README, skill, license, installer, docs, example — in one pass, not a plan to make it.
- The autonomy ladder decided what shipped without asking (writing the files, the local commit) versus what stopped for the human (publishing — a rung-4 irreversible action held for explicit approval).
- Evidence-grounded self-verification ran a security scrub of every file and the git history — author metadata included — before any of it went public.
If the contract didn't hold, you'd be reading a worse README.
Pick whichever you prefer — all three install the same skill.
Fable Mode ships as a self-contained plugin marketplace, so you can install and update it from inside Claude Code:
/plugin marketplace add PH5h5W6d2L/fable-mode
/plugin install fable-mode@fable-mode
The skill lives at skills/fable-mode/SKILL.md and the slash command at commands/fable-mode.md; both are auto-discovered. Update later with /plugin marketplace update fable-mode.
git clone https://github.com/PH5h5W6d2L/fable-mode.git
cd fable-mode
./install.shThis copies the skill to ~/.claude/skills/fable-mode/ and a slash command to ~/.claude/commands/fable-mode.md (both global — available in every project). Nothing else is touched.
Copy skills/fable-mode/SKILL.md to ~/.claude/skills/fable-mode/SKILL.md. That's the whole skill.
Start a Claude Code session and either:
/fable-mode
or just say it in plain language:
use fable mode and migrate this service to the new API, end to end
Then hand it ambitious, multi-step work. For true unattended runs, use headless mode with permission to act:
claude -p "Use fable mode. <your task>. Work to completion without stopping for approval."It will keep a PROGRESS.md as it goes, so you can stop and resume.
- Behavior, not capability. This changes how the model works, not its reasoning ceiling. It does not grant Fable 5's benchmark performance — the hardest long-horizon and frontier-coding gains are model-level.
- Autonomy depends on the harness. With permissions in Claude Code it drives long sessions; in a plain chat it can't run unattended. The realistic version of "no babysitting" is maximum complete work per turn, interrupting only at genuine forks.
- Bounded by safety. Irreversible or access-broadening actions (sending external messages, deleting, spending, publishing) always stop for confirmation, by design.
- Still an LLM. It can over-think simple tasks and still be confidently wrong. The frameworks manage those failure modes; they don't erase them. Human review still matters.
Eight frameworks — PEV loop, autonomy ladder, self-verification, sub-agent delegation, intent capture, evidence-grounded progress, effort calibration, and memory/continuity — plus nine operating principles. Read the full breakdown in docs/how-it-works.md.
Issues and PRs welcome — especially real-world reports of where the autonomy ladder or effort calibration helped or hurt on long runs. Keep additions lean; the value of this skill is precision, not length.
Distilled from Anthropic's public guidance on Fable 5 (product page, prompting guide) and field experience running long autonomous Claude Code sessions. MIT licensed — see LICENSE.