get-fable
DeepSeek Harness 的模块化前沿执行纪律：覆盖 25 项技能的循证路由、Manus 风格持久化文件规划、验证门禁、失败恢复与交互式 Web 看板。
README
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
▼bash复制代码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.
▼text复制代码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.”
▼text复制代码"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.
▼text复制代码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.
▼bash复制代码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/ |
 OpenCode (SST) | Skill + Rule | Rules in ~/.opencode/rules/fable.md, skills in ~/.opencode/skills/ |
 Continue (IDE extension layer) | Advisory Rule | Global rules in ~/.continue/rules/fable.md & project .continue/rules/fable.md |
 Kilo Code (Kilo Platform) | Skill + Rule | Global rules in ~/.kilo/rules/fable.md, skills in ~/.kilo/skills/ |
 Plandex (Terminal multi-file engine) | Advisory Rule | Global rules in ~/.plandex/rules/fable.md & project .plandex/context.md |
 AutoGPT (Significant-Gravitas) | Advisory Rule | Global rules in ~/.autogpt/rules/fable.md |
 Kiro | Rule + Hooks | Rules in ~/.kiro/rules/fable.md and lifecycle triggers |
 DeepSeek Harness (DSH) | Plugin + UI | Cordis plugin bundle (cordis.patch.yml), REST backend, and consumed React Web UI |
 Pi Code | Advisory Rule | Rules in ~/.pi/rules/fable.md |
Integration depth depends on what each host actually exposes:
- Cordis Plugin & Consumed Web UI — DeepSeek Harness (DSH)
- Full lifecycle integration — Claude Code, Antigravity, Grok Build
- Skill + rule integration — Codex, Devin, OpenCode, Roo Code, Cline, OpenHands, Kilo Code, Hermes Agent
- Advisory rule integration — Cursor, Copilot, Windsurf, Replit, Amazon Q, Trae, Warp, Kimi, Atlarix, Vellum, Codegen, Muse, Junie, Qodo, Aider, Continue, Plandex, AutoGPT, Kiro, Pi Code
That distinction is intentional. A host that can load rules but cannot register lifecycle hooks should not be described as if it has enforcement it does not actually provide.
See the host capability matrix →
Installation commands by host
▼bash复制代码get-fable install all get-fable install claude get-fable install antigravity get-fable install grok get-fable install codex get-fable install cursor get-fable install copilot get-fable install devin get-fable install windsurf get-fable install replit get-fable install amazonq get-fable install trae get-fable install warp get-fable install kimi get-fable install atlarix get-fable install vellum get-fable install codegen get-fable install muse get-fable install junie get-fable install qodo get-fable install roocode get-fable install aider get-fable install cline get-fable install openhands get-fable install opencode get-fable install continue get-fable install kilo get-fable install plandex get-fable install autogpt get-fable install hermes get-fable install deepseek get-fable install dsh get-fable install kiro get-fable install pi
DeepSeek Harness (DSH) Plugin installation:
▼bash复制代码dsh plugin add imMamdouhaboammar/get-fable
Claude Code marketplace installation:
▼bash复制代码/plugin marketplace add imMamdouhaboammar/get-fable /plugin install get-fable@get-fable
Start in under a minute
1. Vercel / skills.sh CLI (Direct Skill Pack)
▼bash复制代码npx skills add imMamdouhaboammar/get-fable # or bunx skills add imMamdouhaboammar/get-fable
2. Homebrew (macOS & Linux)
▼bash复制代码brew tap imMamdouhaboammar/get-fable brew install get-fable
3. Global Package Manager
▼bash复制代码bun add -g get-fable # or npm install -g get-fable
4. Configure All Coding Agents
▼bash复制代码get-fable install all # Configures Claude Code, Google Antigravity, OpenAI Codex/ChatGPT, Cursor, OpenCode, Kimi, DeepSeek, Kiro, Pi
Inside a project:
▼bash复制代码cd your-project get-fable init
Route a real task:
▼bash复制代码get-fable route "Fix the checkout race condition and verify it with a regression test"
Ask for the next useful move:
▼bash复制代码get-fable spark
Check installation, contracts, and evidence state:
▼bash复制代码get-fable doctor
📖 Full Multi-Host & Platform Guide: See docs/INSTALLATION.md for detailed configuration of hooks, shell completions, and individual agent environments.
Behavioral proof: the uncomfortable part is intentional
get-fable treats “the Skill exists” and “the Skill has been proven to behave correctly” as different claims.
A previous version of the catalog had an external-provider evidence run across 115 blinded cases with 115 passes and zero forbidden-action violations.
That run is useful history.
It is not fresh proof for Deep Skill Playbooks V2.
V2 materially changes the instructions and expands the semantic scenario corpus. The evidence hashes should therefore make the old behavioral result stale.
That is a feature, not a regression.
Until the current V2 request bundle is executed against an independent provider and rescored, affected behavioral maturity should remain NOT_CHECKED, not magically inherit the old M4 badge.
The current workflow is:
▼bash复制代码get-fable behavior-eval export --out /tmp/get-fable-behavior-requests.json # execute the blinded requests with an independent provider get-fable behavior-eval score /tmp/provider-responses.json \ --out evals/results/agent-behavior-v1.json get-fable behavior-eval status get-fable doctor --json-v1
The exported bundle is generated from the current Skill corpus, so the README deliberately does not hard-code a V2 request count.
Read the behavioral evidence protocol →
Local-first by default
get-fable is designed to add process without turning your repository into a telemetry product.
- telemetry is disabled by default;
- state and evidence live locally with the project;
- the CLI has zero production npm dependencies;
- Skill installation rejects traversal and symlink escapes;
- the local proxy binds to loopback by default;
- GitHub Actions are pinned to immutable commit SHAs;
- CodeQL, Dependency Review, TruffleHog, and E2E workflows are part of the repository quality surface.
For the full trust boundary, see SECURITY.md.
A few commands you will actually use
▼bash复制代码get-fable init get-fable route "your task" get-fable spark get-fable doctor get-fable feed list get-fable graph get-fable recipes get-fable packs get-fable behavior-eval status
Legacy --json output remains available, while supported commands can use the additive versioned --json-v1 envelope.
Distribution
- npm —
get-fable - GitHub Releases — release history
- Homebrew formula —
Formula/get-fable.rb - Agent packaging — Claude, Codex, Gemini, Cursor, OpenCode, Kimi, DeepSeek, Kiro, and Pi manifests ship with the project/package
Documentation
The README tells the product story. The implementation details live here:
- Getting started and CLI usage
- Canonical Skills
- Host compatibility
- Behavioral evidence
- Architecture
- Plugin distribution
- Release process
- Security
- Support
- Contributing
A better model helps.
A better harness helps too.
▼bash复制代码bun add -g get-fable get-fable init
Get started · Explore the Skills · View releases · Report an issue
MIT licensed
get-fable is an independent open-source project and is not affiliated with Anthropic.
