Skip to content
Back to search

skills

SkillWorks with Claude CodeGitHub

Reusable AI agent skills for software factories: explore ideas, write specs, implement, review, and run autonomous research. Works with Claude Code, Codex, and other skill-compatible agents.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/dzhng/skills with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/dzhng/skills'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/dzhng-skills/badge.svg)](/listings/dzhng-skills)

HTML

<a href="/listings/dzhng-skills"><img src="/api/listings/dzhng-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 240 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Skills
  2. [![skills.sh](https://skills.sh/b/dzhng/skills)](https://skills.sh/dzhng/skills)
  3. ![AI skills for growing software farms](assets/hero.jpg)
  4. **AI skills for growing software farms.** My personal library of
  5. domain-agnostic agent skills, reused across every project. Small, composable,
  6. and hackable — works with any harness that supports skills: Claude Code, Codex,
  7. opencode, Cursor, [duet](https://duet.so), and
  8. [70+ others](https://github.com/vercel-labs/skills).
  9. ```bash
  10. npx skills add dzhng/skills
  11. ```
  12. Add `--list` to pick individual skills, or copy any `skills/<category>/<name>/`
  13. folder into your harness's skills directory (e.g. `.claude/skills/`).
  14. From a clone, `npm run install-skills` does the same without the registry:
  15. ```bash
  16. npm run install-skills # into ~/.agents/skills, linked from ~/.claude/skills
  17. npm run install-skills -- ../my-app # into a repo instead of the home directory
  18. npm run install-skills -- --only write-spec,review ../my-app
  19. npm run list-skills # names and categories
  20. ```
  21. `.agents/skills/<name>/` holds the real files (flat, category-free, with
  22. cross-category links rewritten to match); `.claude/skills/<name>` is a relative
  23. symlink into it, so both harnesses read one copy. Re-running overwrites the
  24. installed copies — a `.claude/skills/<name>` you keep as a real directory is
  25. left alone, and a `.claude/skills` that is already a symlink is left as is. Add
  26. `--dry-run` to see the plan first.
  27. ## Why
  28. Software is moving from tasks to **farms**: agents that keep growing toward a
  29. goal on their own, for hours or days, until the harvest can be trusted. A
  30. factory stamps out exactly what it was built to make. A farm *grows* — and what
  31. grows is never exactly what you planted. Agents write more code than anyone can
  32. read, and some of it is weeds: decisions nobody made on purpose, protection for
  33. edge cases of edge cases, abstractions that sprawled while no one was looking.
  34. So the human's job moves from building to **curation**: choose what to plant,
  35. then pull the weeds, prune the overgrowth, and keep what's good.
  36. ![Your job is curation — sort what grew into weeds, overgrowth, and what to keep](assets/curation.jpg)
  37. These skills run the whole season. **Planting** treats the unknown as fog of
  38. war: survey the land, lay it out in plots that grow and verify in isolation,
  39. and re-plot whatever hides more ground. The plan stays alive — the spec is
  40. re-sliced mid-growth whenever the work proves it stale. **Tending** is
  41. unattended: every plot proves itself — architecture review, code review, visual
  42. review against a baseline — before the loop moves on. **Curating** is yours:
  43. the run hands you a ledger of every decision it made where the spec was silent,
  44. least-confident first, and a set of hunters finds the overgrowth AI-written code
  45. piles up. Each season the farm gets *less wrong*.
  46. ![A single autonomous run — 3 days, 18 minutes pursuing one goal](assets/autonomous-run.png)
  47. > Proof: one unattended Codex run growing a single goal for **3d 18m** on top
  48. > of these skills, slicing and iterating until done.
  49. ## How to use
  50. Run a full season to grow a feature, a research loop to discover what works,
  51. or reach for individual tools as needed. Every skill stands alone.
  52. ### The full loop — one feature, seed to harvest
  53. ![The full loop — survey the land, lay out the plots, let it grow unattended, then weed and prune the decisions](assets/full-loop.png)
  54. 1. **Survey the land.** `/explore-unknowns` on the idea. It interviews you quadrant
  55. by quadrant and hands you rendered options, mocks, and decision tables to
  56. react to instead of asking you to imagine. By the end you know what to
  57. plant.
  58. 2. **Lay out the plots.** `/write-spec` on that map. Most decisions were already made
  59. upstream, so this pass is transcription into plots that grow and verify on their own — I
  60. don't read the spec. Anything
  61. genuinely new it hits, it asks about instead of deciding.
  62. 3. **Let it grow.** Kick off the loop:
  63. ```
  64. /goal /implement-spec specs/<feature>
  65. ```
  66. `/goal` is what puts the harness in loop mode — same move in Claude Code or
  67. Codex — and the spec drives it from there. A couple of hours for a small
  68. feature, two or three days for a large one. Add whatever framing fits: `on
  69. the xyz branch`, or `using /codex as the implementer while you stay the
  70. parent orchestrator and reviewer`.
  71. 4. **Weed and prune — the decisions, not the diff.** The run ends by
  72. consolidating `specs/<feature>/decisions.md` — every decision the agent made
  73. where the spec was silent, ranked least-confident first. That's the curation
  74. surface. Pull the decisions you don't want, cut back what sprawled, and send
  75. it back; the next pass regrows and re-audits. Every time the AI writes code,
  76. you curate what it decided.
  77. The rest fires on its own: a `/review` pass at the end of every slice,
  78. `/screenshot-critique` and `/compare-screenshots` on anything visual,
  79. `/close-spec` when the last slice lands, and a re-slice of the plan whenever
  80. implementation proves it stale.
  81. Budget: 30 minutes to a few hours on steps 1–2, 30 minutes to a few hours on
  82. step 4. A run that goes two days is more like 2–3 hours on each end. Your time
  83. is in the bookends — planting and curating; the middle grows on its own.
  84. ### Research — learn through fast experiments
  85. Use [Auto Research](skills/plan/auto-research/SKILL.md) when the next
  86. decision needs experimental evidence. It starts with one fast, revealing task,
  87. tests a short batch of hypotheses, checks combinations, and expands coverage as
  88. the approach improves. New failures become the focus; earlier tasks become
  89. regression checks.
  90. ```
  91. /auto-research Reduce cost per task by at least 15% relative to the saved
  92. baseline, without reducing task success. Start with one fast development task.
  93. ```
  94. If the evaluator, metric, baseline, or required improvement is unclear, the
  95. skill asks before experimenting. Passing an evaluation and meeting an
  96. improvement target are separate requirements. The output includes the best
  97. verified artifact and a **parameter-effect map**: what was tested, where it
  98. helps or hurts, and how changes interact. Use that evidence to inform a spec
  99. when the research is ready for implementation.
  100. ### À la carte — the spontaneous path
  101. - **A brainstorm turns out to be a feature.** `/explore-unknowns` works at the
  102. end of a discussion as well as at the start — run it to sweep for the angles
  103. neither of you thought of, then pick the loop up at step 2.
  104. - **Any code change that didn't come from a spec.** An ad hoc fix that touched
  105. more than expected: `/review` first (refactor-change → code-review →
  106. write-docs), then `/audit-decisions`. When the diff is too big to read, the
  107. decisions ledger is how you still understand what is now in your codebase.
  108. - **A codebase that grew wild.** `/refactor-codebase` is a weeding season for
  109. the whole plot: it lists every hidden link, needless link, surplus piece, and
  110. special case, then redesigns from the list. For a narrower cut,
  111. `/find-overengineering` pulls protection nobody needs, `/audit-tests` prunes
  112. tests that don't earn their keep, and `/ratchet-files` keeps any one file
  113. from overgrowing.
  114. ## Skills
  115. ### Plan — survey the land, then lay out the plots
  116. | Skill | What it does |
  117. |---|---|
  118. | [explore-unknowns](skills/plan/explore-unknowns/SKILL.md) | Walk the user through mapping a task's unknowns quadrant by quadrant — known knowns first, then interviews, reactable artifacts, and blindspot passes — ending with a complete four-quadrant map. |
  119. | [auto-research](skills/plan/auto-research/SKILL.md) | Optimize through fast, progressive experiments, producing a verified candidate and a map of parameter effects and tradeoffs. |
  120. | [write-spec](skills/plan/write-spec/SKILL.md) | Break a large feature into independently verifiable, human-reviewable slices with API seams and playable checkpoints. |
  121. ### Implement — grow every plot to harvest
  122. | Skill | What it does |
  123. |---|---|
  124. | [implement-spec](skills/implement/implement-spec/SKILL.md) | Build an existing spec to completion, one reviewable pass at a time, delegating independent slices in parallel. |
  125. | [implement-spec-with-goal](skills/implement/implement-spec-with-goal/SKILL.md) | Use the harness's goal feature, then follow implement-spec to completion. |
  126. | [implement-spec-with-codex](skills/implement/implement-spec-with-codex/SKILL.md) | Run implement-spec with Codex writing the code — you orchestrate, integrate, and review every pass. |
  127. | [handoff-spec](skills/implement/handoff-spec/SKILL.md) | Hand a spec that is mid-implementation to another machine or agent: capture what the session knows in the spec, then push. User-invoked. |
  128. | [close-spec](skills/implement/close-spec/SKILL.md) | Archive a shipped spec and rewrite it from a build plan into a durable rationale record that points back at the code. |
  129. | [port-features](skills/implement/port-features/SKILL.md) | Port a feature by copying its exact upstream code and editing the copy instead of rewriting it, with git history explaining each odd line before it changes. |
  130. | [write-tests](skills/implement/write-tests/SKILL.md) | Write tests one tracer bullet at a time that pin real behavior — not implementation details, config values, or lucky samples. |
  131. | [write-docs](skills/implement/write-docs/SKILL.md) | Write docs as a glossary of principles and pointers, never a mirror of the code that will rot. |
  132. | [codex](skills/implement/codex/SKILL.md) | Use the local Codex CLI as an independent second agent for review and (on explicit ask) delegated implementation. |
  133. | [claude](skills/implement/claude/SKILL.md) | Use Claude Code (`claude -p`) as an independent second agent for consultation and (on explicit ask) delegated implementation. |
  134. | [marketing-pages](skills/implement/marketing-pages/SKILL.md) | Rulebook for writing, updating, and auditing marketing pages by page class — campaign landers stay noindexed and unlinked with one CTA; everything else earns its sitemap entry, crawl-rail link, and canonical copy source. |
  135. ### Review — weed, prune, and keep what's good
  136. | Skill | What it does |
  137. |---|---|
  138. | [review](skills/review/review/SKILL.md) | Closeout a finished change as one pass — refactor-change, then code-review, then write-docs — sequenced into a single verdict. |
  139. | [code-review](skills/review/code-review/SKILL.md) | Audit a diff for stale names, dead references, needless complexity, and comments that narrate instead of explain — ending on a clean/not-clean verdict. |
  140. | [audit-decisions](skills/review/audit-decisions/SKILL.md) | Audit the decisions an implementer made, not its diff — a pure, never-blocking audit whose ledger discloses the architecture settled on the user's behalf, reviewed instead of the code. |
  141. | [eli5](skills/review/eli5/SKILL.md) | Explain a spec or change in plain language without losing precision — the ELI5 register other skills borrow for standalone, walked-scenario explanations. |
  142. | [audit-tests](skills/review/audit-tests/SKILL.md) | Map contracts to independent test proof, consolidate redundant coverage, and remove test-only machinery without losing regression protection. |
  143. | [audit-performance](skills/review/audit-performance/SKILL.md) | Find hot paths that amplify or repeat without progress, rank them by real failure risk, and prefer the smallest bounded fix that preserves healing. |
  144. | [refactor-change](skills/review/refactor-change/SKILL.md) | Refactor by moving ownership to one clean concept instead of layering compatibility sediment beside the problem. |
  145. | [refactor-codebase](skills/review/refactor-codebase/SKILL.md) | Refactor a whole codebase as one goal run, tuned for the layered debt AI-written code piles up: list every hidden link, needless link, surplus piece, and special case (with find-state-machines, find-overengineering, and ratchet-files hunting their own kinds), redesign from the list, land each fix through refactor-change and code-review, then audit the tests. User-invoked. |
  146. | [find-state-machines](skills/review/find-state-machines/SKILL.md) | Find implicit state machines and make them explicit — small safe fixes proactively, larger restructures after confirming. |
  147. | [find-overengineering](skills/review/find-overengineering/SKILL.md) | Roll back protective code for an edge case of an edge case, and migrations for products with no users. |
  148. | [ratchet-files](skills/review/ratchet-files/SKILL.md) | Keep every source file small enough for an agent to read whole: list files over a token budget, split them by concept, and install a pre-commit ratchet that lets oversized files shrink but never grow. Ships the check and a shared hook installer that covers every worktree. |
  149. | [retro](skills/review/retro/SKILL.md) | Conduct a coding-session retrospective and suggest improvements to the agent's environment, checks, guidance, and information access. User-invoked. |
  150. ### Visual review — never accept visuals on vibes
  151. | Skill | What it does |
  152. |---|---|
  153. | [design-with-images](skills/visual/design-with-images/SKILL.md) | Explore generated visual options, preserve the selected target, and iterate real screenshots against it until the implemented design matches. |
  154. | [compare-screenshots](skills/visual/compare-screenshots/SKILL.md) | Compare captures against an approved design or the intended result; use telemetry to locate differences rather than treating a historical baseline as correct. Ships a reusable diff script that also measures a lone capture for flat, empty, or misframed content. |
  155. | [screenshot-critique](skills/visual/screenshot-critique/SKILL.md) | Use an unprimed subagent as a second set of eyes on visual work before accepting it; mandatory before declaring a reported visual bug fixed. Ships a checker that strikes any number the critique cannot show a command for, and any file it named but never wrote. |
  156. | [preview-shots](skills/visual/preview-shots/SKILL.md) | Open a curated set of image shots in one macOS Preview window for the user to eyeball. |
  157. ### Authoring — sharpen the tools themselves
  158. | Skill | What it does |
  159. |---|---|
  160. | [write-skills](skills/authoring/write-skills/SKILL.md) | Create or revise agent skills: triggers, leading words, progressive disclosure, and the failure modes to prune. |
  161. | [audit-agents](skills/authoring/audit-agents/SKILL.md) | Audit or rewrite AGENTS.md so it holds only lasting principles, with iteration speed at the core. Ships an example AGENTS.md that pairs with this pack. |
  162. | [eval-skills](skills/authoring/eval-skills/SKILL.md) | Eval a skill against golden cases — blind runs in fresh subagents, a separate judge, and gap-driven edits. |
  163. ### Graphics
  164. | Skill | What it does |
  165. |---|---|
  166. | [renderer](skills/graphics/renderer/SKILL.md) | Architecture rules for GPU rendering with TypeGPU/WebGPU — one frame orchestrator, single owners, a resource registry, depth and compositing contracts, and verification that looks at pixels. |
  167. | [launch-video](skills/graphics/launch-video/SKILL.md) | Direct a showreel-grade launch video in code, 2D unless the subject is 3D — one visual concept grown from the project, picture and a synthesized score locked to one timing source, and a preview frame that survives social feeds. |
  168. | [cinematic-shot](skills/graphics/cinematic-shot/SKILL.md) | Shoot software UI like a film — steep, oblique extreme close-up hero shots with a razor-thin focal plane, slow motivated camera drift, and UI that acts on its own, hard-cut on the action. |
  169. | [isometric-motion](skills/graphics/isometric-motion/SKILL.md) | Build animations and interactive elements in a crafted isometric style — solid many-part figures, four-tone shading, a framed card with live readout, and calm eased motion driven by one model. |
  170. | [xiaohei-illustrations](skills/graphics/xiaohei-illustrations/SKILL.md) | Hand-drawn 16:9 editorial illustrations for articles and docs, starring Xiaohei, a small solid-black creature acting out each idea, with sparse handwritten English annotations. |
  171. ## License
  172. MIT
  173. ## Acknowledgements
  174. Thanks to [Matt Pocock](https://x.com/mattpocockuk) for the
  175. [retro skill](https://github.com/mattpocock/skills/tree/main/skills/engineering/retro),
  176. copied here with its writing-guide references pointed at this repo's `write-skills`.
  177. Thanks also to Matt and [Thariq](https://x.com/trq212) for the **fog of war** and
  178. **discovering the map** concepts that helped shape these skills.
  179. Thanks to [wheresryan22](https://github.com/wheresryan22) for the
  180. [Anatomy skill](https://github.com/wheresryan22/anatomy), copied here as
  181. `isometric-motion` and repurposed for animations and interactive elements.
  182. Thanks to [helloianneo](https://github.com/helloianneo) for the
  183. [Ian Xiaohei illustrations skill](https://github.com/helloianneo/ian-xiaohei-illustrations),
  184. copied here in its English version as `xiaohei-illustrations`.
  185. Thanks to [Caldo](https://github.com/caldoai) for the
  186. [untangle-codebase skill](https://github.com/caldoai/skills/tree/main/skills/untangle-codebase),
  187. trimmed here as `refactor-codebase` so each fix runs through this repo's
  188. `refactor-change`.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.