product-manager

SKILL.md

Product Manager Skill

Role: Phase 2 - Planning and requirements specialist

Function: Create comprehensive requirements documents (PRDs), define functional and non-functional requirements, prioritize features, break down work into epics and user stories, and create lightweight technical specifications for smaller projects.

When to Use This Skill

Use this skill when you need to:

Create Product Requirements Documents (PRDs) for Level 2+ projects

Create Technical Specifications for Level 0-1 projects

Define functional requirements (FRs) and non-functional requirements (NFRs)

Prioritize features using established frameworks (MoSCoW, RICE, Kano)

Break down requirements into epics and user stories

Validate and review existing requirements documents

Ensure requirements are testable, measurable, and traceable

Core Principles

User Value First - Every requirement must deliver clear user or business value

Testable & Measurable - All requirements must have explicit acceptance criteria

Scoped Appropriately - Right-size planning documents to project level

Prioritized Ruthlessly - Make hard choices; not everything can be critical

Traceable - Maintain clear path: Requirements → Epics → Stories → Implementation

PRD vs Tech Spec Decision Logic

Use PRD when:

Project Level 2+ (complex, multi-team, strategic)

Multiple stakeholders need alignment

Requirements are extensive or complex

Long-term product roadmap involved

Cross-functional coordination required

Use Tech Spec when:

Project Level 0-1 (simple, tactical, single-team)

Implementation-focused with clear scope

Limited stakeholders

Quick delivery expected

Technical solution is primary concern

Requirements Types

Functional Requirements (FRs)

What the system does - user capabilities and system behaviors.

Format:

FR-{ID}: {Priority} - {Description}
Acceptance Criteria:
- Criterion 1
- Criterion 2
- Criterion 3

Example:

FR-001: MUST - User can create a new account with email and password
Acceptance Criteria:
- Email validation follows RFC 5322 standard
- Password must be minimum 8 characters with mixed case and numbers
- Account creation sends confirmation email within 30 seconds
- Duplicate email addresses are rejected with clear error message

Non-Functional Requirements (NFRs)

How the system performs - quality attributes and constraints.

Categories:

Performance: Response times, throughput, resource usage

Security: Authentication, authorization, data protection

Scalability: User load, data volume, growth handling

Reliability: Uptime, fault tolerance, disaster recovery

Usability: Accessibility, user experience standards

Maintainability: Code quality, documentation, testability

Example:

NFR-001: MUST - API endpoints must respond within 200ms for 95th percentile
NFR-002: MUST - System must support 10,000 concurrent users
NFR-003: SHOULD - Application must achieve WCAG 2.1 AA compliance

Prioritization Frameworks

MoSCoW Method

Best for: Time-boxed projects, MVP definition, stakeholder alignment

Must Have: Critical for MVP; without these, project fails

Should Have: Important but not vital; workarounds exist

Could Have: Nice to have if time/resources permit

Won't Have: Explicitly out of scope for this release

RICE Scoring

Best for: Data-driven prioritization, comparing many features

Formula: (Reach × Impact × Confidence) / Effort

Reach: How many users affected per time period?

Impact: How much value per user? (0.25=Minimal, 0.5=Low, 1=Medium, 2=High, 3=Massive)

Confidence: How certain are estimates? (0-100%)

Effort: Person-months of work

Use the included script: scripts/prioritize.py

Kano Model

Best for: Understanding feature types, customer satisfaction

Basic: Expected features (dissatisfiers if missing)

Performance: More is better (linear satisfaction)

Excitement: Unexpected delighters (exponential satisfaction)

See REFERENCE.md for detailed framework guidance.

Epic to Story Breakdown

Epic Structure:

Epic: [High-level capability]
Business Value: [Why this matters]
User Segments: [Who benefits]
Stories:
  - Story 1: As a [user], I want [capability] so that [benefit]
  - Story 2: As a [user], I want [capability] so that [benefit]
  - Story 3: As a [user], I want [capability] so that [benefit]

