PRP Generator

Overview

This skill generates comprehensive Product Requirement Plans (PRPs) that enable AI agents to implement features in a single pass with high success rates. The skill combines systematic codebase analysis with external research to create detailed, context-rich implementation blueprints.

When to Use This Skill

Invoke this skill when:

• User requests a PRP (Product Requirement Plan)
• Create implementation guidance from architectural design
• Structure design information for implementation phase
• Define implementation plans with step-by-step guidance
• Specify testing strategies and success criteria
• Document architecture, libraries, and dependencies for implementers

Core Principle

Context is Everything: The AI agent implementing your PRP only receives:

1. The PRP content you create
2. Training data knowledge
3. Access to the codebase
4. WebSearch capabilities

Therefore, your PRP must be self-contained with all necessary context and specific references.

Workflow

Phase 1: Understanding the Feature

1. Read the Feature Request

   • If user provides a feature file path, read it completely
   • If user provides verbal description, clarify requirements by asking:
     • What is the user trying to accomplish?
     • What are the acceptance criteria?
     • Are there any specific constraints or requirements?
   • Identify the core problem being solved

2. Clarify Ambiguities

   • Use AskUserQuestion tool for any unclear requirements
   • Confirm technology stack assumptions
   • Verify integration points
   • Ask about specific patterns to follow if not obvious

Phase 2: Codebase Analysis (Mandatory)

Goal: Understand existing patterns, conventions, and integration points

Refer to references/research_methodology.md for detailed guidance, but the core steps are:

1. Search for Similar Features

   Use Grep to search for:
   - Similar component names
   - Similar functionality keywords
   - Similar UI patterns
   - Similar API endpoints
   

   Document findings with:

   • Exact file paths and line numbers
   • Code snippets showing patterns
   • Relevance to new feature
   • Necessary adaptations

2. Identify Architectural Patterns

   • Directory structure conventions
   • Component organization patterns
   • State management approach
   • API structure patterns
   • Routing patterns (if applicable)

   Example findings:

   Pattern: Feature-based directory structure
   Location: src/features/
   Application: Create src/features/[new-feature]/
   

