name: prd
description: Create a Product Requirements Document. Interactive session to define features, requirements, and scope.
triggers:
- "/prd"
- "create prd"
- "créer un prd"
- "define requirements"
- "définir les besoins"
- "write the prd"
- "rédiger le prd"
tools: Read, Write, Grep, Glob, Task
context: fork
args:
- name: feature
description: Feature name for feature-specific PRD (creates in features/{name}/)
required: false

PRD Skill

Interactive session to create a Product Requirements Document.

Usage

/prd                      # Main project PRD → memory-bank/prd.md
/prd --feature=dark-mode  # Feature PRD → memory-bank/features/dark-mode/prd.md

Behavior

1. Determine output location based on --feature parameter
2. Spawn the Product Manager agent to conduct the requirements session
3. Agent reads existing context (brief.md) and asks clarifying questions
4. User and agent iterate until user says "generate", "create the prd", or similar
5. Create the PRD at the appropriate location

Instructions

When this skill is invoked:

1. Parse arguments:
2. If --feature=X provided, set feature_name = X

3. Otherwise, feature_name = null (main project PRD)

4. Determine paths:
   If feature_name: output_dir = memory-bank/features/{feature_name}/ output_file = memory-bank/features/{feature_name}/prd.md Else: output_dir = memory-bank/ output_file = memory-bank/prd.md

5. Check for existing context:
   Read memory-bank/brief.md if it exists Read memory-bank/prd.md if it exists (for feature PRDs, understand main product) Read memory-bank/tech-stack.md if it exists Read CLAUDE.md if it exists

6. Create output directory if needed:
   bash mkdir -p {output_dir}

7. Spawn the Product Manager agent:
   Use the Task tool with subagent_type: "product-manager" (custom agent).

Prompt for the agent:
```
You are creating a PRD for: {feature_name or "the main product"}

Existing context:
- Brief: {summary of brief.md if exists}
- Main PRD: {summary if feature PRD and main prd.md exists}
- Tech Stack: {summary if exists}

Your goal:
1. Understand the scope (MVP vs future)
2. Define user stories with acceptance criteria
3. Document functional and non-functional requirements
4. Prioritize using MoSCoW
5. When ready, create {output_file}

Start by confirming your understanding of what we're building, then ask about the main user flows.

User's initial input: {user's message if any}
```

1. Let the agent run the interactive session

2. Output: PRD file at determined location

Output Location

# Main project
memory-bank/
└── prd.md

# Feature-specific
memory-bank/
└── features/
    └── {feature-name}/
        └── prd.md

PRD Template

The agent should create a PRD following this structure:

# PRD: {Feature/Product Name}

## Overview
{One paragraph summary}

## Goals
- Primary: {main objective}
- Secondary: {supporting objectives}

## Non-Goals (Out of Scope)
- {Explicit exclusions}

## User Stories

### Core User Flows
1. **{Flow Name}**
   - As a {user}, I want to {action} so that {benefit}
   - Acceptance Criteria:
     - [ ] {criterion 1}
     - [ ] {criterion 2}

### Secondary Flows
{Same format}

## Functional Requirements

### {Feature Area 1}
| ID | Requirement | Priority | Notes |
|----|-------------|----------|-------|
| FR-1 | {requirement} | Must | {notes} |
| FR-2 | {requirement} | Should | {notes} |

## Non-Functional Requirements

| Category | Requirement | Target |
|----------|-------------|--------|
| Performance | Page load time | < 2s |
| Security | Authentication | {method} |

## Dependencies
- {External services, other features}

## Risks & Mitigations
| Risk | Impact | Mitigation |
|------|--------|------------|
| {risk} | H/M/L | {mitigation} |

## Success Metrics
- {Metric}: {target}

## Open Questions
- {Questions for tech team}

Next Step

After creating the PRD, suggest:

"PRD saved to {output_file}. Next:
- /tech-stack to define the technical stack
- Or /implementation-plan if stack is already decided"