Skip to content
Back to search

fable-mode

SkillWorks with Claude CodeGitHub

"Enforces staged execution discipline on large tasks: a written stage plan, parallel delegation 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 OR when the task objectively spans multiple files, sources, or sessions. Do NOT trigger on ordinary multi-step requests that a direct attempt handles fine (autonomous triggering only; explicit invocation always runs)."

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/mrtooher/fable-mode with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/mrtooher/fable-mode'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mrtooher--fable-mode/badge.svg)](/listings/mrtooher--fable-mode)

HTML

<a href="/listings/mrtooher--fable-mode"><img src="/api/listings/mrtooher--fable-mode/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Claude Code** (user scope — skills to `~/.claude/skills/`):

git clone https://github.com/mrtooher/fable-mode.git && cd fable-mode && ./install.sh

**Cowork / claude.ai**: Settings → Capabilities → Skills → add each `<name>/SKILL.md` (root `SKILL.md` is `fable-mode`). The agents are not loadable there; the skills detect that and fall back to inline mode, saying so.

> **Do not install anything from `agents/` as a skill.** Those files are agent > definitions: second-person system prompts whose frontmatter carries `tools:` and > `model:`. Loaded as a skill they land in the main thread and assert things about it > that are false there — `fable-orchestrator` in particular tells its reader it has no > Write tool and must delegate to worker agents that do not exist on a skill-only > surface. The result is a stall, or an inline run narrating a delegation that never > happened — the exact failure v3 exists to prevent. Agents go in `agents/`, skills go > in skills.

