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/).

From a clone, npm run install-skills does the same without the registry:

npm run install-skills              # into ~/.agents/skills, linked from ~/.claude/skills
npm run install-skills -- ../my-app # into a repo instead of the home directory
npm run install-skills -- --only write-spec,review ../my-app
npm run list-skills                 # names and categories

.agents/skills/<name>/ holds the real files (flat, category-free, with cross-category links rewritten to match); .claude/skills/<name> is a relative symlink into it, so both harnesses read one copy. Re-running overwrites the installed copies — a .claude/skills/<name> you keep as a real directory is left alone, and a .claude/skills that is already a symlink is left as is. Add --dry-run to see the plan first.

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 3d 18m on top of these skills, slicing and iterating until done.

How to use

Use a chained pipeline to build a feature, a research loop to discover what works, or individual skills as needed. Every skill stands alone.

The full loop — a big feature, start to finish

1. Map the fog. /explore-unknowns on the idea. It interviews you quadrant by quadrant and hands you rendered options, mocks, and decision tables to react to instead of asking you to imagine. By the end you know what the feature does.

2. Codify. /write-spec on that map. Most decisions were already made upstream, so this pass is transcription — I don't read the spec. Anything genuinely new it hits, it asks about instead of deciding.

3. Build. Kick off the loop:

   /goal /implement-spec specs/<feature>
   

   /goal is what puts the harness in loop mode — same move in Claude Code or Codex — and the spec drives it from there. A couple of hours for a small feature, two or three days for a large one. Add whatever framing fits: on the xyz branch, or using /codex as the implementer while you stay the parent orchestrator and reviewer.