/fable-it

Make Opus behave like Fable

Hand Claude a goal and a numbered Definition of Done.
Go to sleep. Wake up to an honest report.

Behavior transfers. That's what makes overnight jobs survivable.

Install  ·  The honest claim  ·  How it works  ·  What's bundled  ·  The report

[!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 packs those behaviors into a single Claude Code skill, so Opus runs long, unattended jobs the way Fable does.

The honest claim

It does not turn Opus into Fable, and anyone who tells you a skill can do that is selling something. It makes Opus behave like Fable on long work — which is most of what you actually felt when you used Fable.

The line is real. But the part that ports over is the part that makes overnight jobs survivable: your Opus runs them far more like Fable than it did yesterday.

Install

# 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.

Alternatively, install via the skills CLI:

npx skills add DevOtts/fable-it

How it works

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 improvement.

On top of routing, it enforces the layer that otherwise gets hand-written into every overnight prompt:

• Autonomous posture — keeps moving instead of stopping to ask permission, clamped by two counter-rules: don't fake confidence, don't gold-plate. Irreversible actions still need prior authorization.
• Pre-grounding gate — reads the real source of truth (the actual schema, the real endpoint) before writing a line of code, so hour-3 work doesn't drift from hour-1 reality.
• Three coherence guardrails that stop long, parallel runs from quietly falling out of sync:
  1. Shared decision contract — parallel agents read and write one shared file for every cross-cutting decision, so a renderer is never built for schema A while a connector saves schema B.
  2. Cross-session interface file — when this run assumes work another session is still building, it writes the contract both sides agree on instead of guessing.
  3. Honest per-criterion status — every DoD item gets a state with evidence: VERIFIED, IMPLEMENTED-NOT-VERIFIED, or BLOCKED. No green result is ever reported off a mock or an assumption.

The coherence problem on long jobs isn't raw capability — it's decisions made in hour 1 contradicting work done in hour 3. The guardrails exist for exactly that.

Use

You don't have to type a command — the skill auto-activates when you describe a goal-to-DoD delivery:

"work autonomously until done" · "I'm going to bed, finish this" · "run to DoD" · "green light, take decisions" · or a goal followed by numbered acceptance criteria.

To invoke it explicitly (plugin skills are namespaced by the plugin name):

/fable-it:fable-it Build the Shopify multi-store connector.
  DoD:
  1. Backfill shows all records in connector-logs
  2. Pooling enabled in UI, records appear in logs
  3. New interactions visible on the timeline page
  4. ShopifyRenderer shows details for a clicked item

Only two things are required: the goal and a numbered DoD. Everything else has a sensible default — credentials, tooling inferred from the DoD, parallelism, report location. It's built to run unattended: a long silence means it's working, not stuck.

What's bundled

Because the skills it delegates to ship inside the plugin, there are no missing dependencies. And if a delegated skill is absent in some environment, fable-it degrades gracefully — it runs that phase inline and notes the absence in its report, rather than failing.

What the report looks like

# Fable-it Report — Shopify → Postgres analytics sync
Run window: 02:14 → 05:47  |  Approach: single session

## DoD status
| # | Criterion                          | Status                    | Evidence              |
|---|------------------------------------|---------------------------|-----------------------|
| 1 | Orders sync with correct schema    | VERIFIED                  | 1,847 rows, schema ✓  |
| 2 | Incremental sync works             | VERIFIED                  | delta query confirmed |
| 3 | Dashboard shows real data          | IMPLEMENTED-NOT-VERIFIED  | service was down      |
| 4 | All three pass in QA report        | BLOCKED                   | depends on #3         |

## Recommended next actions
- Restart the dashboard service and re-run /full-qa for criterion 3

VERIFIED means real data, a real endpoint, real evidence — never a mock dressed up as a pass.

Status

Honest, like the skill itself: this has been tabletop-tested against real prompts, not yet hammered end-to-end in every environment. Validate the plugin locally before relying on it:

claude plugin validate ./plugins/fable-it
claude plugin validate .

Security considerations

• No secrets are required to install or run the skill. You supply credentials only for the specific job you ask it to do.
• It reads .full.credentials and .env locally only — these are never transmitted anywhere and are not committed.
• Browser automation uses your own Chrome via the Chrome DevTools Protocol (CDP) on a local port, reusing your existing logged-in session. fable-it does not store or exfiltrate your cookies or session.
• Any credential created during a run (e.g. an admin token, a registry login) is isolated in a dedicated credentials artifact with rotation notes — never buried inside the prose report.
• Irreversible actions (dropping tables, force-push, destructive migrations on shared/prod state) always require explicit prior authorization; autonomy covers reversible work only.

License

MIT — see LICENSE and plugin.json. Use it, fork it, ship with it.

Thank you for contribution:

• andre2654
• mBidarra
• her0 Studio

Built by DevOtts.