PRD Skill

Produce comprehensive, drift-proof Product Requirements Documents through iterative discovery.

Output: .claude/reference/PRD.md (the living requirements document for the project).

Mode Routing

Parse $ARGUMENTS to determine the mode:

Plan Mode (--to-plan)

Transform the PRD’s phasing section into a task plan that /orchestrate can execute directly.

Input

Read .claude/reference/PRD.md. If it doesn’t exist, report error and stop. Validate V5 (DAG) passes first.

Transformation Rules

For each Phase in the PRD:

1. Extract requirements mapped to this phase (M1, S1, etc.)
2. Generate tasks from each requirement’s acceptance criteria
3. Assign waves within each phase:
   • Wave 1: Foundation tasks (schemas, types, migrations, config)
   • Wave 2: Implementation tasks (routes, services, repositories)
   • Wave 3: Integration tasks (wiring, UI, end-to-end flows)
   • Wave 4: Polish tasks (error handling, edge cases, docs)
4. Assign agent types:
   • haiku: Type definitions, config changes, simple CRUD, test writing
   • sonnet: Business logic, complex integrations, security-sensitive code
5. Set dependencies from the PRD’s phase prerequisites
6. Generate verification commands from the PRD’s test file mapping

Output Format

Write to docs/plans/<feature-name>-plan.md:

# Task Plan: [Feature Name]

Generated from PRD: `.claude/reference/PRD.md`
Generated at: [ISO timestamp]

## Phase 1: [Title]

### Wave 1: Foundation

| ID     | Task                      | Agent | Files              | Depends | Verify           |
| ------ | ------------------------- | ----- | ------------------ | ------- | ---------------- |
| 1-1.01 | Create Zod schemas for M1 | haiku | packages/types/... | —       | npx tsc --noEmit |

### Wave 2: Implementation

| ID     | Task                        | Agent  | Files             | Depends | Verify                |
| ------ | --------------------------- | ------ | ----------------- | ------- | --------------------- |
| 1-2.01 | Implement repository for M1 | sonnet | src/repositories/ | 1-1.01  | npx vitest run <test> |

Create Mode

Phase 1: Codebase Scan (automatic)

Before asking questions, build context:

1. Launch an Explore agent to map relevant codebase areas
2. Read roadmap/changelog for prior decisions
3. Check for outdated dependencies in scope

Phase 2: Interactive Discovery (2-4 rounds)

Round 1 — Problem & Vision: What problem, who, success criteria, personas Round 2 — Scope & Boundaries: MoSCoW priorities, out-of-scope, interactions Round 3 — Technical Constraints: Architecture, database, auth, performance Round 4 — Phasing & Risk (if needed): Phases, parallelization, risks

Rules: Never >4 questions. Never ask what the scan answered. Never draft before Round 2.

Phase 3: Draft Generation

1. Read template.md from this skill directory
2. Write PRD to .claude/reference/PRD.md
3. Mark gaps with [NEEDS CLARIFICATION: ...]
4. Populate Architecture Decisions with AD-N entries
5. Build phasing DAG with explicit dependency arrows

Phase 4: Multi-Angle Validation

Read validation.md and run every check. Present pass/fail results. Iterate until critical gates pass.

Phase 5: Finalize

Remove markers, print summary, commit with docs(prd): add <feature-name> requirements.

Update Mode (--update)

1. Read existing PRD
2. Ask what changed (new requirement, scope change, dependency update, etc.)
3. Launch Explore agent to detect codebase drift
4. Generate diff-style updates with [ADDED], [CHANGED], [REMOVED], [DRIFT DETECTED] markers
5. Present changes for approval, apply, re-validate

Validate Mode (--validate)

Read validation.md and run all gates. Print pass/fail with line references.

Audit-Deps Mode (--audit-deps)

Read drift-prevention.md and run dependency freshness + architectural drift checks.

Anti-Patterns (NEVER)

• NEVER generate a PRD without scanning the codebase first
• NEVER write acceptance criteria as “should work correctly” — use Given/When/Then
• NEVER skip dependency analysis
• NEVER batch all questions into one wall of text
• NEVER assume a library version — check package.json and npm
• NEVER write phasing without dependency arrows (phases must be a DAG)
• NEVER leave [NEEDS CLARIFICATION] markers in a finalized PRD

Arguments

• /prd — interactive creation
• /prd Workflow Designer — start with context
• /prd --update — incremental update
• /prd --validate — run validation only
• /prd --audit-deps — dependency audit only
• /prd --to-plan — generate orchestrate-ready task plan