OpenSkillIndex← back to search
claude-code

Learn-skills.dev prd

Create, validate, and evolve Product Requirements Documents with interactive discovery, technical architecture, phasing, TDD protocol, and dependency analysis. Use when: writing a PRD, planning a feature, defining requirements, or updating an existing PRD. Supports /prd (create), /prd --update (incremental update), /prd --validate (run checklist), /prd --audit-deps (dependency analysis only), /prd --to-plan (generate orchestrate-ready task plan).

install
source · Clone the upstream repo
git clone https://github.com/NeverSight/learn-skills.dev
Claude Code · Install into ~/.claude/skills/
T=$(mktemp -d) && git clone --depth=1 https://github.com/NeverSight/learn-skills.dev "$T" && mkdir -p ~/.claude/skills && cp -r "$T/data/skills-md/acedergren/agentic-tools/prd" ~/.claude/skills/neversight-learn-skills-dev-prd && rm -rf "$T"
manifest: data/skills-md/acedergren/agentic-tools/prd/SKILL.md
source content

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:

ArgumentModeDescription
(empty)CreateInteractive PRD creation from scratch
<feature text>
CreateStart with context, then iterate
--update
UpdateIncremental update to existing PRD
--validate
ValidateRun validation checklist on existing PRD
--audit-deps
AuditRun dependency/drift analysis only
--to-plan
PlanGenerate orchestrate-ready task plan

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