Fable Method – Distilled Agent Workflow
Converts Claude Fable 5's way of working into executable skills, a loop, and a verifier, kept honest by a trap suite.
Evidence shows: plugin runs with least privilege, but permission boundaries not explicitly declared; user confirmation exists (plan stops, authorization gate), but not detailed; data flow transparency limited, no explanation of data handling or transmission; sensitive data handling not explicit; dependency security not audited; external effects (e.g., deployments) have authorization gate, but not comprehensive; rollback not explicit; source attribution clear (MIT license, author Sahir619). Deductions: permission boundaries, data flow, sensitive data, dependency security, external effects, rollback not sufficiently documented.
Evidence shows: method internally consistent, rules match flow; dependency availability not explicit (e.g., external APIs); failure messages have hard bounds (3 failed verify cycles stop), but error handling not detailed. Deduction: dependency availability not documented.
Evidence shows: clear target audience (Claude Code users, other agents); capability boundaries clear (refuses red-line domains like medical); trigger precision (classification step); environment fit (plugin, standalone skills, AGENTS.md). Deduction: no major deductions, but environment fit not fully tested.
Evidence shows: clear information architecture (directory structure); detailed install notes; naming stability (namespaced); examples and FAQ present (examples.md); known limitations present (null results); MIT license; versioning changelog present (DOC.md mentions changes); maintenance responsibility not explicit. Deduction: maintenance responsibility not explicit.
Evidence shows: high output usability (clear report format); marginal value present (improvement in trap scenarios); cost-benefit present (no lift on small tasks, but lift on traps). Deduction: no major deductions, but cost-benefit not quantified.
Evidence shows: claims traceable (links to eval results); cross-source corroboration limited (only internal eval); fact-inference separation clear (explicit distinction). Deduction: cross-source corroboration insufficient.
- Static review, no code execution, all conclusions based on file contents.
- Eval results based on LLM judges, small sample sizes (1-4 runs), may be unreliable.
- Dependency security not audited, external API usage not explicit.
- Maintenance responsibility unclear, community contribution path open but not implemented.
What does this agent do, and when should you use it?
The Fable Method is a Claude Code plugin that distills how Claude Fable 5 approached problems before its removal into four skills: fable-method (think), fable-loop (act), fable-judge (prove), and fable-domain (grow). Each skill defines exact steps, thresholds, and escape hatches, so even mid-tier models can follow it literally. The method centers on a six-step loop: classify, define done, evidence, decide, act, verify, and includes forced artifacts (like an INTENT line) for accountability. The repo includes 15 eval rounds with over 260 agent runs and 14 trap scenarios, showing lifts for weaker models (Haiku, Sonnet) especially on adversarial traps. It also ships eight domain adapters (marketing, research, data, business, finance, legal, design, DevOps) and a schema (TEMPLATE.md), with fable-domain to generate new adapters with a trap fixture and smoke eval.
As a Claude Code plugin, it provides four namespaced slash commands: /fable-method applies the loop's rules, /fable-loop runs the full orchestrated flow (parallel evidence subagents -> one committed plan -> surgical execution -> adversarial verifier agents -> audited report), /fable-judge performs adversarial verification of finished work (re-runs claimed checks, diffs changes, hunts weakened tests and false completion claims, returns VERIFIED / CAVEATS / REFUTED), and /fable-domain generates domain adapter bundles (adapter, trap fixture, smoke eval) for new sectors. fable-method also supports plan (produce a plan and stop), audit (grade existing work against the loop), and report (rewrite pending answer outcome-first). It reads trap fixtures from eval/scenarios/ and raw judge outputs from eval/results/, and follows rules in skills/fable-method/SKILL.md. It does not send data to external APIs; everything runs within the Claude Code context.
- A developer wanting a structured, step-by-step methodology (classification, definition of done, evidence gathering, verification) for non-trivial coding tasks rather than free-form prompting.
- A team using weaker models like Haiku or Sonnet that needs more reliable detection of spec conflicts or false success claims, e.g., the s2 surprise trap or s7 fraudulent-work scenario.
- An operations lead who needs to generate trustworthy adapters for domains like marketing, research, or DevOps, and wants the adapter to come with a trap fixture and smoke eval to ensure quality.
- An engineering team that wants adversarial audits of its agent's work, using /fable-judge to verify claims and expose weakened tests or unobserved checks.
- A researcher in agent methodology who wants to reproduce the repo's evaluations using the /fable-judge suite syntax or the eval/README.md.
- A user who wants to adapt fable-method's AGENTS.md to other tools (Codex, Cursor, aider) for the same methodology in different environments.
What are this agent's strengths and limitations?
- Every rule is backed by evidence: each rule exists because a test failed without it or a trace demanded it, with links to committed transcripts.
- Includes an adversarial trap suite (like s7 fraudulent work) and blind LLM judges that verify by diffing and executing, not by reading reports.
- Shows improvement on weaker models (Haiku, Sonnet) especially on traps, while honestly reporting zero lift on simple tasks, validating its scope.
- Transferable: provides an AGENTS.md for other agents (Codex, Cursor, aider) and fable-domain can generate new domain adapters.
- Exclusively a Claude Code plugin, requiring the Anthropic ecosystem; not applicable to other platforms.
- Evaluations are smoke-test grade (1-4 runs per cell) with LLM judges, so results may have statistical uncertainty and judge bias.
- The method cannot improve model knowledge freshness; on knowledge-heavy research tasks, bare frontier models may outperform it.
- Requires network access for fetching sources and running evals, and there is no clear cost estimate; multiple LLM calls may be involved.
- Documentation is dense with repo-specific terminology and flowcharts; new users may need significant reading to apply it effectively.
How do you install or deploy this agent?
Inside a Claude Code session, run:
/plugin marketplace add Sahir619/fable-method
/plugin install fable@fable-methodThis installs the four skills namespaced as /fable:. For standalone skills (un-namespaced), use:
git clone https://github.com/Sahir619/fable-method && bash fable-method/install.shWindows PowerShell: git clone https://github.com/Sahir619/fable-method; .\fable-method\install.ps1.
How do you use this agent?
After installation, use slash commands such as:
- /fable-method <task> to apply the loop.
- /fable-method plan <task> to classify, define done, gather evidence, and deliver a plan, then stop.
- /fable-loop <task> for a full orchestrated run.
- /fable-judge to verify finished work.
- /fable-judge suite <target> to run the repo's trap suite on any skill, model, or prompt.
- /fable-domain <sector> to generate a domain adapter bundle.
It is recommended to add proactive triggers to ~/.claude/CLAUDE.md, such as: "Before any non-trivial multi-step task, apply the fable-method loop; for tasks that will run unattended or fan out subagents, use fable-loop." and "After completing substantive work, or whenever any agent/tool claims work is done, run a fable-judge pass before presenting it as finished."