3. Document Coding Conventions

   • TypeScript usage patterns (interfaces vs types, strict mode)
   • Component patterns (FC vs function, default vs named exports)
   • Styling approach (CSS modules, styled-components, Tailwind)
   • Import ordering and organization
   • Function and variable naming
   • Comment style

   Example:

   Convention: Named exports for all components
   Example: export function UserProfile() { ... }
   Found in: src/components/*.tsx
   

4. Study Test Patterns

   • Test framework and version
   • Test file naming and location
   • Mock strategies
   • Coverage expectations
   • Example test to mirror

   Document:

   Framework: Vitest + @testing-library/react
   Pattern: Co-located tests with *.test.tsx
   Example: src/components/Button/Button.test.tsx
   Mock Strategy: Use vi.fn() for functions, MSW for HTTP
   

5. Check Project Configuration

   • Review package.json for dependencies and scripts
   • Check tsconfig.json for TypeScript settings
   • Review build configuration (vite.config.ts, etc.)
   • Note path aliases and special configurations

   Document:

   Build Tool: Vite 5.x
   Path Aliases: '@/' �� 'src/', '@components/' �� 'src/components/'
   TypeScript: Strict mode enabled
   

Phase 3: External Research (Mandatory)

Goal: Find best practices, documentation, examples, and gotchas

Refer to references/research_methodology.md for detailed guidance, but the core steps are:

1. Search for Library Documentation

   • Go to official documentation for any libraries being used
   • Find the SPECIFIC version in package.json
   • Document exact URLs to relevant sections
   • Note version-specific features or changes

   Example output:

   Library: @tanstack/react-query
   Version: 5.28.0 (from package.json)
   Docs: https://tanstack.com/query/latest/docs/react/overview
   Key Sections:
     - Queries: https://tanstack.com/query/latest/docs/react/guides/queries
     - Mutations: https://tanstack.com/query/latest/docs/react/guides/mutations
   Gotchas:
     - Query keys must be arrays
     - Automatic refetching on window focus
     - Default staleTime is 0
   

2. Find Implementation Examples

   • Search GitHub for similar implementations
   • Look for StackOverflow solutions (recent, highly-voted)
   • Find blog posts from reputable sources
   • Check official example repositories

   Document:

   Example: Form validation with React Hook Form + Zod
   Source: https://github.com/react-hook-form/react-hook-form/tree/master/examples/V7/zodResolver
   Relevance: Shows exact integration pattern needed
   Key Takeaway: Use zodResolver from @hookform/resolvers
   

3. Research Best Practices

   • Search for "[technology] best practices [current year]"
   • Look for common pitfalls and gotchas
   • Research performance considerations
   • Check security implications (OWASP guidelines)

   Document:

   Practice: Input sanitization for user content
   Why: Prevent XSS attacks
   How: Use DOMPurify before rendering HTML
   Reference: https://owasp.org/www-community/attacks/xss/
   Warning: NEVER use dangerouslySetInnerHTML without sanitization
   

4. Performance & Security Research

   • Bundle size implications of new dependencies
   • Runtime performance patterns
   • Security vulnerabilities to avoid
   • Accessibility considerations

   Document specific URLs and recommendations

Phase 4: Ultra-Thinking (Critical)

STOP AND THINK DEEPLY BEFORE WRITING THE PRP

This is the most important phase. Spend significant time analyzing:

1. Integration Analysis

   • How does the new feature connect to existing code?
   • What existing patterns should be followed?
   • Where might conflicts arise?
   • What files will need to be created vs modified?

2. Implementation Path Planning

   • What is the logical order of implementation steps?
   • What are the dependencies between steps?
   • Where are the potential roadblocks?
   • What edge cases need handling?

3. Validation Strategy

   • What can be validated automatically?
   • What requires manual testing?
   • How can the implementer verify each step?
   • What are the success criteria?

4. Context Completeness Check Ask yourself:

   • Could an AI agent implement this without asking questions?
   • Are all integration points documented?
   • Are all necessary examples included?
   • Are gotchas and warnings clearly stated?
   • Is the implementation path clear and logical?

5. Quality Assessment

   • Is this PRP comprehensive enough for one-pass implementation?
   • What could cause the implementation to fail?
   • What additional context would be helpful?
   • Are all assumptions documented?

Phase 5: Generate the PRP

Use the template from assets/prp_template.md as the base structure, and populate it with:

1. Metadata

   • Feature name
   • Timeline estimate
   • Confidence score (1-10)
   • Creation date

2. Summary

   • 2-3 sentences describing the feature
   • Core value proposition

3. Research Findings

   • Codebase analysis results (with file:line references)
   • External research (with specific URLs and sections)
   • Document EVERYTHING discovered in Phase 2 and 3

4. Technical Specification

   • Architecture overview
   • Component breakdown
   • Data models
   • API endpoints (if applicable)

5. Implementation Blueprint

   • Prerequisites
   • Step-by-step implementation (with pseudocode)
   • File-by-file changes
   • Reference patterns from codebase
   • Error handling strategy
   • Edge cases

6. Testing Strategy

   • Unit test approach
   • Integration test approach
   • Manual testing checklist

7. Success Criteria

   • Clear, measurable completion criteria
   • Checklist format

Phase 6: Quality Scoring

Score the PRP on a scale of 1-10 for one-pass implementation success:

Scoring Criteria:

• 9-10: Exceptionally detailed, all context included, clear path, executable gates
• 7-8: Very good, minor gaps, mostly clear implementation path
• 5-6: Adequate, some ambiguity, may require clarification
• 3-4: Incomplete research, missing context, unclear path
• 1-2: Insufficient for implementation

If score is below 7: Go back and improve the PRP before delivering it.

Phase 7: Save and Deliver

1. Determine Feature Name

   • Use kebab-case
   • Be descriptive but concise
   • Example: "user-authentication", "dark-mode-toggle", "data-export"

2. Save the PRP

   Save to: PRPs/[feature-name].md
   

   If PRPs directory doesn't exist, create it:

   mkdir -p PRPs
   

3. Deliver Summary to User Provide:

   • Brief summary of the feature
   • Location of saved PRP
   • Confidence score and rationale
   • Next steps recommendation

Quality Checklist

Before delivering the PRP, verify:

• Feature requirements fully understood
• Codebase analysis completed with specific file references
• External research completed with URLs and versions
• All similar patterns identified and documented
• Coding conventions documented
• Test patterns identified
• Implementation steps clearly defined
• Error handling strategy documented
• Edge cases identified
• Success criteria defined
• Confidence score 7+ (if not, improve the PRP)
• No assumptions left undocumented
• Integration points clearly identified
• PRP saved to correct location

Common Pitfalls to Avoid

1. Vague References

   • ? "There's a similar component somewhere"
   • ? "See UserProfile at src/components/UserProfile.tsx:45-67"

2. Missing Version Information

   • ? "Use React Query"
   • ? "Use @tanstack/react-query v5.28.0"

3. Generic Best Practices

   • ? "Follow React best practices"
   • ? "Use named exports (see src/components/Button.tsx:1)"

4. Incomplete Research

   • ? Skipping codebase analysis
   • ? Thoroughly document existing patterns

5. Missing Gotchas

   • ? Assuming smooth implementation
   • ? Document known issues and edge cases

Example Usage

User Request:

"Create a PRP for adding dark mode support to the application"

Your Response:

1. Clarify: "Should dark mode preference persist across sessions? Should it respect system preferences?"
2. Research codebase for theme-related code
3. Research external resources (dark mode best practices, library options)
4. Ultra-think about implementation approach
5. Generate comprehensive PRP using template
6. Score the PRP
7. Save to PRPs/dark-mode-support.md
8. Deliver summary with confidence score

Resources

Template

• assets/prp_template.md - Base template for all PRPs

References

• references/research_methodology.md - Detailed research guidance and best practices

Examples

• assets/Update-ExecId-Tag17-Generating-Strategy.md - Example simple feature PRP
• assets/Support-Multi-CIFIX-Instances-in-Watchdog.md - Example complex feature PRP
• assets/CIFIX-v2-Overview.md - Example multi-component PRP
• assets/Support-Customer-Level-Config-in-RDBMS.md - Example database focused PRP

These examples does not contain Codebase Analysis and External Research

Notes

• Research is mandatory: Never skip codebase or external research
• Be specific: Always include file paths, line numbers, URLs, versions
• Think deeply: Phase 4 (Ultra-Thinking) is critical for success
• Score honestly: If confidence is below 7, improve the PRP
• Context is king: The implementer only has what you put in the PRP