to-prd
Skill0 starsChanged 5 days agoMITView on GitHub
Build a lean, engineering-ready PRD — problem through quality requirements — in eight sections, one turn each.
134 other projects use a version of this.
Adopted by
Most recently taken up by
- Robo-Co-op/robobuilder-standardtheir own version, first seen Nov 16, 2026
- AshrafDurjoy/genai-shared-patternstheir own version, first seen Nov 16, 2026
- Integralist/agent-skillstheir own version, first seen Nov 14, 2026
- ishandutta2007/Awesome-Claude-Skillstheir own version, first seen Nov 8, 2026
- kazemcodes/skill-treetheir own version, first seen Nov 8, 2026
- paureis/pau-skillstheir own version, first seen Nov 8, 2026
Used with
Projects with it also use decision-mapping, zoom-out and 10 more.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
FabienDehopreSkilldecision-mapping
Turn a loose idea into a sequenced map of investigation tickets, then drive them to resolution one at a time.
Also in 8 projects that use this
victorgarciaesgiSkillzoom-out
Tell the agent to zoom out and give broader context or a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture.
Also in 60 projects that use this
simo97Skillrequest-refactor-plan
Use this skill when user wants to create a refactor plan.
Also in 23 projects that use this
simo97Skilledit-article
The user will invoke this skill to help them edit an article.
Also in 23 projects that use this
kennethkeimSkillubiquitous-language
Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions "domain model" or "DDD".
Also in 23 projects that use this
AnasX7Skillsetup-pre-commit
Set up Husky pre-commit hooks with lint-staged (Prettier), type checking, and tests in the current repo. Use when user wants to add pre-commit hooks, set up Husky, configure lint-staged, or add commit-time formatting/typechecking/testing.
Also in 34 projects that use this
- +4 more from simo97
Other versions134 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 134
- GreyDGL/PentestGPT★ 16ksame name
- amazingloft999-droid/mattpocock-skills★ 422same name
- Tiberriver256/mcp-server-azure-devops★ 401same name
- ninehills/skills★ 280same name
- InditexTech/weavejs★ 266same name
- serejaris/personal-corp-os★ 244same name
- serejaris/ris-claude-code★ 243same name
- heyongjun666/AICU-Graph★ 200same name
- ayoubben18/ab-method★ 193same name
- yamcodes/arkenv★ 151same name
124 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository35 other files it gives its agents.
- ask-mattSkill
- codebase-designSkill
- code-reviewSkill
- create-verification-skillSkill
- cutSkill
- diagnosing-bugsSkill
- domain-modelingSkill
- grillingSkill
- grill-meSkill
- grill-with-docsSkill
- handoffSkill
- implementSkill
- implement-specSkill
- improve-codebase-architectureSkill
- lean-product-canvasSkill
- maintain-verification-skillSkill
- napkin-mathSkill
- property-testingSkill
- prototypeSkill
- pr-review-canvasSkill
- prSkill
- researchSkill
- retroSkill
- setup-matt-pocock-skillsSkill
- setup-playbookSkill
- tddSkill
- teachSkill
- to-questionnaireSkill
- to-specSkill
- to-ticketsSkill
- triageSkill
- wait-whatSkill
- wayfinderSkill
- wizardSkill
- writing-for-agentsSkill
The file
We split this skill into the rules it gives an agent
12 rules. 0 are common, 11 are distinctive, and 1 is very specific to this project.
0
Common
Most of the 129 edited versions we read keep these.
11
Distinctive
This author's own choices. Worth a look.
1
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 24
The gate: Every field passes one of three ways:
- Distinctive: line 59
Advance when: all three lines are filled, the persona is the product's user or buyer, and the problem is observable.
- Distinctive: line 89
Advance when: every Won't build entry carries a rationale, future considerations are their own bulleted list, every entry has sorted on the …
- Distinctive: line 101
Anchor: every number. A number with no evidence behind it still gets written, tagged 🔶.
- Very specific: line 113
Read references/NFR-SIGNALS.md on entering — it governs all five moves below.
- Distinctive: line 115
Derive: Read What & why and In scope against the signal table.
- Distinctive: line 116
Admit: Every candidate names an in-scope workstream and either the problem or a success criterion.
- Distinctive: line 122
Every entry carries a number.
- Distinctive: line 142
Goal: every gap has a name against it.
- Distinctive: line 146
Every inline 🔶 in the document.
- Distinctive: line 149
Advance when: every inline 🔶 and every cross has a row.
- Distinctive: line 159
Advance when: all four of Cagan's risks have been walked and each surfaced risk has a row.
“Common” is measured: kept by at least 6 in 10 of the 129 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Purpose
The lean PRD owns two things nothing upstream covers: the scope of the release and the requirements it must hold to.
The skill is standalone. A lean product canvas is useful input, never a prerequisite. User stories, epics and acceptance criteria come afterward.
Input
Anything supplied at invocation — text after /to-prd, a pasted dump, discovery notes, a referenced file, a canvas — is material already given. Read it and route each piece through the gate. Arriving empty-handed works too: the flow opens at What & why.
Operating contract
Three rules govern every turn. The sections below only apply them.
Strict flow. Eight sections in order. Finish one — every field gate-passed, Advance when met — before opening the next.
The gate. Every field passes one of three ways:
- Found — in the invocation, a dump, or a readable file. Restate it and have the user confirm or correct it.
- Missing — one focused question carrying an anchor: a candidate answer to accept, correct, or reject, since an anchor pulls a sharper reply than a blank does. A vague answer earns one follow-up.
- Unanswerable — the user genuinely doesn't know. Tag it 🔶 inline where it sits, and carry it to Open questions. Write what is known and mark what isn't; facts, data, quotes and approvals come from the user.
The cross. An item carrying risk its own section can't hold crosses to Open questions and gains a row there.
Facilitation.
- Open with a heads-up — eight sections, a turn each. Guided whatever arrives: a dump fills fields ahead of the turn, and the turn still runs so the user confirms them.
- One turn per section: ask that section's fields together, then wait. Label progress every turn —
Section 3/8 — Out of scope. - Numbered options where a question has natural choices, your recommendation first,
Other (specify)when open-ended. Accept1,#1,1 and 3,1,3, or free text. - On "how many left?", answer and resume. On "stop", halt and wait for an explicit resume.
Output
Fill template.md — it is the sole authority on the deliverable's layout: the sections it shows are the sections the document has, opening on its heading and the line beneath it. Read a section's block on entering that section, and reproduce its structure literally. Each section's item limits live in this contract, not in the template.
Section 1/8 — What & why
Goal: a stakeholder knows what is being built, for whom, and why, in 30 seconds.
Three lines:
- Building — "We're building [solution] for [persona] to solve [problem], which will result in [impact]." Needing more than one sentence means the scope is still unclear.
- Persona — a type label, one line of build-relevant traits, and the one pain this product removes. Two personas at most, and a second only when it changes what gets built.
- Problem — one sentence, concrete and observable.
A canvas already holds all three: carry the lines across and confirm them. With no canvas, ask for them plainly.
The problem names what the persona cannot do today. "We lack an AI layer" is a solution, "revenue is down" is a business metric, "users need a dashboard" is a feature request — each is a different question than the one this line answers.
Advance when: all three lines are filled, the persona is the product's user or buyer, and the problem is observable.
Section 2/8 — In scope
Goal: the build list — every workstream this release ships, in build order, at a grain a team can break into stories.
Included — one line each, **workstream** — what it covers, at most eight, in build order: an entry never sits ahead of something it depends on. Epic-sized: "Data ingestion", never "parse the ISIR header row" and never "the platform". Past eight, ask which ones merge.
Derive them from What & why. Every capability the building line promises is shipped by something here, and so is everything that line leaves implicit — the audit trail, the reminder cadence, the authentication behind a reviewer's panel. Reworking something that already exists is a workstream like any other. Build order follows dependency: what the rest rests on — the data model, authentication — leads the list, whatever order the persona meets it in.
Trace each entry to the problem line, in conversation. One that traces to nothing moves to Out of scope or gets cut. The traces stay out of the document.
Advance when: at most eight entries, each naming a workstream and what it covers on one line, no entry ahead of something it depends on, nothing the building line promises left uncovered, and every entry traced.
Section 3/8 — Out of scope
Goal: scope creep meets a written boundary.
Won't build — one line each, exclusion — rationale, at most six. The valuable entries are the ones someone will be disappointed about; give those the strongest rationale.
Future considerations — its own bulleted list under Won't build, at most five, one line each, no rationales. Its only job is stopping a settled question from reopening.
Sort by permanence. Can you name a concrete condition under which you'd build this later — more users, a signed contract, a specific metric? Yes → Future considerations. No, full stop, you looked at it and the answer is no → Won't build, even if someone could theoretically revisit it someday.
An exclusion that is really a dependency — "mobile out of scope" when the persona is phone-first — is no exclusion: drop it and cross it. An item that won't sort — no nameable trigger condition, but not confidently permanent either — crosses the same way.
Advance when: every Won't build entry carries a rationale, future considerations are their own bulleted list, every entry has sorted on the trigger-condition test or crossed, and nothing here also appears in In scope.
Section 4/8 — Success criteria
Goal: a number that settles, after launch, whether this worked.
One criterion carries ⭑ — the one to instrument, which is what the downstream story work wires up. Write that one always. Add up to four more where a distinct outcome needs its own number; one number that settles it beats four that hedge.
One line each: [observable thing] reaches [number], measured [window].
Anchor every number. A number with no evidence behind it still gets written, tagged 🔶.
Advance when: exactly one criterion carries ⭑, and every criterion written holds a number and a measurement window.
Section 5/8 — Quality requirements
Goal: how well the build must behave, in numbers engineering can design against.
Capabilities live in In scope. This section holds behaviour under named conditions.
Read references/NFR-SIGNALS.md on entering — it governs all five moves below.
- Derive. Read What & why and In scope against the signal table. Candidates come from this document, not from a checklist walked out of habit.
- Admit. Every candidate names an in-scope workstream and either the problem or a success criterion. One that names only itself is scope creep.
- Rank survivors on the rubric's two axes, then cut to five. Past five, ask which five would delay launch. What is cut is named in the section's Raised, not pinned list, one bullet per attribute — a silent cut and a forgotten attribute read identically six months on.
- Pin each survivor in the template's four parts —
PREFIX-NN, a 2–4 word label naming what the requirement is about, the number under its named conditions, and theWhy/Frompair — opening with the attribute's breakage question and anchoring the number. The label names the requirement, not its attribute: "Reply latency" earns its line where "Speed" restates the prefix. Still waving after one follow-up → record a landing zone. Genuinely unknown → 🔶. - Reconcile. Walk the pinned set against the reference's tradeoff pairs and settle each in conversation. Only the amended number and a half-line reason reach the entry.
Every entry carries a number. A mandated rule the breakage questions surface — a regulation, a contract term, a residency policy — is pinned when it holds a number engineering designs against, and otherwise belongs to In scope as a fact about what gets built.
A number the reference's napkin-math check calls implausible crosses, as does any entry that ranked high on technical risk.
Advance when: at most five entries, each carrying a label, a number, a Why and a From; every attribute the signal table raised is either pinned or carries its own bullet in the Raised, not pinned list; and every implausible number has crossed.
Section 6/8 — Dependencies
Goal: name what this build waits on.
A flat list of at most eight, each with its state — built / absent today / unresolved / blocked on X.
Advance when: at most eight dependencies, every one carries a state, and anything unresolved that blocks the build has crossed.
Section 7/8 — Open questions
Goal: every gap has a name against it.
One table: Open question | Why it matters. Two sources fill it:
- Every inline 🔶 in the document.
- Every cross.
Advance when: every inline 🔶 and every cross has a row.
Section 8/8 — Risks
Goal: catch the risk a PRD is most likely to skip.
One table: Risk | Why it matters, filled by a pass over Cagan's four risks — value (will they want it?), usability (can they use it?), feasibility (can we build it?), viability (does the business case hold?). Most PRDs fill feasibility and leave value empty; this pass exists to catch that. A risk raised here that turns out to be an unknown someone must go answer crosses to Open questions instead.
Advance when: all four of Cagan's risks have been walked and each surfaced risk has a row.
Publishing
Publish to the PRD path AGENTS.md names (CLAUDE.md where that is the file the repo keeps); without one, docs/product/prd.md. An existing file is replaced only after the user has seen the diff and confirmed. Then point AGENTS.md at the file so downstream skills find it: a PRD: line under ## Product docs, the section created when missing, the line rewritten when the path changed. Report the path.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

