Prd generator

Skill dhzrx/ai-pm-claude-skills/skills/prd-generator

Install

npx -y skills add dhzrx/ai-pm-claude-skills --skill prd-generator

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
22 stars22 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Generate comprehensive Product Requirements Documents with AI PM best practices for new features and products

SKILL.md

8.0 KB, as published. Nobody here has run it

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 research
- competitive-analyzer → Understand market positioning
- feature-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 implications
- metrics-dashboard-builder → Define measurement approach
After PRD Creation:
- user-story-generator → Break down into development tickets
- stakeholder-communicator → Generate alignment updates
- gtm-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]