| name | prd-generator |
| description | Generate comprehensive Product Requirements Documents with AI PM best practices for new features and products |
PRD Generator
Overview
The PRD Generator skill helps AI Product Managers create comprehensive, well-structured Product Requirements Documents (PRDs) that incorporate industry best practices, PM frameworks, and AI-specific considerations. It transforms high-level feature ideas into detailed specifications ready for engineering and stakeholder review.
When to Use This Skill
- Starting a new feature or product initiative
- Need to document requirements for engineering team
- Preparing for stakeholder review or approval
- Creating specification for AI/ML features
- Transitioning from discovery to delivery phase
- Documenting complex features with multiple components
PM Frameworks Applied
- Jobs-to-be-Done (JTBD): Frames problem from user's perspective
- SMART Goals: Ensures success criteria are Specific, Measurable, Achievable, Relevant, Time-bound
- RICE Prioritization: Calculates expected impact (Reach × Impact / Effort)
- User Story Format: "As a... I want... So that..." structure
- MoSCoW Method: Categorizes requirements as Must/Should/Could/Won't have
- RACI Matrix: Defines stakeholder roles and responsibilities
- AI Product Canvas: Structured approach for AI feature requirements
Inputs Required
{
"feature_name": "string",
"problem_statement": "string",
"target_users": "string or array",
"business_goals": "array of strings",
"user_research_summary": "string (optional)",
"competitive_landscape": "string (optional)",
"technical_constraints": "array of strings (optional)",
"success_metrics": "array of objects (optional)",
"ai_ml_requirements": {
"model_type": "string (optional)",
"data_requirements": "string (optional)",
"performance_targets": "object (optional)"
}
}
Outputs Produced
A comprehensive PRD document in Markdown format containing:
- Executive Summary - One-page overview
- Problem Statement - JTBD-framed user problem
- Opportunity Sizing - Market size and impact potential
- Success Metrics - Quantifiable KPIs with targets
- User Stories - Detailed scenarios with acceptance criteria
- Functional Requirements - Must/Should/Could/Won't have features
- Technical Requirements - Architecture, APIs, dependencies
- AI/ML Specifications - Model requirements, data needs, bias mitigation
- User Experience - Key flows and interactions
- Risk Assessment - Potential issues and mitigations
- Launch Plan - Phased rollout strategy
- Stakeholder Matrix - RACI chart
- Appendix - Research summary, competitive analysis
Usage Instructions
Basic Invocation
Create a PRD for [feature name] that solves [problem] for [user segment]
Detailed Invocation
Generate a comprehensive PRD with the following details:
- Feature: AI-powered recommendation engine
- Problem: Users spend too much time searching for relevant products
- Target Users: E-commerce shoppers, focus on returning customers
- Business Goals: Increase conversion rate by 15%, improve average order value
- Include AI/ML requirements and ethical considerations
With Structured Input
Provide JSON input matching the schema above for most detailed results.
Best Practices
- Start with the problem, not the solution - Focus on user needs first
- Be specific about success metrics - Include baseline, target, and timeline
- Document assumptions - Make implicit knowledge explicit
- Include alternatives considered - Show why this approach was chosen
- Address "why now?" - Explain timing and urgency
- Consider edge cases - Don't just focus on happy path
- Plan for failure - Include rollback strategy
- Quantify impact - Use data wherever possible
- Keep it living - PRD should evolve as you learn
Composition with Other Skills
Recommended Workflow
-
Before PRD Creation:
user-research-analyzer → Extract insights from researchcompetitive-analyzer → Understand market positioningfeature-prioritizer → Validate this should be built now
-
During PRD Creation:
- Use this skill (
prd-generator) → Create initial PRD
ai-ethics-assessor → For AI features, evaluate ethical implicationsmetrics-dashboard-builder → Define measurement approach
-
After PRD Creation:
user-story-generator → Break down into development ticketsstakeholder-communicator → Generate alignment updatesgtm-strategy-builder → Plan launch approach
Common Pitfalls to Avoid
- Solution before problem - Jumping to "how" before establishing "why"
- Vague success metrics - "Improve user satisfaction" vs. "Increase NPS from 45 to 60"
- Skipping alternatives - Not documenting why other approaches were rejected
- Ignoring constraints - Technical, resource, or timeline limitations
- Missing dependencies - Other teams, systems, or features required
- Unclear scope - What's in v1 vs. future versions
- No rollback plan - How to handle if feature underperforms
- Stakeholder assumptions - Not validating who needs to approve what
AI/ML Specific Considerations
When generating PRDs for AI features, the skill ensures:
- Model Performance Requirements: Accuracy, latency, throughput targets
- Data Requirements: Training data size, quality, labeling needs
- Bias & Fairness: Evaluation criteria across user demographics
- Explainability: How users understand AI decisions
- Monitoring: Ongoing model performance tracking
- Fallback Behavior: What happens when model fails or is uncertain
- Ethical Guidelines: Privacy, transparency, accountability measures
- Regulatory Compliance: GDPR, AI Act, industry-specific regulations
Python Functions
This skill uses the following Python functions:
generate_prd(input_data: dict) -> str
Main function that orchestrates PRD generation.
Parameters:
input_data: Dictionary containing feature requirements
Returns: Complete PRD in Markdown format
calculate_opportunity_size(reach: int, impact: float, market_size: float) -> dict
Estimates market opportunity using TAM/SAM/SOM framework.
generate_success_metrics(business_goals: list, baseline_data: dict) -> list
Creates SMART metrics with targets and measurement methods.
extract_user_stories(requirements: list, user_personas: list) -> list
Converts functional requirements into user story format with acceptance criteria.
assess_risks(feature_scope: dict, technical_complexity: str) -> list
Identifies potential risks and suggests mitigation strategies.
create_launch_phases(scope: dict, dependencies: list) -> dict
Designs phased rollout plan based on scope and dependencies.
Output Format Example
# PRD: [Feature Name]
## Executive Summary
[One-page overview with problem, solution, impact, and ask]
## Problem Statement
**Job-to-be-Done**: When [situation], I want to [motivation], so I can [outcome].
**Current Experience**: [Pain points]
**Desired Experience**: [Vision]
## Opportunity Sizing
- **TAM** (Total Addressable Market): [size]
- **SAM** (Serviceable Addressable Market): [size]
- **SOM** (Serviceable Obtainable Market): [size]
- **Expected Impact**: [RICE calculation]
## Success Metrics
| Metric | Baseline | Target | Timeline | Measurement |
|--------|----------|--------|----------|-------------|
| [Metric 1] | [value] | [value] | [date] | [method] |
[... continues with all PRD sections]
Related Documentation
- See
user-research-analyzer for analyzing research before writing PRD
- See
feature-prioritizer for validating feature should be built
- See
ai-ethics-assessor for AI-specific ethical evaluation
- See
stakeholder-communicator for sharing PRD with stakeholders
Version: 1.0.0
Last Updated: November 2025
Skill Type: Generative (with Python)
Complexity: Advanced