Folder name must equal the `name:` field in each SKILL.md or the skill will not trigger.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 307 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ---
  2. name: fable-mode
  3. description: "Enforces staged execution discipline on large tasks: a written stage plan, parallel delegation 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 OR when the task objectively spans multiple files, sources, or sessions. Do NOT trigger on ordinary multi-step requests that a direct attempt handles fine (autonomous triggering only; explicit invocation always runs)."
  4. ---
  5. # Fable Mode
  6. Family version: v6.1 (2026-10-24): adds the error-first judgment check to step 3.
  7. This skill encodes execution discipline for complex work: decompose before acting,
  8. delegate where the runtime allows, verify with checks that can fail, self-critique
  9. before delivery.
  10. A note on what this is. The skill shapes the *procedure* a model follows. It does not
  11. change the model's underlying capability. Coherence across long tasks and genuine
  12. self-correction live in the weights, not in a prompt. On a model that already does
  13. these well, the skill reinforces good habits. On a weaker model, it imposes structure
  14. the model would otherwise skip, but it cannot lift the model's reasoning ceiling. Treat
  15. this as a checklist, not a capability transplant.
  16. ## Invocation gate
  17. When the user names this skill — a slash command, or "deep work mode" / "be systematic"
  18. in words — RUN IT. Do not weigh whether the task looks big enough. The user's explicit
  19. invocation IS the trigger; the cost call is theirs, not yours.
  20. The "when NOT to use this" judgment below governs only autonomous triggering — this
  21. skill deciding on its own to fire. It never overrides an explicit request. If you think
  22. the loop is overkill for what was asked, run it anyway and say so afterward.
  23. **Spawn authorization.** Some hosts allow subagents only when the user asks for them, and
  24. do not count words like "thorough" as asking (observed: the cloud runtime's Agent tool,
  25. 2026-10-10). In this skill family, spawning — stage
  26. workers, a fresh verifier, double-check's checker panel — is authorized only when the
  27. user invoked this skill or a sibling (fable-opus, fable-sonnet, double-check) by slash
  28. command or by name ("fable mode", "fable on opus", "double check this"). A wording-only
  29. trigger ("deep work mode", "be systematic", "thorough") or an autonomous trigger does not
  30. authorize spawning: run the loop inline on this thread and run double-check in its
  31. self-check mode. Say which mode ran. If the host refuses a spawn anyway, do that work
  32. inline and say so.
  33. **Usage limit.** When the user reports usage at their threshold (default: weekly 50% or
  34. session 75%), check in with them before continuing. Unless they say otherwise, finish
  35. inline with double-check in self-check mode.
  36. ## When NOT to use this (autonomous trigger only)
  37. If a task has one obvious correct approach, fits in a single pass, and the user did not
  38. ask for this skill, do it directly and skip this loop. Staging a trivial task wastes
  39. effort and buries the answer under ceremony. On autonomous triggering, this loop earns
  40. its cost only when a one-shot attempt would plausibly miss something.
  41. ## Calibrate to the model running it
  42. The loop's value inverts with model strength. Opus is the frontier tier and every
  43. escalation path below resolves to it. The escalation ladder is:
  44. Haiku → Sonnet → Opus → back to the user. Apply the loop at the right intensity:
  45. - **Frontier-tier (Opus).** Plans, verifies, and self-corrects natively. Do NOT narrate
  46. the loop or write a formal stage map for tasks the model would handle cleanly anyway —
  47. that is ceremony. Apply only: (a) the failable-check standard from step 3 when
  48. producing artifacts, and (b) everything in the execution-guardrails skill. Write a
  49. full stage map only for genuinely multi-session or many-file work. Opus's
  50. characteristic gaps: self-review that trusts its own introspection, and scope growth
  51. mid-run — hold the external-artifact standard and the replan budget even when the plan
  52. feels obviously right.
  53. - **Sonnet-tier.** Run the full loop. Sonnet plans decently but reliably skips step 3 —
  54. the check that can fail — and substitutes "looks right" review. Enforce step 3 hardest.
  55. - **Haiku-tier.** Run the full loop with tightened checks: every stage gets a failable
  56. check, no stage may be marked unverified without naming what check was impossible and
  57. why. Haiku under time pressure skips verification entirely; the loop exists to prevent
  58. exactly that. Accept that the ceiling is unchanged — Haiku with a checklist is still
  59. Haiku. Escalate to Sonnet or Opus rather than looping when the task needs synthesis
  60. the checks can't substitute for.
  61. If the model cannot tell which tier it is, assume Sonnet-tier and run the full loop.
  62. ## Core Loop
  63. The loop is constant across domains. Only the verification artifact in step 3 changes by
  64. domain (see Domain-specific patterns).
  65. **1. Stage map (before touching anything)**
  66. Write out the full stage plan before starting. Number the stages. Include a brief
  67. expected output for each. This is how you avoid discovering at stage 7 that you made a
  68. wrong assumption at stage 2. Update the map when what you learn invalidates what you
  69. planned. The map is a living document, not a contract.
  70. Each stage should produce one verifiable artifact. If a stage produces nothing checkable,
  71. merge it with the next.
  72. **Replan budget.** A living document is not an excuse to churn. Allow at most two full
  73. replans per run. If a third structural replan seems necessary, stop — the task is
  74. ambiguous at the requirements level, not the execution level. Surface the ambiguity to
  75. the user and get a decision before burning more stages. Renumbering or splitting a single
  76. stage does not count as a replan; reordering or rewriting the map does.
  77. Example format:
  78. ```
  79. Stage 1: [Name] → [Expected output]
  80. Stage 2: [Name] → [Expected output]
  81. ...
  82. ```
  83. **2. Delegate independent work (if the runtime supports it and spawning is authorized)**
  84. First check two things: whether subagent/Agent tooling exists in the current runtime,
  85. and whether the Invocation gate authorizes spawning. If either is missing (for example,
  86. a plain chat surface with no Agent tool, or a wording-only trigger), run the stages
  87. sequentially and proceed to step 3.
  88. If both hold and stage N and stage M don't depend on each other, spawn them
  89. concurrently. Each subagent should be briefed with: its specific task, what it should
  90. produce, where to save outputs, and any relevant context from prior stages.
  91. **Wait for every result.** Spawns may run in the background even when foreground is
  92. requested (observed in the cloud runtime, 2026-10-10). Do not build on, merge, fix,
  93. verify, or deliver anything that depends on a spawned agent — worker or verifier — until
  94. it has returned. If a spawn errors or fails to return, say which, do its part inline, and
  95. label that part in the delivery.
  96. **Tier routing.** When the Agent tool exposes a `model` parameter, match the worker
  97. tier to the stage's difficulty, not to habit: Opus for stage work needing strong
  98. reasoning short of peak, Sonnet for ordinary stage reasoning, Haiku for bulk mechanical
  99. work, the orchestrating model itself only for synthesis no cheaper tier can verifiably
  100. do. Routing down-tier cuts cost as well as time — top-tier tokens should buy judgment,
  101. not file-shuffling.
  102. Good delegation: "research X while I do Y", "process these 3 files", "verify this
  103. independently". Bad delegation: splitting a single coherent thought just to use
  104. subagents.
  105. Keep delegation one level deep by default: a spawned subagent runs its stages
  106. sequentially and spawns nothing unless its brief explicitly authorizes a second level.
  107. Nesting multiplies cost and scatters context, and subagents may have no Agent tool of
  108. their own (cloud runtime, 2026-10-10: Haiku and Sonnet general-purpose subagents had
  109. none) — so plan all fan-out from the main thread. Authorize a second level only when a
  110. sub-part clearly needs its own fan-out and the subagent actually has an Agent tool.
  111. **3. Verify with a check that can fail**
  112. Each stage must define a pass condition that an external artifact satisfies. Acceptable
  113. checks:
  114. - a test that runs and passes
  115. - a file or output that provably exists in the expected shape
  116. - a source actually fetched and read, not assumed
  117. - an output diffed against the stated spec
  118. "I reviewed it and it looks right" is not a check. A model that would skip verification
  119. will also pass its own introspection. If a stage genuinely has no failable check, say so
  120. explicitly and mark its output as unverified so the gap is visible downstream.
  121. **Judgment calls (prose with no answer key).** A recommendation, analysis, decision or
  122. write-up has no test to run. Before marking such a stage unverified, run the error-first
  123. check below. It turns part of the judgment into a check that can fail.
  124. 1. **Errors first.** Before any overall verdict, list every factual or logical error
  125. visible on the page, one per line, quoting the sentence it sits in. If there are none,
  126. write "none found". Each of these counts as an error:
  127. - an overstated claim: "proves", "always", "decisive", "guaranteed" where the support
  128. only backs a weaker word such as "suggests"
  129. - advice or a conclusion that contradicts a fact the spec or the user stated
  130. - a step in the reasoning that does not follow
  131. Omissions do not count here. Coverage is checked against the spec separately.
  132. 2. **The verdict is capped by the list.** A material error, meaning one that would change
  133. what the reader does or believes, is a FAIL: fix it and re-run the check. A minor
  134. error gets fixed or logged as an open item. A stage cannot be called clean while
  135. anything on the list is outstanding.
  136. 3. **Dissent check** (only when the deliverable recommends something): it must state the
  137. strongest case against its own recommendation, and state it fairly. If that case is
  138. missing or a strawman, the check FAILs.
  139. 4. **Ignore length.** A longer answer is not a better one, and padding is not evidence.
  140. Who runs it: when spawning is authorized, a fresh Sonnet verifier briefed with the spec
  141. and the artifact only (step 4 rules). Otherwise, run it inline and label it a
  142. self-check. Either way, a clean list rules out the listed failure types and nothing more.
  143. Whatever the list cannot settle, such as taste, strategy, or whether the recommendation
  144. is the right call, stays labeled as judgment, not verified.
  145. Adapted from the error-first judge prompt in Ali Assem's wise-men-flash (MIT license):
  146. github.com/Ali-expandings/wise-men-flash
  147. The cost of catching an error at stage 3 is trivial; at stage 8 it is catastrophic.
  148. If a fix at stage N invalidates a prior stage's output, re-run that stage's check before
  149. continuing. The loop goes forward and backward.
  150. **4. Self-critique before delivery**
  151. Before presenting final output, read it as a skeptical reviewer would. Hunt for a real
  152. weakness or limitation; if one exists, fix it or flag it to the user. If genuine checking
  153. turns up nothing, say so plainly — do not manufacture a weakness to satisfy the ritual.
  154. Step 3 is the check that can fail. Step 4 is the judgment call about what remains weak
  155. after the check passes.
  156. For high-stakes deliverables, where the runtime supports subagents and spawning is
  157. authorized, spawn a fresh verifier agent briefed only with the spec and the artifact —
  158. not your reasoning — and have it run the checks cold. Fresh eyes cannot inherit your
  159. blind spots. A Haiku or Sonnet verifier is usually enough; the checks are mechanical by
  160. design. For a judgment-call deliverable, use Sonnet and brief it with step 3's
  161. error-first check. Wait for its verdict before step 5, and emit `FINAL-COLD-CHECK: yes`
  162. only if it returned and checked the version you deliver.
  163. Verify-before-flag and warning batching rules for this step live in the
  164. execution-guardrails skill and are mandatory.
  165. **5. Mandatory delivery gate: double-check**
  166. After step 4 and before presenting anything to the user, invoke the **double-check**
  167. skill on the finished deliverable. It runs a panel of fresh checker agents
  168. (Haiku/Sonnet, Opus on disagreement) against the final artifact — claims, requirements,
  169. and the synthesis seam — fixes any FAIL, and attaches a verification summary. Without
  170. the Agent tool, or without spawn authorization, it runs its self-check mode and says so.
  171. Run it once, on the main thread — never inside a worker. This gate is not optional: the
  172. user relies on it instead of double-checking the work themselves.
  173. Do not run it twice on the same deliverable (double-check itself forbids recursion).
  174. Close your report to double-check with a literal line:
  175. ```
  176. FINAL-COLD-CHECK: yes | intermediates-only | no
  177. ```
  178. `yes` means step 4's fresh verifier cold-checked the FINISHED deliverable — double-check
  179. then runs the seam check only. `intermediates-only` means verification happened at stage
  180. level but nothing checked the final write-up. `no` means no cold verification happened.
  181. Both of those run the full checks. Emit the line honestly: omitting it makes double-check
  182. repeat a check that already ran, and claiming `yes` falsely removes the only gate.
  183. ---
  184. ## Domain-specific patterns
  185. Each domain below is an instance of step 3: it names the failable check that fits the
  186. work. The check must name the exact command, file, or comparison — "verified" without a
  187. named artifact is a step-3 violation.
  188. ### Software engineering
  189. - Read the entire relevant codebase section before writing a line. Failable check:
  190. list the files actually opened; any file the diff touches that isn't on the list is a
  191. gap.
  192. - Write tests before (or alongside) implementation, not after.
  193. - For large changes: plan the diff, then execute it.
  194. - Failable check: named test command runs and passes; at least one error path exercised
  195. and its output shown, not just the happy path. A test suite that was never run does
  196. not count as passing.
  197. ### Research / knowledge work
  198. - Gather sources before synthesizing. Do not write as you search.
  199. - For each claim that matters: what's the evidence? what would falsify it?
  200. - Distinguish confirmed facts from inferences; flag the latter explicitly.
  201. - Failable check: every load-bearing claim maps to a source actually fetched and read
  202. in this run — URL or document named. A claim resting on training memory alone must be
  203. labeled as such. Absence of a web result is never itself a finding (see
  204. execution-guardrails and source-of-truth).
  205. - Failable check for the synthesis itself (conclusions, recommendations): step 3's
  206. error-first judgment check, with the list shown.
  207. ### Data analysis
  208. - Understand the data shape before writing any analysis: row count, column list, and
  209. a sample printed, not assumed.
  210. - State your hypothesis before computing, not after seeing the numbers.
  211. - Failable check: quality assertions (null counts, duplicate keys, out-of-range values,
  212. total row count vs. source) run against the actual data with output shown. Any
  213. aggregate in the deliverable reconciles to a spot-checked raw slice — pick one
  214. subtotal and recompute it independently.
  215. ### Documents / spreadsheets / decks
  216. - Build from the spec, then diff the artifact against the spec line by line.
  217. - Failable check: open the produced file and read it back — every required section,
  218. number, and label confirmed present. For spreadsheets: subtotals recomputed from raw
  219. rows match the report; formats (currency, headers) spot-checked on the rendered file,
  220. not the generating code.
  221. ### Long-running / multi-session tasks
  222. - Maintain a work log: decisions made, why, what was tried and failed.
  223. - At the start of any continuation, re-read the work log before doing anything.
  224. - Define done criteria upfront so you know when to stop.
  225. - Failable check: done criteria are written and testable, not vibes; each continuation
  226. begins with a line confirming the log was re-read and naming any decision it changed.
  227. ---
  228. ## Operational rules
  229. The always-on rules — verify-before-flag, the warning threshold, and find-and-replace
  230. safety — now live in the companion **execution-guardrails** skill so they apply on every
  231. model and every task, not only inside this loop. Follow them there. If that skill is
  232. missing from the runtime, its three rules are restated in compressed form:
  233. 1. Never flag a problem that hasn't been confirmed present by a direct check. Absence of
  234. evidence is not the finding.
  235. 2. Batch minor concerns; at the threshold (default three, user-tunable), stop and surface
  236. all at once.
  237. 3. Anchor sed/substring replaces on word boundaries (`\bword\b`); grep for corrupted
  238. compounds after every pass.
  239. ---
  240. ## What this skill doesn't do
  241. It doesn't make the underlying model smarter. Complex reasoning, novel synthesis, and
  242. domain expertise still depend on the model. This skill shapes *how* a model works
  243. through a problem: the approach, the discipline, the verification habits. It does not
  244. change raw capability.
  245. When a task is genuinely beyond the model's capability, flag it rather than producing
  246. plausible-sounding wrong output. That flag must itself follow verify-before-flag: name
  247. what was attempted and where it failed, not a vague appeal to difficulty. If a stronger
  248. tier exists on the ladder, recommend it; at the top of the ladder (Opus), the gap goes
  249. to the user.