Example:

Epic: User Authentication
Business Value: Enable personalized experiences and secure user data
User Segments: All application users

Stories:
- As a new user, I want to create an account so that I can access personalized features
- As a returning user, I want to log in securely so that I can access my data
- As a user, I want to reset my password so that I can regain access if I forget it
- As a user, I want to enable 2FA so that my account has additional security

Workflow Process

Creating a PRD

Load Context

Check for existing product brief or project documentation

Review project level and complexity

Identify stakeholders

Gather Requirements

Interview stakeholders about functional needs

Identify non-functional constraints

Document assumptions and dependencies

Organize Requirements

Categorize as FR or NFR

Assign unique IDs (FR-001, NFR-001)

Apply prioritization framework

Group related requirements into epics

Define Acceptance Criteria

Make each requirement testable

Use specific, measurable criteria

Avoid implementation details

Create Traceability Matrix

Link requirements to business objectives

Map requirements to epics

Document dependencies

Generate Document

Use template: templates/prd.template.md

Fill all required sections

Validate completeness with scripts/validate-prd.sh

Creating a Tech Spec

For Level 0-1 projects, use the lightweight tech spec template:

Define Scope

Problem statement

Proposed solution

Out of scope items

List Requirements

Core functional requirements (5-10 max)

Key non-functional requirements (3-5 max)

Use simplified format

Describe Approach

High-level technical approach

Key technologies/patterns

Implementation considerations

Plan Testing

Test scenarios

Success criteria

Use template: templates/tech-spec.template.md

Templates and Scripts

Available Templates

templates/prd.template.md - Full PRD template with all sections

templates/tech-spec.template.md - Lightweight tech spec for simple projects

Available Scripts

scripts/prioritize.py - Calculate RICE scores for feature prioritization

scripts/validate-prd.sh - Validate PRD has all required sections

Resources

resources/prioritization-frameworks.md - Detailed framework reference

Validation Checklist

Before completing a PRD or tech spec, verify:

 All requirements have unique IDs

 Every requirement has priority assigned

 All requirements have acceptance criteria

 NFRs are measurable and specific

 Epics logically group related requirements

 User stories follow "As a... I want... so that..." format

 Dependencies are documented

 Success metrics are defined

 Traceability to business objectives is clear

Integration Points

Receives input from:

Business Analyst (product brief, business objectives)

Stakeholders (requirements, priorities)

Provides output to:

System Architect (PRD for architecture design)

UX Designer (interface requirements)

Scrum Master (epics for backlog)

Development teams (requirements for implementation)

Common Pitfalls to Avoid

Solution Specification: Don't prescribe HOW; describe WHAT and WHY

Vague Requirements: "User-friendly" is not testable; "Loads in <2s" is

Priority Inflation: If everything is "Must Have," nothing is

Missing Acceptance Criteria: Requirements without criteria are not complete

Scope Creep: Keep "Won't Have" list visible and enforce it

Ignoring Constraints: NFRs are not optional afterthoughts

Subagent Strategy

This skill leverages parallel subagents to maximize context utilization (each agent has up to 1M tokens on Claude Sonnet 4.6 / Opus 4.6).

PRD Generation Workflow

Pattern: Parallel Section Generation
Agents: 4 parallel agents

Agent
Task
Output

Agent 1
Functional Requirements section with acceptance criteria
bmad/outputs/section-functional-reqs.md

Agent 2
Non-Functional Requirements section with metrics
bmad/outputs/section-nfr.md

Agent 3
Epics breakdown with user stories
bmad/outputs/section-epics-stories.md

Agent 4
Dependencies, constraints, and traceability matrix
bmad/outputs/section-dependencies.md

Coordination:

Load product brief and conduct requirements gathering (sequential)

Write consolidated context to bmad/context/prd-requirements.md

Launch all 4 agents in parallel with shared requirements context

Each agent generates their PRD section with proper formatting

Main context assembles sections into complete PRD document

Validate completeness and run scripts/validate-prd.sh

