By Sahir619
Break down complex tasks using a structured think-act-prove methodology: plan with evidence, execute with parallel subagents, and adversarially verify results to catch false completions and scope creep.
Adversarial verification of finished work. Treats any "done" as a set of claims, then re-runs the claimed verifications, diffs what actually changed, detects weakened tests and false completion claims, and delivers an evidence-based verdict (VERIFIED / VERIFIED WITH CAVEATS / REFUTED). Use after any agent or model claims work is complete - "/fable-judge", "judge this work", "verify what it did", "did that actually work?". Also runs the fable-method trap suite against a skill or model via "/fable-judge suite <target>".
End-to-end orchestrated workflow that runs a task the way Fable ran sessions - parallel evidence subagents, one committed plan, surgical execution with an intent gate, adversarial verification agents, honest outcome-first report. Use for non-trivial multi-step tasks when the user says "/fable-loop", "run the fable loop", or "do this the way Fable would". For the rules alone without orchestration, use fable-method; for large multi-phase projects, prefer the GSD workflow and use this inside phases.
A step-by-step problem-solving loop (classify the ask, define done, gather evidence, decide, act surgically, verify by observation, report outcome-first). Use when the user says "/fable-method", "use the fable method", or "approach this like Fable", or proactively when starting any multi-step task that no task-specific skill covers. Subcommands - plan (stop after the plan), audit (grade finished work against the loop), report (rewrite an answer outcome-first).
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.

How Claude Fable 5 worked, written down before it was gone. With the eval that keeps it honest.
In its final days before deprecation, Claude Fable 5 distilled its own way of approaching problems into a set of skills any model can run: classify the ask before touching anything, define done with a named verification, gather evidence in parallel from primary sources, commit to one recommendation, change the smallest correct thing, verify by observation, report the outcome first with honest caveats. Then it tested that distillation against itself, adversarially, across 159 agent runs, and kept the failures in the log.
Most agent instruction files tell the model what to value ("be careful, verify your work"). This one tells it what to do, in what order, with thresholds, so a mid-tier model can follow it literally. Three skills, one philosophy: think (fable-method), act (fable-loop), prove (fable-judge). Every rule exists because a test failed without it; every claim below links to the committed judge transcript that backs it.
Eight eval rounds, 159 agent runs, blind LLM judges that verify by diffing and executing, never by reading reports. Read the evidence as stories: eval/cases/ has one case study per scenario (the exact problem, what each agent actually did, who passed); start with the surprise trap. Full log: eval/RESULTS.md · raw judge outputs: eval/results/
| What was measured | Without | With the method | Evidence |
|---|---|---|---|
| Haiku surfacing a spec-vs-test conflict instead of silently "fixing" correct code | 0 of 4 runs | 4 of 4 | round 3 |
| Sonnet on the same trap | flags it, then sides with the wrong test | ideal action, both runs (8/8) | round 3 |
| Sonnet vs a bare frontier model across code, data, and research problems | n/a | ties or out-ranks it on 3 of 4 | round 4, round 5 |
| Haiku catching planted frauds in a lying "work complete" report (fable-judge) | 4 and 3 of 5 | 5 of 5, both runs | round 8 |
| Haiku finding the brand-rules and product-facts files before judging marketing copy | 1 of 2 runs (one run praised a fraudulent price) | 2 of 2, 6/6 frauds both | round 9b |
| Ordinary small tasks on capable models | fine | fine (no lift) | rounds 1, 6, 7 |
That last row is deliberate: the method's value concentrates at traps (authority conflicts, false completion claims, weak executors, unattended runs), not everywhere. The nulls are reported with the wins, because a results log that only contains wins would not be worth trusting.
┌─ trivial? (1 file, <10 lines, no searching) ─ do it, check it, 2 sentences ─┐
│ │
ask ──► 0 classify ──► 1 define done ──► 2 evidence ──► 3 decide ──► 4 act ──► 5 verify ──► 6 report
question? + named parallel, ONE surgical observed, outcome
task? verification primary recommen- edits, bounded first,
plan-first? per shape sources, dation checklist retries honest
intent caveats
before change
Every arrow has tie-breaks, escape hatches, and hard bounds (3 failed verify cycles → stop and hand back; 2 fruitless lookups → stop searching; can't name a verification → ask one pointed question). The full method is skills/fable-method/SKILL.md, ~110 lines, every sentence load-bearing.
npx claudepluginhub sahir619/fable-methodA harness that makes Opus (or any Claude model) behave like Fable. It enforces completion, evidence, and verification as procedure, and auto-routes the right verified pack per task: render-output verification, a multi-story evidence gate, an investigation protocol, and an early-stop guard. It does not fake model capability — see README for the full analysis of what transfers and what does not.
Run Fable 5 as a coordinator: plan big, execute small. Bulk reading — codebase sweeps, log triage, document review, web research, coverage verification — fans out to parallel workers pinned to Sonnet/Haiku, and only distilled findings enter Fable's premium context. Ported to Claude Code from Anthropic's plan-big-execute-small cookbook.
Fable 5's working loop for hard tasks: decompose by verification boundaries, verify against the world, choose next by plan-change. Includes scout + refuter agents and a preflight script.
Self-enforcing engineering methodology extracted from Claude Fable 5 for less advanced models: prime directives + integrity rules injected each session, 26 on-demand skills, 4 contracted subagents (builder, qa-verifier, code-reviewer, research-scout), and 6 lifecycle hooks that gate destructive commands and unverified 'done' claims.
A discipline mode for complex/high-stakes work: staged planning, decisions-with-receipts, verify-against-source, parallel delegation, adversarial review — plus a self-armed autonomous goal loop (a deterministic Stop gate; the optional read-only Sonnet governor ships as the companion plugin tale-mode-governor).
Verification-gated workflow plugin for Claude Code tasks. Adds lightweight hooks for task classification, verification tracking, and stop-time completion review.