Hot tip: use Fable-5 for planning and as the general orchestrator and reviewer, and Codex as the actual implementer so you don’t blow through all your fable credits in a day

I have a skill for this: https://github.com/dzhng/skills

It also contains my battletested skill to recursively plan and map out the lay of the land, very important to do this before you start any long loop runs.

Happy Fable day!

dzhng/skills

Source: https://github.com/dzhng/skills

Skills

AI skills for building software factories. My personal library of domain-agnostic agent skills, reused across every project. Small, composable, and hackable — works with any harness that supports skills: Claude Code, Codex, opencode, Cursor, duet, and 70+ others.

npx skills add dzhng/skills

Add --list to pick individual skills, or copy any skills/<category>/<name>/ folder into your harness’s skills directory (e.g. .claude/skills/).

Why

Software is moving from tasks to factories: agents that pursue a goal autonomously until the output can be trusted. The hard part isn’t breaking the goal into tasks — it’s breaking it into independently verifiable pieces, and knowing where the pieces even are.

These skills run that loop. Treat the unknown as fog of war: map the terrain, carve it into territories that build and verify in isolation, and recursively re-slice whatever hides more map. And re-planning doesn’t stop when planning ends — the spec is a living document, updated and re-sliced mid-implementation whenever the work teaches the agent that the plan is stale. Every piece must prove itself — architecture review, code review, and visual review against a baseline — before the loop moves on. Each iteration gets less wrong, until the goal is done.

Proof: one unattended Codex run pursuing a single goal for 1d 16h on top of these skills, slicing and iterating until done.

How to use

1. Plan. Ask your agent to /feature-slicing the goal. It interviews you, researches the unknowns, and materializes a spec under specs/<feature>/ — a slice graph where every slice is independently verifiable.

2. Build. Kick off the loop:

   /goal /implement-spec specs/<feature>
   

   Add whatever framing fits: on the xyz branch, or using /codex as the implementer while you stay the parent orchestrator and reviewer.

3. The rest fires on its own. The spec tells the loop when to call the other skills — /refactor-clean and a review pass at the end of every slice, /screenshot-critique and /compare-screenshots on anything visual, /close-spec when the last slice lands — and to update and re-slice the plan whenever implementation proves it stale. Every skill is also independently useful: invoke any of them manually whenever you want.

Skills

Engineering — slice, build, verify, repeat

Visual review — never accept visuals on vibes

Authoring — keep the skills themselves sharp

Graphics

License

MIT