get-fable

What if the coding agent you already use could work more like Claude Fable?

Same model. Better working habits. A much stronger coding loop.

25 connected Skills · routing · research · planning · TDD · verification · review · recovery · DSH plugin · release

bun add -g get-fable

Start here · How it works · The Skills · Docs

---

I kept coming back to one question

What if you could take the coding agent you already have — Codex, Claude Code, Gemini, OpenCode, Cursor, a local model, a cheaper model, whatever you happen to use — and make it work more like a serious coding partner?

Not by swapping the model.

Not by writing one giant system prompt and hoping it still matters forty minutes later.

But by changing what happens around the model.

That question is where get-fable started.

Because when people talk about a great coding agent, they usually talk about the model first. And obviously the model matters. A lot.

But the model is not the whole experience.

A strong coding partner also knows when to inspect before touching anything. When to stop guessing and check the current docs. When a bug needs a failing test before a fix. When a task is large enough to plan. When two workers can genuinely work in parallel — and when they absolutely should not. When a green test is stale because the code changed afterward. When three failed attempts mean rethink the diagnosis, not try a fourth variation of the same patch.

That behavior is not just raw intelligence.

A lot of it is the harness.

get-fable is an attempt to bring that harness to almost any coding agent.

The goal is deliberately ambitious: take the agent you already use and push its working behavior closer to the discipline you expect from a top-tier coding partner.

No, it does not magically turn a small local model into Claude Fable.

But it can give that model a better way to approach real software work.

And when the model underneath is already strong, the harness has more to work with.

---

The model is only part of the agent

Two agents can use completely different models and still make the same mistakes.

They can both start editing too early.

They can both lose the original plan halfway through a long task.

They can both rely on stale knowledge about an API.

They can both patch a bug without proving the bug first.

They can both run tests, change five more files, and still treat the old test run as proof.

They can both split work across subagents because the files look different while the workers are quietly changing the same contract.

They can both keep retrying an approach that clearly is not working.

And they can both end with the most dangerous sentence in agentic coding:

“Done.”

get-fable works on that part of the problem.

It does not replace the model.

It surrounds it with a way of working.

YOUR CODING AGENT
       +
GET-FABLE HARNESS
       ↓
DISCOVER
RESEARCH
PLAN
TEST
DELEGATE
EXECUTE
VERIFY
REVIEW
SECURITY
RECOVER
RELEASE
       ↓
A MORE DISCIPLINED CODING LOOP

---

So what does get-fable actually do?

It gives the agent 25 connected specialist Skills and a lifecycle that decides when each one should take over.

A normal bug request should not immediately mean “edit production code.”

"Fix the token refresh race condition"

        ↓

Where does the behavior actually live?
        ↓
Can we reproduce it reliably?
        ↓
What test level crosses the real failure boundary?
        ↓
Did RED fail for the right reason?
        ↓
Make the smallest production change
        ↓
Fresh GREEN
        ↓
Probe adjacent race/error paths
        ↓
Verify the current mutation
        ↓
Review the actual diff

A release request follows a different route.

An unfamiliar SDK should trigger current primary-source research before implementation.

A repeated failure should stop mutation and enter diagnosis.

A security-sensitive change should be traced through trust boundaries, not waved through because a scanner came back clean.

The workflow follows the work.

---

This is not a prompt pack

This distinction matters.

A prompt can say:

verify your work

get-fable can track that the repository changed after verification and treat the old evidence as stale.

A prompt can say:

use TDD

fable-tdd now distinguishes a valid RED from a syntax error, a broken fixture, a stale artifact, a false-green mock, or a concurrency test that only passes because it slept long enough.

A prompt can say:

use subagents

fable-delegate asks whether the work is independent at the semantic level, not just whether two workers touch different files.

A prompt can say:

debug carefully

fable-recover freezes blind mutation, builds a ranked hypothesis queue, chooses discriminating probes, falsifies bad theories, and only then issues one bounded repair.

A prompt can say:

make sure the release works

fable-release separates source correctness from the artifact users actually install, then distinguishes READY_NOT_PUBLISHED, PUBLISHED_UNVERIFIED, and genuinely RELEASED.

That is the direction of the project: not more instructions, but more operational judgment around the instructions.

---

Deep Skill Playbooks V2

Every canonical Skill carries complete operational knowledge and architecture discipline:

• Activation boundaries: Exact criteria for when to activate, refuse, or defer;
• Situational classification: Taxonomy and decision branches for ambiguous cases before acting;
• Staged execution: Verifiable, step-by-step evidence protocol with red/green gates;
• Architectural invariants: Non-negotiable constraints that must remain true;
• Failure handling: Actionable taxonomy that changes the next action upon error;
• Anti-pattern guards: Explicit enumeration of tempting anti-patterns to avoid;
• Structured artifacts: Machine-verifiable receipts, templates, and state handoffs;
• Progressive references: Substantial deep-dive guides (>1,000 to >3,000 bytes) for complex scenarios;
• Behavioral evals: Comprehensive 10-scenario evaluation benchmarks per skill.

The hard-earned engineering reasoning lives directly in the Skill — providing reliable, deterministic execution across all model tiers.

---

25 Skills. One way of working.

Understand the work

get-fable — choose the next specialist from intent + durable state, with precedence for failure, security, stale proof, and unknowns.

fable-discover — trace real repository/runtime execution paths instead of guessing from filenames and imports.

fable-research — resolve current external facts against version-appropriate primary sources.

fable-plan — turn evidence into dependency-aware, risk-aware, falsifiable work cards.

Build the change

fable-tdd — prove the behavior gap through the right test boundary before production mutation.

fable-delegate — parallelize only when write, semantic, and verification independence are real.

