Love this framing. A software factory shouldn’t require the human to review every line of code, but every decision should be backed by a human review. AI is the perfect execution machine but still imperfect decision makers. Added to my skill repo: https://github.com/dzhng/skills

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 /write-spec 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 — 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

Taelin (@VictorTaelin): I think I finally figured out how to use AI at scale

of course, the fact Fable is good is part of it. but I also changed how I work, and it all comes down to one key realization: you don’t need to audit the code, but you NEED to audit the choices it made. if you just do that,