fableplan

fableplan is a Claude Code skill I built to fix a specific, recurring waste in how I use agentic coding tools: paying premium-model prices for premium-model tokens, most of which are spent on work that doesn't need premium reasoning at all.

The split

Every coding task really has two different jobs in it. There's the planning job — reading the real codebase, figuring out what actually needs to change, ordering the steps, catching the edge case that breaks the naive approach before a single line is written. And there's the building job — executing that plan: editing files, following existing conventions, wiring things together, running tests, iterating.

Those two jobs have almost opposite cost profiles. Planning is low-volume and high-stakes — a bad plan compounds into every line built on top of it, so it's worth spending your best reasoning there. Building is high-volume and comparatively low-stakes per token — most of it is mechanical, and a strong general-purpose model executing a good plan rarely needs the top reasoning tier to get it right.

Most agentic workflows don't make that split. They run one model, at one cost, for both jobs — which means either you're overpaying for the boring 90% (building), or underpaying for the 10% that actually determines whether the feature is correct (planning).

Why Fable 5 for planning

Fable 5 is the model in fableplan's planning seat, dispatched as a dedicated subagent regardless of what model is running your main session. For planning specifically — reading a real codebase, surfacing the non-obvious constraint, producing a concrete and correctly ordered implementation plan — it's the best reasoning I've thrown at the job. That's exactly the kind of work where paying for the top tier is worth it: it happens once per task, and its output is the thing everything else depends on.

It's also exactly the kind of work where that cost is easy to justify, because the volume is small. One plan, reviewed once, before any code exists.

Why not Fable 5 for building

Running that same model through an entire build — every file edit, every test run, every back-and-forth fix — is a different story. Building is high-token-volume by nature, and once the planning is done, most of what's left is disciplined execution, not novel reasoning. Paying top-tier prices for that volume doesn't buy you much the plan hasn't already bought you, and it shows up directly in cost and latency across a long build.

The handoff

This is why fableplan builds from the vetted plan using your main session's model — Opus or Sonnet, whatever you're already running — instead of staying on Fable 5 for the whole task. Once the ambiguity is gone and the plan is checked against the real codebase, the remaining risk is execution fidelity: does the model follow the plan, match conventions, and not silently drop a step. Opus and Sonnet are good enough at that job, most of the time, to make finishing the build on the cheaper, faster model the correct call rather than a compromise.

The plan is also where a human — or a GitHub issue — gets a cheap checkpoint. It's a lot easier to catch a structurally wrong approach by reading a plan than by reviewing a finished diff.

How it works

Trigger it with /fableplan, "fableplan this," or "plan this with fable," plus a task description and optionally a GitHub issue.

1. Resolves the referenced GitHub issue, if any, so planning works from the real requirements.
2. Dispatches the Fable 5 Plan subagent, confirms it made no edits, and saves the plan verbatim.
3. Sanity-checks the plan against the actual codebase — files, symbols, conventions — and stops to ask if it's structurally wrong rather than silently re-planning.
4. Posts the vetted plan to the GitHub issue as a comment, if one was referenced.
5. Presents the plan for review.
6. Sets up an isolated git worktree so the build never touches the current workspace.
7. Builds the task from the plan, inside that worktree, on the main session's model.

Install

The repo is a Claude Code plugin marketplace. Inside any Claude Code session, add the marketplace and install the plugin:

/plugin marketplace add richkuo/fableplan
/plugin install fableplan@fableplan

Prefer npm? It's published as @fableplan/fableplan — one command copies the skill into ~/.claude/skills/:

npx @fableplan/fableplan

Add --project to install into the current repo's .claude/skills/ instead. The skill is picked up automatically either way, and plugin-marketplace installs also get updates through the plugin system. Prefer a single-file install, the npx skills CLI, or a copy-paste prompt that lets Claude Code install it for you? All the alternatives are in the repo README. Restart your session and invoke it with /fableplan.