fable-execute — implement one bounded card while protecting scope, source-of-truth, and user work.

fable-simplify — reduce complexity without quietly changing behavior.

Prove it

fable-verify — build a claim → failure mode → evidence matrix and try to falsify the implementation.

fable-review — inspect the actual diff for concrete failure scenarios instead of style-comment theater.

fable-security — trace attacker-controlled input across trust boundaries and validate findings skeptically.

fable-simulator — compare against an independent oracle without confusing simulation with production proof.

fable-eval — measure changes to agent behavior without benchmark overfitting or oracle leakage.

Keep long sessions sane

fable-recover — stop blind retries and rebuild causal confidence after repeated failure.

fable-spark — suggest the smallest useful next move — or stay silent when another suggestion would just be noise.

fable-memory — preserve durable facts with scope, provenance, supersession, and secret-safe rules.

fable-handoff — create a real resumability contract for another agent/session.

fable-cowork — execute long scoped work autonomously without throwing away lifecycle gates or authorization boundaries.

fable-loop — poll changing conditions with explicit state machines, budgets, backoff, and honest stop reasons.

Work with the environment

fable-run — launch the exact runtime artifact and separate spawn, readiness, feature proof, and cleanup.

fable-config — change harness settings with precedence, least privilege, host-capability honesty, and behavioral verification.

Build evidence people can use

fable-dataviz — choose truthful visual encodings, preserve metric semantics, and audit for misleading scales/transformations.

fable-artifact — produce source-grounded documents and diagrams that survive outside the conversation.

Extend the harness

skill-creator — author new Skills to the same V2 standard instead of cloning shallow templates.

Explore the canonical Skill catalog →

---

Fable Spark: sometimes the best next move is tiny

During a long coding session, the agent usually does not need another page of advice.

It needs one useful move.

reproduce the bug
check the exact installed SDK version
write the failing contract test
compare source and built entrypoints
review the current diff
rerun evidence after the last mutation
stop retrying and diagnose

Or nothing.

Spark is explicitly allowed to stay silent when the current specialist already owns an obvious next step.

get-fable spark

---

Works with the coding agent you already use

get-fable is portable across 30 AI coding agents, platforms, and IDEs rather than being tied to one model or editor.

Proprietary & Commercial Markets

Agent / Tool	Integration Tier	Key Capabilities

Claude Code (Anthropic) | Full Lifecycle | 5 Python hooks (settings.json), 25 canonical skills, rules in CLAUDE.md, Marketplace plugin | |

Gemini CLI / Google Antigravity (Google) | Full Lifecycle | hooks.json lifecycle triggers, plugin manifest, canonical skills, constitution rules | |

Grok Build (xAI) | Full Lifecycle | hooks.json lifecycle triggers, Grok plugin manifest, canonical skills, constitution rules | |

OpenAI Codex & ChatGPT (OpenAI) | Skill + Rule + Plugin | .codex-plugin/plugin.json, ChatGPT OpenAPI Custom Actions, skills in ~/.codex/skills/ | |

Cursor (Anysphere) | Advisory Rule + Plugin | .cursor/rules/fable-lifecycle.mdc, .cursor-plugin/marketplace.json | |

GitHub Copilot Agent Mode (GitHub / Microsoft) | Advisory Rule | Global rules in ~/.copilot/rules/fable.md & project .github/copilot-instructions.md | |

Devin (Cognition) | Skill + Rule | Global ~/.devin/instructions.md, rules, and canonical skills in ~/.devin/skills/ | |

Windsurf (Codeium) | Advisory Rule | Global rules in ~/.codeium/windsurf/rules.md & project .windsurfrules | |

Replit Agent (Replit) | Advisory Rule | Global rules in ~/.replit/rules/fable.md & project .replit.md | |

Amazon Q Dev (Amazon Web Services) | Advisory Rule | Global rules in ~/.aws/amazon-q/rules/fable.md & project .amazonq/rules.md | |

Trae (ByteDance) | Advisory Rule | Global rules in ~/.trae/rules/fable.md & project .trae/rules/fable.md | |

Warp AI (Warp Terminal) | Advisory Rule | Global rules in ~/.warp/rules/fable.md | |

Kimi K3 (Moonshot AI) | Advisory Rule | Rules in ~/.kimi/rules/fable.md | |

Atlarix (Atlarix Desktop Copilot) | Advisory Rule | Rules in ~/.atlarix/rules/fable.md | |

Vellum (Vellum Workflow Platform) | Advisory Rule | Rules in ~/.vellum/rules/fable.md | |

Codegen (Codegen Platforms) | Advisory Rule | Rules in ~/.codegen/rules/fable.md | |

Muse Code (Muse) | Advisory Rule | Rules in ~/.muse/rules/fable.md | |

Junie (JetBrains) | Advisory Rule | Global rules in ~/.junie/rules/fable.md & project .junie/rules/fable.md | |

Qodo (Formerly CodiumAI) | Advisory Rule | Global rules in ~/.qodo/rules/fable.md & project .qodo/rules/fable.md | |

Roo Code | Skill + Rule | Global rules ~/.roo/rules/fable.md, skills in ~/.roo/skills/, and project .roomodes |

Open-Source & Community Markets

Agent / Tool	Integration Tier	Key Capabilities

Aider (Git-first CLI agent) | Advisory Rule | Global rules in ~/.aider/rules/fable.md & project .aider.prompt.md | |

Cline (Autonomous BYOK Agent) | Skill + Rule | Global rules in ~/.cline/rules/fable.md, skills in ~/.cline/skills/, and .clinerules | |

OpenHands (Formerly OpenDevin) | Skill + Rule | Global microagents in ~/.openhands/microagents/, skills in `~/.openhands/skills/