create-prd

What this skill does

# create-prd

**Category**: Product & Strategy

## Usage

```bash
create-prd <product-name>
```

## Arguments

- `<product-name>`: Required - The name of the product (will be used for filename and document title)

## Execution Instructions for Claude Code

When this command is run, Claude Code should:

1. Read the PRD template from `claude_settings/python/shared/templates/prd-template.md`
2. Start an interactive session with a welcome message
3. Guide the user through each section with detailed questions and examples
4. Allow users to review and edit responses before moving forward
5. Generate a complete PRD document with all responses
6. Save the document as `<product-name>-prd.md` in the current directory
7. Offer to create a summary or next steps document

## Interactive Session Flow

### Welcome & Overview
```
Welcome to the PRD Creation Wizard!

We'll work together to create a comprehensive Product Requirements Document for [product-name].
This process has 15 sections and typically takes 30-45 minutes.

You can:
- Type 'skip' to leave any optional section blank
- Type 'back' to review/edit the previous section
- Type 'preview' to see the document so far
- Type 'help' for assistance

Ready to begin? (yes/no)
```

### 1. **Document Setup** [Section 1/15]
```
Let's set up the document metadata:

Product Name: [pre-filled with <product-name>]
Is this correct? (yes/no):

Document Version [default: 1.0]:

Your Name/Author:

Document Status:
  1. Draft (default)
  2. Review
  3. Approved
  4. Released
Select (1-4):
```

### 2. **Executive Summary** [Section 2/15]
```
The executive summary should capture the essence of your product in 2-3 sentences.

Think about:
- What is the product?
- Who is it for?
- What key problem does it solve?

Example: "TaskMaster is a project management tool designed for remote teams. It solves
the challenge of coordinating work across time zones by providing async-first features
and intelligent scheduling. This enables teams to maintain productivity without requiring
constant real-time communication."

Please write your executive summary:
```

### 3. **Problem Statement** [Section 3/15]
```
Let's define the problem your product solves. We'll break this into 4 parts:

Part 1: The Core Problem
What specific problem are you solving? Be concrete and specific.

Example: "Remote teams struggle to coordinate work effectively across different time zones,
leading to delayed decisions, missed deadlines, and team frustration."

Your problem statement:
```

```
Part 2: Who Experiences This Problem?
Describe the people or organizations affected by this problem.

Example: "Small to medium software companies (10-200 employees) with distributed teams
across 3+ time zones, particularly those in tech, consulting, and creative industries."

Who experiences your problem:
```

```
Part 3: Current Solutions & Limitations
What solutions do people use today? What's wrong with them?

Example: "Teams currently use combinations of Slack, email, and basic project tools.
These lack timezone awareness, require manual coordination, and create information silos."

Current solutions and their limitations:
```

```
Part 4: Cost of Not Solving
What happens if this problem isn't addressed? Include metrics if possible.

Example: "Companies report 20% productivity loss due to coordination delays,
$50K+ annual cost in missed deadlines, and 30% higher turnover in remote positions."

Cost/impact of not solving:
```

### 4. **Product Vision & Objectives** [Section 4/15]
```
Let's establish your product vision and measurable objectives.

Part 1: Vision Statement
Write ONE sentence describing the ideal future state your product enables.

Example: "A world where distributed teams collaborate as effectively as co-located ones,
regardless of time zones or geography."

Your vision statement:
```

```
Part 2: Key Objectives
List 3-5 specific objectives your product aims to achieve.
Format as bullet points, starting each with an action verb.

Example:
- Reduce cross-timezone coordination time by 50%
- Enable 24-hour development cycles for global teams
- Improve remote employee satisfaction scores by 30%
- Decrease project delays caused by timezone misalignment to <5%

Your key objectives (one per line):
```

```
Part 3: Success Metrics
How will you measure success? Be specific and quantifiable.

Example:
- Time to decision: <4 hours (down from 24 hours)
- User adoption: 80% daily active users within teams
- NPS score: >50 within 6 months
- Customer retention: >90% annual

Your success metrics (one per line):
```

### 5. **Target Users & Personas** [Section 5/15]
```
Let's define your primary user persona in detail.

Primary User Name/Title:
Example: "Sarah Chen, Engineering Manager"

Your primary user:
```

```
Their Role/Job Description:
Example: "Manages a team of 8 engineers across US, Europe, and Asia. Responsible for
sprint planning, code reviews, and team coordination."

Role description:
```

```
Their Main Goals (what are they trying to achieve?):
Example: "Ship features on schedule, maintain code quality, keep team engaged and productive,
advance her career to Director level"

Main goals (list 2-4):
```

```
Their Pain Points (what frustrates them?):
Example: "Waiting hours for responses, duplicate work due to poor handoffs, difficulty
scheduling meetings, feeling disconnected from team"

Pain points (list 2-4):
```

```
Technical Proficiency:
  1. Low (basic computer skills)
  2. Medium (comfortable with standard tools)
  3. High (technical/power user)

Select (1-3):
```

```
Secondary User Types:
Do you have other important user types? (yes/no/skip)

[If yes, collect: name, role, and key differences from primary persona]
```

### 6. **User Stories & Requirements** [Section 6/15]
```
Let's prioritize features using the MoSCoW method:
- P0 (Must Have): Critical for launch, product fails without these
- P1 (Should Have): Important but can launch without if needed
- P2 (Nice to Have): Enhances experience but not essential

We'll use the format: "As a [user], I want to [action] so that [benefit]"

Must-Have Features (P0):
Example: "As an engineering manager, I want to see my team's availability across time zones
so that I can schedule work effectively"

Enter your P0 features (type 'done' when finished):
1:
```

```
Should-Have Features (P1):
Example: "As a team member, I want to set my preferred working hours so that colleagues
know when to expect responses"

Enter your P1 features (type 'done' when finished):
1:
```

```
Nice-to-Have Features (P2):
Example: "As a manager, I want AI-suggested optimal meeting times so that I can minimize
disruption across time zones"

Enter your P2 features (type 'done' when finished):
1:
```

### 7. **Solution Overview** [Section 7/15]
```
Now let's describe how your product solves the problem.

Part 1: Solution Approach
Describe your solution in 2-3 paragraphs. Focus on the "how" and "why" of your approach.

Example: "TaskMaster reimagines project management for async-first teams. Instead of
real-time dashboards, we provide time-shifted views that show each team member their
relevant work context. Our AI-powered handoff system ensures smooth transitions between
time zones...

[2-3 paragraphs continuing the example]"

Your solution approach:
```

```
Part 2: Key Differentiating Features
What makes your solution unique? List 3-5 features that competitors don't have.

Example:
- Timezone-aware task routing that automatically assigns work to available team members
- Async video standups with AI-generated summaries
- Predictive deadline alerts based on global team availability
- Cultural calendar integration to respect holidays/working patterns

Your key differentiators (one per line):
```

```
Part 3: User Journey
Describe the main user journey step-by-step from problem to solution.

Example:
1. Sarah logs in Monday morning in San Francisco
2. Sees AI-prioritized tasks handed off from Asia team overnight
3. Reviews async video update