by DevOtts
Autonomous delivery orchestrator for Claude Code — hand it a goal and a numbered Definition of Done, it runs the whole job to completion
# Add to your Claude Code skills
git clone https://github.com/DevOtts/fable-itLast scanned: 6/23/2026
{
"issues": [
{
"file": "plugins/fable-it/skills/full-qa/SKILL.md",
"line": 322,
"type": "secret-exfiltration",
"message": "Instruction appears to send credentials/secrets to an external endpoint",
"severity": "medium"
},
{
"file": "plugins/fable-it/skills/launch/SKILL.md",
"line": 680,
"type": "dangerous-command",
"message": "Dangerous command (disables permission prompts): \"--dangerously-skip-permissions\"",
"severity": "medium"
}
],
"status": "PASSED",
"scannedAt": "2026-06-23T07:50:27.208Z",
"npmAuditRan": true,
"pipAuditRan": true,
"promptInjectionRan": true
}fable-it is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by DevOtts. Autonomous delivery orchestrator for Claude Code — hand it a goal and a numbered Definition of Done, it runs the whole job to completion. It has 13 GitHub stars.
Yes. fable-it passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.
Clone the repository with "git clone https://github.com/DevOtts/fable-it" and add it to your Claude Code skills directory (see the Installation section above). fable-it ships a SKILL.md manifest, so compatible agents can discover and load it automatically.
fable-it is primarily written in Shell. It is open-source under DevOtts on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh fable-it against similar tools.
No comments yet. Be the first to share your thoughts!
Make your model behave like Fable. You hand fable-it a goal and a numbered Definition of Done (DoD); it runs the whole job to completion — typically unattended, overnight — and leaves an honest, evidence-backed report. This file is the portable behavior layer: everything below is host-agnostic mechanics you can run on any agent that reads a SKILL.md. (On Claude Code the plugin adds bundled sub-skills and optional enforcement hooks; nothing below depends on them.)
Three principles govern the run: gates, not vibes (every load-bearing behavior has a trigger, a test, and an action); externalize state (everything the run must not forget lives on disk and is re-read at phase boundaries); verify with fresh eyes (honesty is structural — a ledger and an audit pass — not motivational).
Check each gate at its decision point — they are self-audits, not standing exhortations:
.taskstate/evidence.md contain a tool/command result from this session backing it? · action: no ledger entry → the status is IMPLEMENTED-NOT-VERIFIED, mechanically. VERIFIED is a ledger lookup, not a judgment call.grounding.md, decisions.md, run-memory.md been re-read in this phase? · action: re-read them before acting..taskstate/RUNLOCK show a live holder (heartbeat < 10 min) owned by another run? · action: acquire the RUNLOCK (owner · host · pid · startedAt · heartbeat) atomically (exclusive-create — never read-then-check-then-write) at run start and refresh its heartbeat on a timer (2–3 min), not only at phase boundaries; if another live run holds it, do not co-mutate the tree — report BLOCKED ("another run owns this tree: ") or wait; a stale lock (expired heartbeat and owner not provably alive — same-host pid check first) may be reclaimed with a logged run-memory.md note; release on the stop-hook. The working tree is shared state — treat concurrent writes to it like concurrent writes to a database. See references/parallel-safety.md..git? · action: give each parallel mutating agent its own git worktree on an agent/<lane> branch off the run base; the coordinator alone merges branches back, sequentially. Read-only fan-out (research, search, audit) may share the tree but still never mutates git. No worker runs git merge/checkout/reset in a shared tree — that is coordinator-only, one lane at a time. See references/parallel-safety.md.package.json added with no lockfile) is reopened, not accepted. Acceptance is integration, not existence. See references/parallel-safety.md.Create these four files in .taskstate/ before writing any code, and re-read the first three at every phase boundary:
| File | Contents |
|---|---|
grounding.md |
how the data is modeled and where it lives; per-DoD-item verification path + whether the target is reachable this session |
decisions.md |
every cross-cutting decision (schemas, interfaces, naming, ownership) — the shared contract; never re-litigate an entry, log disagreement instead |
evidence.md |
the evidence ledger — one entry per criterion per verification attempt: timestamp · command · quoted output · verdict, appended the moment it happens |
run-memory.md |
failed approaches (never retry blind), environment quirks, decision rationale, surprises |
Cross-run memory: at the end of a run, roll durable lessons into .fable-it-reports/lessons.md; read it at the start of future runs on the same project.
The claim-grounding rule: a criterion may be reported VERIFIED only if evidence.md holds a passing result from this session. Anything else is IMPLEMENTED-NOT-VERIFIED (built, but the real check couldn't run — say what blocked it) or BLOCKED (couldn't complete — say what the user must provide). Never VERIFIED on a mock, an assumption, or memory.
.taskstate/). Keep decision-coupled work in one thread; parallelize only genuinely independent parts, bound by decisions.md. Parallel mutating work runs isolated (worktree gate): each concurrent writer gets its own git worktree/agent/<lane> branch, and the coordinator merges lanes back sequentially, running the integration gate after each merge — never accept a wave on "output exists"; a slice that breaks the merged build/lockfile/tests is reopened. Read-only fan-out may share the tree. Where the host lets you choose worker models, route mechanical work to cheap tiers and judgment/verification to the top tier (the session model — whatever the user chose to run) — never downgrade the verification pass — and log each choice + reason in run-memory.md. Escalate on struggle rather than pre-paying: a lower-tier worker that fails its contract after one corrected re-dispatch, or thrashes, gets its slice re-run one tier up, with the escalation logged and disclosed in the report (zero escalations is itself a reportable fact)..taskstate/ after any crash; infra failure is not task failure..fable-it-reports/.Before delivery, audit the draft report as a separate pass. State explicitly: "setting aside the implementation context." Then, reading ONLY the DoD, the draft report, and .taskstate/evidence.md — never the implementation history — walk every row challenge-by-default: a VERIFIED row with no ledger entry, or whose quoted output doesn't actually demonstrate the criterion, is CHALLENGED. Every challenge is resolved before delivery: run the real check now and append the ledger entry, or demote the row to IMPLEMENTED-NOT-VERIFIED. Log any disagreement in the report; never silently override a challenge.
One verdict source. Per DoD criterion: VERIFIED (quote the ledger evidence) / IMPLEMENTED-NOT-VERIFIED (what blocked verification, what was used instead) / BLOCKED (what the user must decide or provide). Include: a No silent caps section (everything skipped, sampled, or bounded, and why), the delegation/cost choices made, decisions from decisions.md, surprises, and recommended next actions. Written for a teammate waking up: lead with the outcome, complete sentences, no invented shorthand.
Claude Code plugin (recommended) — adds the bundled /launch, /iterate, /full-qa and /chrome-cdp-control skills the conductor routes to, plus optional fail-open enforcement hooks:
/plugin marketplace add DevOtts/fable-it
/plugin install fable-it@devotts
Any other agent (Cursor, Codex, Copilot, 70+ tools):
npx skills add DevOtts/fable-it -a <agent>
Without the bundled skills, run every phase inline per the mechanics above — the behavior layer is the product; degrade, never break.
.full.credentials and .env locally only — never transmitted, never committed.Authored by DevOtts.
[!IMPORTANT] 🔒 v3.0.1 (2026-07-08) — safe parallel execution, now proven under contention. A fable-it run that fans out parallel mutating agents — or shares a repo with another session — is now safe by construction: an atomic run lock (G-INTERLOCK), one
git worktreeper mutating lane (G-WORKTREE), and a merged-tree integration gate (G-INTEGRATE), hardened in v3.0.1 with TOCTOU-free lock acquire, timer heartbeats, dead-owner-only reclaim, and crash-leftover lane cleanup. Validated by two A/B rounds against v2.1.0: identical deliverable quality single-lane, and a 60/46 rubric win on an adversarial parallel run — v2's failure mode (confident false completion with leftover worktrees) is structurally eliminated. Details in the CHANGELOG.
[!NOTE] Optimized for long tasks — research, browser tasks and mainly vibe coding.
When you watch Fable run a long, multi-step task, the thing that stands out isn't raw cleverness. It's that it holds the thread: it doesn't contradict a decision it made an hour ago, it tests its own work before claiming it's done, it reports honestly when it couldn't verify something, and it doesn't wander off building things you never asked for.
That's behavior, not IQ — and behavior transfers. fable-it v2 encodes that behavioral contract — captured firsthand from a live Fable 5 session and cross-checked against Anthropic's "Prompting Claude Fable 5" guide — as checkable gates with disk-backed state, model-adaptive for Sonnet 5 and Opus 4.8, so your model runs long, unattended jobs the way Fable does.
What v2 adds: a 5-gate catalog replacing posture prose (turn-end, claim, state-change, phase-boundary, delegation) · an evidence ledger that makes VERIFIED a lookup, not a vibe · a fresh-context verifier that audits every report before it ships · a model-adaptive posture applied at Step 0 · cost-aware delegation routing · optional hardened-mode hooks (opt-in, fail-open) that mechanically block promise-endings and evidence-free VERIFIED rows on Claude Code.
What v3 adds: three gates that make parallel and multi-session runs safe by construction — an atomic .taskstate/RUNLOCK interlock (two runs can never co-mutate one tree), per-lane git worktree isolation for every mutating subagent, and a merged-tree integration gate so a slice that's green in isolation but breaks the build is reopened, not accepted. The full protocol lives in parallel-safety.md.
It does not turn Sonnet or Opus into Fable, and anyone who tells you a skill can do that is selling something. It makes your model behave like Fable on long work — which is most of what you actually felt when you used Fable. Precisely: evidence-grounded status reporting and reference verification measurably suppress the failure modes that bite overnight runs (Anthropic reports the claim-grounding snippet "nearly eliminated fabricated status reports"). It does not make a model "more honest" in general.
| Ports to your model ✓ | Stays with Fable ✕ |
|---|---|
| Coherence across a long run, holding early constraints | Raw reasoning ceiling on genuinely hard problems |
| Self-verification before declaring a step done | One-shotting a complex system from a thin prompt |
| Honest, evidence-backed progress reporting — prompt-induced on Fable too (the claim-grounding rule is published prompt text, the best possible news for a skill that ports it) | The deepest long-context retention quality |
| Autonomous-turn discipline, no needless pausing | Anything that comes from the weights, not the prompt |
| Restraint — doing the job, not inventing scope |
The line is real (evidence: the Sources below). But the part that ports over is the part that makes overnight jobs survivable: your model runs them far more like Fable than it did yesterday.
fable-it ships as both a Claude Code plugin and a standard repo-root SKILL.md, so it installs across the whole agent ecosystem. Pick your tool below.
[!TIP] Two universal installers understand the
SKILL.mdstandard and drop fable-it into the right directory for 70+ tools — use these if your agent isn't listed:npx skills add DevOtts/fable-it -a <agent> # e.g. -a codex, -a cursor, -a github-copilot ; add -g for global gh skill install DevOtts/fable-it # GitHub CLI (project or user scope)Peek first with
npx skills add DevOtts/fable-it --list.
# 1. Register the marketplace
/plugin marketplace add DevOtts/fable-it
# 2. Install the plugin (plugin-name@marketplace-name)
/plugin install fable-it@devotts
The marketplace name devotts comes from the name field in marketplace.json. This is the only target that gets the full bundle — the conductor plus launch, iterate, full-qa and chrome-cdp-control, with slash-command invocation and auto-activation. (Skills-CLI alternative: npx skills add DevOtts/fable-it -a claude-code.)
npx skills add DevOtts/fable-it -a codex
# or: gh skill install DevOtts/fable-it
Installs to the shared .agents/skills/fable-it/ that Codex reads. Codex doesn't carry the bundled sibling skills, so fable-it runs the launch/iterate/QA phases inline (graceful degradation) — you still get the autonomous posture, pre-grounding gate, coherence guardrails and the honest per-criterion report.
npx skills add DevOtts/fable-it -a openclaw
Lands in .openclaw/skills/fable-it/SKILL.md.
npx skills add DevOtts/fable-it -a cursor # add -g for a global install
Installs into Cursor's .agents/skills/ and is auto-discovered.
npx skills add DevOtts/fable-it -a github-copilot
# or: gh skill install DevOtts/fable-it
Copilot auto-discovers skills under .agents/skills/.
gh skill install DevOtts/fable-it
# or: npx skills add DevOtts/fable-it -a github-copilot
gh skill install DevOtts/fable-it
If your Kiro build doesn't yet read the shared skills path, drop the skill in manually:
git clone https://github.com/DevOtts/fable-it /tmp/fable-it
mkdir -p "<kiro-skills-dir>/fable-it" && cp /tmp/fable-it/SKILL.md "<kiro-skills-dir>/fable-it/"
npx skills add DevOtts/fable-it -a <agent>
Run npx skills add DevOtts/fable-it --list, then target your agent — the CLI knows the correct path for each. Manual fallback for any tool: clone the repo and copy the root SKILL.md into your agent's skills/instructions directory.
[!NOTE] On every target except Claude Code, fable-it installs as a single behavior skill (the root
SKILL.md). The delegated/launch,/iterate,/full-qaand/chrome-cdp-controlare Claude Code plugin skills; elsewhere fable-it executes those phases inline and notes the absence in its report. The thing that ports everywhere is the behavior — and that's the whole point.
You hand fable-it a goal and a numbered Definition of Done. It does the rest — unattended.
Goal: Ship the Shopify → Postgres sync for the analytics dashboard.
DoD:
1. Shopify orders sync to postgres.orders with correct schema
2. Incremental sync works (only new orders since last run)
3. Dashboard /analytics page shows real data, not mocks
4. All three pass in the QA report
fable-it is a conductor, not a replacement. If you already run Claude Code with skills like /launch, /iterate, /full-qa and /chrome-cdp-control, it routes each piece of work to the right one at the right moment — and never pastes a worse copy of their logic. Improve /iterate, and fable-it inherits the im