fable-mode skill
An execution-discipline skill for Claude: staged planning, delegation to agents, failable checks and a double-check before delivery
- 891 ★ on the repository
- Last commit
Minimal access
Why this level
- The set consists of instructions and agent definitions and adds no actions on external systems
Install
- Works in
Manual install
git clone https://github.com/mrtooher/fable-mode.git && cd fable-mode && ./install.shSkills go to ~/.claude/skills/, agents to ~/.claude/agents/.
Access and checks
How we reviewMinimal accessThe tool runs nothing and makes no network calls.
- The set consists of instructions and agent definitions and adds no actions on external systems
This is third-party code. Review the repository files before installing.
What it does
This is a set of skills that imposes execution discipline on large tasks in Claude. It requires a written stage plan first, delegation to named agents where the runtime supports it, a check that can actually fail at each stage, and a skeptical self-review plus a cold double-check before the result is handed over. It includes the general fable-mode plus model-specific variants, along with two always-on companions: execution-guardrails with base rules and double-check as the final gate before delivery. In version 3 delegation was moved into separate agent definitions, because asking to delegate in prose usually makes the model do everything inline. The author stresses this is a checklist, not a new capability, and reports results from three benchmark rounds.
Who it is for. For people who give the agent large multi-step tasks and want a plan, checks and an execution trail.
Good fit when
- The task spans many files, sources or sessions
- You need a reproducible work trail and checks, not just a result
- You want to reduce the risk of plausible but fabricated answers in research
Not a fit when
- The task is simple and fits in a single pass
- You need speed and the overhead of stages and checks is not justified
Example request
Do this thoroughly: lay out a stage plan, delegate and verify each stepLimitations
This is a method, not a new model capability. By the author's measurements there is no accuracy gain on short tasks; the value shows on open-ended research and on enforcing checks at lower model tiers. Structural delegation works only where the runtime supports named agents; otherwise the set falls back to inline mode and says so. Files from the agents folder must not be installed as skills. The repository has no license file.
How to disable. Remove the skill folders from ~/.claude/skills/ and the definitions from ~/.claude/agents/. In Cowork, remove the added skills through settings.
FAQ
Does it make the model smarter?
No. It is execution discipline: planning, delegation and checks. Accuracy does not rise on short tasks; the value is in verification and in real sources instead of fabricated ones.
What if the runtime has no agents?
The set falls back to inline mode on the current model and states plainly that structural delegation is unavailable.
Discussion
No questions or reviews yet.
Related
SkillsA skill that makes the lead Claude model a foreman: it plans work, hands tasks to worker agents and verifies the result itself.
A Claude Code plugin with four working-method skills: classify the task, act in steps, verify the result and generate domain adapters
fable-skills (DizzyMii)
fable-skills
Six discipline skills for Claude Code: answer first, edits only as asked and a claim of success only with proof.
A skill that makes Claude a conductor: it hands tasks to Codex workers in git branches and verifies each before merge.
A Claude Code template: 15 department agents, five skills and an approval queue for outward actions such as emails and invoices.
A Claude Code plugin that injects Anthropic guide rules into sessions, with the fable command expanding a vague ask
README in short
The README describes an execution-discipline set: a stage plan, delegation to named agents, a check that can fail, self-critique and a mandatory double-check before delivery. There are model-specific modes, while shared rules and the final gate live in the execution-guardrails and double-check skills. In version 3 delegation moved into agent definitions in the agents folder. It presents three benchmark rounds with deterministic graders and concludes that the loop's value grows toward lower model tiers. Installation for Claude Code runs through install.sh; for Cowork the skills are added manually.
README badge
Original SKILL.md
---
name: fable-mode
description: >
Enforces staged execution discipline on large tasks: a written stage plan,
delegation to named fable agents where the runtime supports it, a failable
verification check at each stage, and a skeptical self-review before delivery.
Trigger when the user explicitly asks ("do this thoroughly", "be systematic",
"deep work mode") OR when the task objectively spans multiple files, multiple
sources, or multiple sessions. Do NOT trigger on ordinary multi-step requests
that a direct attempt handles fine. For a run pinned to a specific model, use
fable-fable, fable-opus, fable-sonnet, or fable-haiku instead. Always-on guardrails
(verify-before-flag, warning batching, sed safety) live in the companion
execution-guardrails skill.
---
# Fable Mode (v3)
Decompose before acting, delegate to named agents, verify with checks that can
fail, self-critique before delivery. The skill shapes procedure, not
capability: benchmarked 2026-07.
## When NOT to use this
One obvious correct approach, fits in a single pass, do it directly. Staging a
trivial task buries the answer under ceremony.