Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Fable Mode Pro

    1

    Staged execution for Claude: plan, prove every stage with a check that can fail, and get a VERIFY.md audit trail.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Fable Mode Pro

    Fable Mode Pro

    Example session with this skill installed

    Use fable-mode: build a validator for my skills repo that checks every SKILL.md has valid YAML frontmatter with name and description, and that each skill's folder name matches its name field. Include tests.

    • Read your context and instructions
    • Compiled the fable mode pro

    Summary

    Built scripts/validate_skills.py + 33 tests for a 7-skill repo. All checks pass. The double-check panel then found 4 real bugs the first version shipped with, every one invisible to "looks right" review. All fixed and re-verified cold.

    Stage map

    StageOutputFailable check
    1 InventoryEvery SKILL.md + install.sh mappingfind lists 7 files; root skill installs as fable-mode
    2 SpecName/description rulesFetched agentskills.io/specification and read it, not recalled
    3 Tests first23 testsRun before validator exists → fails (red)
    4 Validatorvalidate_skills.py23/23 pass; real repo: 7 checked, 0 failed
    5 Gatedouble-check panelFresh Haiku + Sonnet checkers, claims only, no reasoning

    Delegation: stages 1–2 independent but each one quick read, so run inline. Spawning would cost more than it saves.

    Spec rules enforced

    • name: required, 1–64 chars, a-z 0-9 -, no leading/trailing hyphen, no --, must match folder
    • description: required, 1–1024 chars, non-empty
    • compatibility: 1–500 chars if present
    • Warnings: unknown fields, body over 500 lines

    Real repo result

    PASS  SKILL.md  (name: fable-mode)
    PASS  double-check/SKILL.md  (name: double-check)
    PASS  execution-guardrails/SKILL.md  (name: execution-guardrails)
    PASS  fable-fable/SKILL.md  (name: fable-fable)
    PASS  fable-haiku/SKILL.md  (name: fable-haiku)
    PASS  fable-opus/SKILL.md  (name: fable-opus)
    PASS  fable-sonnet/SKILL.md  (name: fable-sonnet)
    
    7 skill(s) checked, 0 failed
    

    Headroom check: fable-fable description is 970/1024 chars, 54 from failing.

    What the cold check caught

    The 23-test version passed everything. Then the Sonnet checker probed edge cases:

    BugInputBeforeAfter
    BOM rejectedfile starts EF BB BFfalse FAILPASS
    Crashinvalid UTF-8 bytestraceback, run abortsFAIL: "not valid UTF-8 (byte 37)"
    Silent truncationindented --- in block-scalar descriptiondescription cut to "hi", no errorfull description parsed
    Duplicate keystwo name: lineslast one silently winsFAIL: "duplicate key 'name'"

    One test of mine also passed for the wrong reason: it asserted "no errors", and the truncation bug produces no error. Tightened to check the parsed text, confirmed red, then fixed.

    Plus 6 tests for error paths nobody had tested (non-string name, trailing hyphen, non-mapping and empty frontmatter, whitespace description, empty/non-string compatibility).

    Ran 33 tests in 0.032s
    OK
    

    Verification

    Double-check: 5 claims + 7 requirements.
    FIXED after FAIL: 4 bugs + 6 untested error paths. Re-check round: 6/6 confirmed.
    Kept by choice: ASCII-only names, documented in the script.
    Checkers: 1× Haiku, 1× Sonnet, 1 Haiku re-check
    

    Next steps

    • Run python3 scripts/validate_skills.py in CI or a pre-commit hook.
    • Trim fable-fable's description before it crosses 1024.
    Every SKILL.md

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Complex, multi-file work fails when a model rushes to an answer and calls it done because it "looks right." Fable Mode Pro makes Claude plan the work in stages, prove each stage with a check that can actually fail, and hand you a written record of every check it ran.

    What Pro adds

    • Its own command (fable-mode-pro): /fable-mode-pro runs the full loop with everything below always on. Regular /fable-mode stays in the bundle and stays regular, so you choose per task.
    • VERIFY.md audit trail (fable-audit): every run logs its stage map, each check's exact command and output, what failed and how it was fixed, and what's still open. Logged as the work happens, never written up afterward. Hand it to a reviewer, a client, or your future self.
    • Ready-made checks (fable-checks): recipes for code (pytest, Jest, Vitest, Go, red-then-green, type checks, diff scope), data (nulls, duplicate keys, join fan-out, reconciliation), research (claim tracing, attribution, freshness), documents (docx, pdf, xlsx totals, pptx) and web (render, console errors, links, forms). Each one guards against a "0 failures" result from a run that checked nothing.
    • SKILL.md validator: checks every skill in a folder against the Agent Skills spec. 33 tests.

    The core loop (included)

    • Stage map before any work: numbered stages with expected outputs.
    • Parallel delegation to subagents where the runtime supports it.
    • Failable verification at every stage: a test that runs, a source actually fetched, a file read back.
    • Skeptical self-review, then the double-check gate: fresh checker agents verify the finished work against its claims.
    • Tier runners (fable-opus, fable-sonnet) and always-on execution-guardrails.

    How to use

    1. Install with ./install.sh (Claude Code), or upload each skill folder in the Claude app.
    2. Say /fable-mode-pro (or "fable mode pro") for the full Pro run. Say /fable-mode for the regular loop.
    3. Pro runs hand you the deliverable plus VERIFY.md.

    Free vs Pro

    The core loop is free on GitHub (mrtooher/fable-mode). Pro adds the fable-mode-pro command, fable-audit, fable-checks and the validator: the parts that turn "it says it checked" into a record you can read.

    Known limitations

    Doesn't raise the model's reasoning ceiling. Built and tested for Claude Code; parallel delegation and the checker panel need subagent support. At most two full replans per run, then it stops and asks you.

    Cannot lift a model's raw reasoning ceiling. Requires subagent/Agent tool support for parallel delegation. Spawning is restricted to explicit user triggers or specific slash commands.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Requires

    jest
    Node.js
    vitest
    tsc

    Permissions

    Terminal / Shell
    Write Files
    Read Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Fable Mode is designed for high-stakes, multi-file tasks where LLMs typically hallucinate or rush, such as complex refactoring or technical research requiring external verification. It replaces standard linear generation with a rigorous framework of staged planning, parallel subagent delegation, and mandatory failable checks.

    Fable Mode is a set of SKILL.md files built and tested for Claude Code, installed with the included install.sh. Any agent that loads the open SKILL.md standard can read the instructions. Parallel delegation and the double-check checker panel need a runtime with subagent support; without it, stages run inline and double-check runs in self-check mode. The verification panel uses Haiku and Sonnet checkers, with Opus only when they disagree.

    Unlike self-review, which often suffers from confirmation bias, failable verification requires the agent to produce a concrete, external artifact—like a passing test suite or a successful data fetch—before a stage is marked complete. If the external check fails, the agent is forced to troubleshoot rather than simply claiming the task is done.

    Eight skills: fable-mode-pro (the Pro command, with the audit trail and check recipes always on), the regular fable-mode loop, fable-opus and fable-sonnet (model-tier runners), execution-guardrails (always-on rules), double-check (the delivery gate), fable-audit (VERIFY.md audit trail) and fable-checks (check recipes for code, data, research, documents and web). Also a SKILL.md validator with 33 tests, README, EXAMPLE.md with worked examples, a benchmark write-up, and install.sh.

    It allows at most two full replans per run. If a third structural replan seems necessary, it stops and asks you to settle the ambiguity instead of looping. Splitting or renumbering a single stage does not count as a replan.

    The free version on GitHub (mrtooher/fable-mode) has the regular loop: stage map, failable checks, self-review and the double-check gate. Pro adds its own command, /fable-mode-pro, which runs that loop with two things always on: fable-audit writes a VERIFY.md record of every check run, every failure and fix, and every open item; fable-checks supplies a ready-made pass condition for each stage. Regular /fable-mode is included and still works on its own. Also includes the SKILL.md validator.

    New in Agents & Orchestration