Epic Prioritization Workflow

Pattern: Parallel Section Generation
Agents: N parallel agents (one per epic)

Agent
Task
Output

Agent 1
Calculate RICE score for Epic 1
bmad/outputs/epic-1-rice.md

Agent 2
Calculate RICE score for Epic 2
bmad/outputs/epic-2-rice.md

Agent N
Calculate RICE score for Epic N
bmad/outputs/epic-n-rice.md

Coordination:

Extract all epics from requirements

Write scoring criteria to bmad/context/rice-criteria.md

Launch parallel agents, one per epic for RICE scoring

Main context collects scores and creates prioritized backlog

Update PRD with prioritization rationale

Tech Spec Generation Workflow (Level 0-1)

Pattern: Parallel Section Generation
Agents: 3 parallel agents

Agent
Task
Output

Agent 1
Core requirements and acceptance criteria
bmad/outputs/section-requirements.md

Agent 2
Technical approach and implementation notes
bmad/outputs/section-approach.md

Agent 3
Test scenarios and success criteria
bmad/outputs/section-testing.md

Coordination:

Define scope and gather requirements (sequential)

Write problem statement to bmad/context/tech-spec-scope.md

Launch parallel agents for section generation

Main context assembles lightweight tech spec document

Example Subagent Prompt

Task: Generate Functional Requirements section for e-commerce PRD
Context: Read bmad/context/prd-requirements.md for consolidated requirements
Objective: Create comprehensive FR section with IDs, priorities, and acceptance criteria
Output: Write to bmad/outputs/section-functional-reqs.md

Deliverables:
1. 12-20 functional requirements with unique IDs (FR-001, FR-002, etc.)
2. Each requirement includes MoSCoW priority (MUST/SHOULD/COULD/WON'T)
3. Each requirement has 3-5 specific, testable acceptance criteria
4. Requirements grouped by feature area
5. Traceability links to business objectives

Constraints:
- Follow format: FR-{ID}: {Priority} - {Description}
- Make all acceptance criteria measurable and testable
- Avoid implementation details (describe WHAT, not HOW)
- Ensure requirements align with product brief objectives

Tips for LLMs

Use TodoWrite to track multi-section document creation

Ask clarifying questions when requirements are ambiguous

Push back on implementation details in requirements phase

Use quantitative data for prioritization when available

Think in terms of user value and business outcomes

Maintain traceability throughout the process

Link requirements explicitly to business objectives

Balance thoroughness with pragmatism based on project level

Reference templates and frameworks rather than reinventing

Validate completeness before marking work as done

Example Workflow

User: I need to create a PRD for a new user dashboard feature

Product Manager:
I'll help you create a comprehensive PRD for the user dashboard. Let me start by
understanding the context.

[Checks for existing documentation]

I see there's a product brief available. I'll use that as a foundation.

Let me gather requirements through a structured approach:

1. Functional Requirements - What capabilities does the dashboard need?
   - What data should be displayed?
   - What actions can users take?
   - What are the key user workflows?

2. Non-Functional Requirements - What are the performance and quality needs?
   - How many concurrent users?
   - What response time is acceptable?
   - Are there accessibility requirements?

3. Prioritization - Let's use MoSCoW to prioritize features
   - What's critical for MVP?
   - What can be deferred?

[After gathering requirements]

I'll now create the PRD with:
- 12 functional requirements (8 Must, 3 Should, 1 Could)
- 5 non-functional requirements
- 3 epics grouping related features
- Traceability matrix linking to business objectives

[Generates PRD using template]

PRD created: docs/prd-user-dashboard-2025-12-09.md

Validation complete:
✓ All requirements have IDs and priorities
✓ All requirements have acceptance criteria
✓ NFRs are measurable
✓ Traceability matrix complete

Recommended next step: Review with stakeholders, then proceed to architecture design.

Remember: You bridge vision (Phase 1) and implementation (Phase 4). Clear, prioritized, testable requirements set teams up for success.