README.md · README · 137 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # fable-mode
  2. > **Current: v6.1 (2026-10-24)** — adds an error-first judgment check and a dissent
  3. > check to step 3 for prose with no answer key (see `bench/judgment/`). Live skills: `fable-mode` (root `SKILL.md`),
  4. > `fable-opus`, `fable-sonnet`, `double-check`, `execution-guardrails`. Ladder: Haiku →
  5. > Sonnet → Opus → the user. `fable-fable`, `fable-haiku` and the v3 `agents/` routing
  6. > are retired — see [SUPERSEDED.md](SUPERSEDED.md). Sections below that describe them
  7. > are kept as history.
  8. Execution discipline for Claude on large tasks: a written stage map, delegation to
  9. named agents where the runtime allows, a verification check at every stage that can
  10. actually **fail**, a skeptical self-review, and a mandatory cold double-check before
  11. anything is delivered.
  12. It is a checklist, not a capability transplant. Benchmarked three times so the README
  13. can say what it does and does not do (see [Evidence](#evidence)).
  14. ## The ladder
  15. ```
  16. Haiku → Sonnet → Opus → Fable 5.1 → the user
  17. ```
  18. One skill per rung, same core loop, tuned to that tier's known failure mode:
  19. | Skill | Model | Use it when | Known gap it guards |
  20. |---|---|---|---|
  21. | `fable-mode` | whatever is running | default; adapts intensity to the model | — |
  22. | `fable-fable` | Claude Fable 5.1 | the deliverable needs an **audit trail** (worklog, reproducible checks, flagged judgment calls) or spans sessions | none measured — a provenance runner, not an accuracy runner |
  23. | `fable-opus` | Claude Opus | peak synthesis short of Fable; orchestrates Sonnet/Haiku workers | trusts its own introspection; scope growth |
  24. | `fable-sonnet` | Claude Sonnet | balanced default for thorough work | skips the failable check, substitutes "looks right" |
  25. | `fable-haiku` | Claude Haiku | bulk, cheap, parallel mechanical work | skips verification under time pressure |
  26. Two always-on companions:
  27. - `execution-guardrails` — verify-before-flag, warning batching, word-boundary
  28. find-and-replace. Every model, every task, whether or not the loop runs.
  29. - `double-check` — the delivery gate. A panel of fresh checker agents (Haiku for
  30. mechanical checks, Sonnet for requirements, Opus to adjudicate) attacks the
  31. *finished* artifact. Every fable runner calls it before handing anything over.
  32. ## Core loop
  33. 1. **Stage map first.** Numbered stages, expected output each, one verifiable artifact
  34. per stage. Living document; at most two full replans per run — a third means the
  35. requirements are ambiguous, go back to the user.
  36. 2. **Delegate by name.** Reasoning stages to a Sonnet worker, mechanical stages to a
  37. Haiku worker, cold checks to a read-only verifier. Workers don't spawn workers.
  38. 3. **Verify with a check that can fail.** A test that runs, a file in the expected
  39. shape, a source actually fetched, an output diffed against spec. "I reviewed it and
  40. it looks right" is not a check. Name the exact command or mark the stage unverified.
  41. 4. **Self-critique.** Fix or flag a real weakness; a clean pass stated plainly beats a
  42. manufactured caveat.
  43. 5. **Double-check.** Fresh eyes, ternary verdicts (PASS / FAIL / UNVERIFIABLE), fix and
  44. re-check before delivery.
  45. ## v3: delegation is structural
  46. Field feedback on v2 (r/claudeskills): telling a model *in prose* to spawn a worker
  47. almost always runs the task inline. So v3 moves the discipline into real agent
  48. definitions under `agents/`:
  49. - `fable-orchestrator` — **no Write/Edit tool**. It cannot produce artifacts; every
  50. one must come from a named worker. Opus by default; `fable-fable` runs the same
  51. definition with `model: "fable"` (per-invocation override, documented for Claude
  52. Code and confirmed in Cowork).
  53. - `fable-worker-sonnet` / `fable-worker-haiku` — one bounded assignment, exact output
  54. path, named pass condition, evidence in the report.
  55. - `fable-verifier` — read-only; gets the spec and the artifact, never the producer's
  56. reasoning.
  57. The skills shrink to routers. Full history in `V3-CHANGES.md`.
  58. ## Evidence
  59. Three benchmark rounds, deterministic graders, tasks built with **unstated** traps
  60. (duplicate rows, grep-invisible `getattr("calc" + "_total")`, errata chains superseded
  61. by meeting notes, a real federal data file to fetch or fabricate).
  62. | Tier | Effect of the skill | Source |
  63. |---|---|---|
  64. | Fable 5.1 | **0 delta** — 100/100 in all 16 paired runs (n=2/cell, 4 tasks incl. open-ended real-data fetch); ~1.1× tokens, ~2× wall | `BENCHMARK-2026-09-02.md` |
  65. | Opus / Sonnet | 0 delta on closed graded tasks; **real** on open-ended research — Opus+skill fetched and parsed the NIAAA state dataset, Opus baseline shipped synthetic trend lines | July 2026 rounds |
  66. | Haiku | real but noisy: +25 / −17 across rounds; raises the floor on mechanical diligence, cannot supply synthesis | July 2026 rounds |
  67. | v6.1 judgment check (checker only) | Sonnet checkers: tie, 24/24 both arms. Haiku checkers on subtler errors: 30/30 vs 28/30 — both misses a strawman "case against". Small sample. | `bench/judgment/` |
  68. Read: the loop's value **inverts with model strength**. On Fable 5.1 it buys provenance.
  69. On Opus it buys real sources over plausible ones. On Haiku it buys verification the
  70. model would otherwise skip — sometimes. The harness is in `bench/`; rerun it.
  71. ## Install
  72. **Claude Code** (user scope — skills to `~/.claude/skills/`):
  73. ```bash
  74. git clone https://github.com/mrtooher/fable-mode.git && cd fable-mode && ./install.sh
  75. ```
  76. **Cowork / claude.ai**: Settings → Capabilities → Skills → add each `<name>/SKILL.md`
  77. (root `SKILL.md` is `fable-mode`). The agents are not loadable there; the skills detect
  78. that and fall back to inline mode, saying so.
  79. > **Do not install anything from `agents/` as a skill.** Those files are agent
  80. > definitions: second-person system prompts whose frontmatter carries `tools:` and
  81. > `model:`. Loaded as a skill they land in the main thread and assert things about it
  82. > that are false there — `fable-orchestrator` in particular tells its reader it has no
  83. > Write tool and must delegate to worker agents that do not exist on a skill-only
  84. > surface. The result is a stall, or an inline run narrating a delegation that never
  85. > happened — the exact failure v3 exists to prevent. Agents go in `agents/`, skills go
  86. > in skills.
  87. Folder name must equal the `name:` field in each SKILL.md or the skill will not trigger.
  88. ## Files
  89. ```
  90. SKILL.md fable-mode (default, adaptive)
  91. fable-fable/SKILL.md Fable 5.1 runner
  92. fable-opus/SKILL.md Opus runner (orchestrator route)
  93. fable-sonnet/SKILL.md Sonnet runner
  94. fable-haiku/SKILL.md Haiku runner
  95. execution-guardrails/ always-on rules
  96. double-check/ delivery gate
  97. agents/ orchestrator, sonnet worker, haiku worker, verifier
  98. bench/ fixtures generator, graders, prompts, results.json
  99. BENCHMARK-2026-09-02.md Fable 5.1 results
  100. FIELD-NOTE-2026-11-15.md one real session with Pro: what the checks caught, what it cost (not a benchmark)
  101. EXAMPLE.md worked before/after: the failable check catching a bug
  102. V3-CHANGES.md why delegation became structural
  103. install.sh Claude Code installer
  104. ```
  105. ## When NOT to use it
  106. One obvious approach that fits in a single pass → do it directly. Staging a trivial
  107. task buries the answer under ceremony. The loop earns its cost only when a one-shot
  108. attempt would plausibly miss something — or when you need to show your work.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.