Skip to content
Back to search

skills

A collection of Claude Code skills for product development workflows by unlearn.dev

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

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

HTML

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

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx skills add unlearndev/skills

This uses [skills.sh](https://skills.sh) to install all skills into your project's `.claude/skills/` directory. Once installed, your agent will automatically detect and use them based on your prompts.

To install a single skill:

npx skills add unlearndev/skills --skill spec-generator

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 · 241 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. A collection of skills for product development workflows by [Unlearn](https://unlearn.dev).
  3. ## Install
  4. ```sh
  5. npx skills add unlearndev/skills
  6. ```
  7. This uses [skills.sh](https://skills.sh) to install all skills into your project's `.claude/skills/` directory. Once installed, your agent will automatically detect and use them based on your prompts.
  8. To install a single skill:
  9. ```sh
  10. npx skills add unlearndev/skills --skill spec-generator
  11. ```
  12. ## Skills
  13. | Skill | Description |
  14. |-------|-------------|
  15. | [spec-generator](#spec-generator) | Turn a vague idea into a detailed product spec |
  16. | [feature-generator](#feature-generator) | Expand a spec into an implementation-ready feature list |
  17. | [code-review](#code-review) | Review staged changes or a specific area of the codebase |
  18. | [checklist](#checklist) | Convert plans or reviews into persistent markdown checklists |
  19. | [review-order](#review-order) | Prepare a structured, scannable review map of a branch's changes |
  20. | [first-five](#first-five) | Triage a branch against the First Five checklist and flag only real concerns |
  21. | [triage](#triage) | Group a branch's changes into feature areas and assign risk tiers |
  22. | [zombies](#zombies) | Suggest the most relevant tests to write for a feature using the ZOMBIES heuristic |
  23. | [warm](#warm) | Evaluate newly added or upgraded dependencies against the WARM check |
  24. | [preflight](#preflight) | Produce a production pre-flight checklist of everything a branch needs once it merges |
  25. | [ship-gate](#ship-gate) | Scan the staged diff for secrets, debug code, and stray files and return a straight PASS or BLOCK |
  26. | [qa-checklist](#qa-checklist) | Turn a branch's diff into a short, click-through manual QA checklist for the feature |
  27. | [judge-arch](#judge-arch) | Judge a branch's changes against the design decisions in the repo's DECISIONS.md |
  28. | [trace](#trace) | Trace one journey through an unfamiliar codebase and draw it as a cited flow diagram |
  29. | [cruft-hunt](#cruft-hunt) | Hunt for what coding agents left behind and rank the deletion candidates, with evidence |
  30. | [is-it-dead](#is-it-dead) | Prove one candidate is dead (or not) with the DEAD checks before deleting it, one commit at a time |
  31. | [leftovers](#leftovers) | End-of-branch cleanup: remove what this branch added that the finished work doesn't use |
  32. ### spec-generator
  33. Generate a detailed product specification from a rough idea, description, or supporting materials (screenshots, notes, wireframes).
  34. ```
  35. > Write up a spec for a Slack bot that summarizes daily standups
  36. > Turn this idea into a requirements doc
  37. > /spec-generator
  38. ```
  39. Outputs a structured markdown spec covering overview, user stories, data model, API, UI, and edge cases.
  40. ### feature-generator
  41. Expand a `spec.md` into a full `features.md` ordered by implementation dependency, or keep the two files in sync when either changes.
  42. ```
  43. > Generate features from the spec
  44. > Sync spec and features
  45. > /feature-generator
  46. ```
  47. Features are ordered for optimal AI agent implementation: foundation first, then simple flows, complex features, admin features, and cross-cutting concerns.
  48. ### code-review
  49. Review staged git changes or a specific area of the codebase. Optionally delegate to an alternative agent (codex, aider, goose).
  50. ```
  51. > Review my staged changes
  52. > /code-review codex auth-module
  53. > /code-review
  54. ```
  55. Findings are classified by severity: Critical, Error, Warning, Suggestion, and Nitpick.
  56. ### checklist
  57. Convert the current plan, code review, or any structured content into a persistent markdown checklist saved to `.claude/plans/`.
  58. ```
  59. > Turn this plan into a checklist
  60. > /checklist
  61. ```
  62. Creates a trackable file with checkboxes that the agent checks off as it works through the implementation.
  63. ### review-order
  64. Prepare a scannable map of a branch's changes, grouped by feature and ordered for review (Types → Data Flow → Business Logic → Edge Cases) with `file:line` citations.
  65. ```
  66. > Prep a review of this branch
  67. > /review-order
  68. > /review-order develop
  69. ```
  70. Outputs a descriptive map (no suggestions, no questions) so you can jump straight into the code yourself.
  71. ### first-five
  72. Scan a branch or diff against the **First Five** checklist (Error Handling, Input Boundaries, External Calls, State Mutations, Assumed Dependencies) and report only genuine concerns — verified against the codebase, not flagged on suspicion.
  73. ```
  74. > Run the first five on this branch
  75. > /first-five
  76. > /first-five develop
  77. ```
  78. Outputs a short, scannable triage list with `file:line` citations and ⚠️ markers for high-severity findings. No fixes proposed, no clean-section placeholders.
  79. ### triage
  80. Map a branch's changes into feature-area groups, each tiered as High / Medium / Low risk, so you can decide where to spend your review time. This is a triage map — not a review.
  81. ```
  82. > Triage this branch
  83. > /triage
  84. > /triage develop
  85. ```
  86. Outputs a risk-ordered report grouped by feature area (e.g. "Authentication", "Notification Delivery"), with auto-generated files pushed to a Skip section. No suggestions, no fixes — just a map.
  87. ### zombies
  88. Identify the most valuable tests to write for a feature using the ZOMBIES heuristic (Zero, One, Many, Boundaries, Interface, Exceptions, Simple scenarios). Pass a free-text feature description, or omit the argument to use the current branch's diff.
  89. ```
  90. > /zombies
  91. > /zombies sign-in code login flow
  92. > /zombies image upload validation
  93. ```
  94. Outputs a grouped list of test ideas — only the ZOMBIES categories that genuinely apply, with specific values pulled from the code (column lengths, expiry windows, throttle limits) so you can see at a glance what's worth covering and write the tests yourself.
  95. ### warm
  96. Evaluate newly added or upgraded dependencies against the **WARM** check (Worth it, Alive, Right-sized, Maintained securely). Covers client- and server-side dependencies in any language by diffing the changed manifests against a base.
  97. ```
  98. > WARM check this branch
  99. > /warm
  100. > /warm develop
  101. ```
  102. Outputs a per-dependency report scoring each WARM letter with a one-word verdict (Keep, Reconsider, Patch/Pin, Replace), ordered by concern. Facts come from real registry, repo, and advisory lookups — nothing fabricated. Evaluates and reports only; it never edits manifests or runs installs.
  103. ### preflight
  104. Read the diff between the current branch and main and produce a production pre-flight checklist of everything that must be done or configured once the change merges (migrations, queue workers, env vars, new services).
  105. ```
  106. > What needs doing in production before this merges?
  107. > /preflight
  108. ```
  109. Outputs a short checklist grouped by type (Database, Infrastructure, Configuration, Operational), sub-grouped by confidence, with a file citation for every item.
  110. ### ship-gate
  111. Scan the **staged** diff for the four things that should never be committed — secrets or API keys, leftover debug code (`dd()`, `console.log`), large commented-out blocks, and accidentally added large or binary files — reporting the file and line for each.
  112. ```
  113. > Check what's staged before I commit
  114. > Anything I shouldn't commit here?
  115. > /ship-gate
  116. ```
  117. Ends with a single **PASS** or **BLOCK** verdict, so it drops cleanly into a pre-commit or pre-push hook. Reports only — it never unstages or edits anything.
  118. ### qa-checklist
  119. Read a branch's diff and produce a short, manual QA checklist to run against the feature — only the behaviour this change touched, written as plain-English steps a person can click through.
  120. ```
  121. > What should I test on this branch after deploy?
  122. > /qa-checklist
  123. > /qa-checklist develop
  124. ```
  125. Outputs a ~5–10 item markdown checklist, each step pairing an action with its expected result, with any required preconditions (test accounts, feature flags) noted up front.
  126. ### judge-arch
  127. Judge the current branch's changes against the design decisions recorded in the repo's `DECISIONS.md` — only those decisions, no other findings or style feedback. Every violation needs evidence you can point at in the change: a file and line, a whole file, or the set of files involved.
  128. ```
  129. > Judge this branch against our decisions
  130. > Check this change against DECISIONS.md
  131. > /judge-arch
  132. ```
  133. Outputs a report grouped by violated decision, each violation citing where it is, what the code does, and the smallest concrete fix that satisfies the decision.
  134. ### trace
  135. Answer a question about how something works in a codebase you didn't write by tracing one journey end to end, from the button, route, or command that starts it through to the response.
  136. ```
  137. > Where does authorization get checked when a user edits their feedback?
  138. > What happens to a user's votes when they delete their account?
  139. > /trace how does a user sign in?
  140. ```
  141. Outputs a top-to-bottom flow diagram, one box per hop, with the `file:line` for each and the names worth searching for. Vendor code, implicit framework hops, and failure branches are marked. If nothing in the app actually triggers the journey, it says so first. Anything inferred rather than read is listed under Not sure.
  142. ### cruft-hunt
  143. Hunt a codebase for what coding agents leave behind: abandoned approaches (ghosts), duplicate helpers (twins), one-use abstractions (scaffolding), unused packages (baggage), options and guards nothing uses (just-in-case) and litter. Runs the stack's dead-code tool first (knip, composer-unused, vulture/deptry, deadcode, cargo-machete) without adding it to the project, then investigates what tools can't see.
  144. ```
  145. > Hunt for cruft
  146. > /cruft-hunt
  147. > /cruft-hunt server/
  148. ```
  149. Outputs a short, ranked list of candidates grouped by leftover type, each with its evidence and payoff/risk, plus a **⚠️ Check first** section for anything that might be reached another way. Read-only: candidates, not verdicts.
  150. ### is-it-dead
  151. Prove whether one file, function, route, job, flag branch or package is really dead before deleting it. Runs the **DEAD** checks (Direct callers, Every other way in, Anyone outside, Data from production), checks the story in git history, then has a fresh context argue that it's still used.
  152. ```
  153. > Is the old CSV exporter dead?
  154. > /is-it-dead server/lib/export/csvExporter.ts
  155. > /is-it-dead papaparse
  156. ```
  157. Outputs the evidence for each check and a verdict: **DEAD**, **ALIVE** or **NOT PROVEN** (with a tombstone to add). On DEAD, and only after you say yes, it deletes the item and its own tests in one commit, runs your checks, and reports anything the deletion left unused.
  158. ### leftovers
  159. End-of-branch cleanup. Finds what this branch added that the finished work doesn't use: abandoned first attempts, helpers that duplicate existing ones, unused new files, exports, packages and options, debug logging, commented-out code and agent summary files.
  160. ```
  161. > Clean up the leftovers before I commit
  162. > /leftovers
  163. > /leftovers develop
  164. ```
  165. Outputs a numbered list with evidence, asks which to remove, removes only those, then runs your checks.

Ratings and comments

Sign in to rate this skill.

Sign in

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