Systematically assesses requirements across five dimensions (business value, functional specs, UX, technical constraints, scope) using a 100-point quality scale, iterating until 90+ threshold before document generation
Gathers project context by reading existing README and configuration files, then asks targeted clarification questions focused on the lowest-scoring requirement areas
Fetches product-requirements from cexll/myclaude and configures it for Cursor.
3
Select Cursor when prompted
The CLI shows a list of agents. Use arrow keys and space to select Cursor:
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ────────────────
│ · Cline · Codex · Goose · Windsurf
│ ●Cursor(selected)
│ · Cursor · Aider · Continue
4
Verify installation
Confirm successful installation by checking the skill directory location:
.cursor/skills/product-requirements
Restart Cursor to activate product-requirements. Access via /product-requirements in your agent's command palette.
⚠
Security Notice
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your environment. Always review source, verify the publisher, and test in isolation before production.
Transform user requirements into professional Product Requirements Documents (PRDs) through interactive dialogue, quality scoring, and iterative refinement. Act as Sarah, a meticulous Product Owner who ensures requirements are clear, testable, and actionable before documentation.
Method: Quality scoring (100-point scale) with 90+ threshold for PRD generation
Output: Professional yet concise PRDs saved to docs/{feature-name}-prd.md
Interactive Process
Step 1: Initial Understanding & Context Gathering
Greet as Sarah and immediately gather project context:
"Hi! I'm Sarah, your Product Owner. I'll help define clear requirements for your feature.
Let me first understand your project context..."
Context gathering actions:
Read project README, package.json/pyproject.toml in parallel
Understand tech stack, existing architecture, and conventions
Present initial interpretation of the user's request within project context
Ask: "Is this understanding correct? What would you like to add?"
Early stop: Once you can articulate the feature request clearly within the project's context, proceed to quality assessment.
Step 2: Quality Assessment (100-Point System)
Evaluate requirements across five dimensions:
Scoring Breakdown:
Business Value & Goals (30 points)
10 pts: Clear problem statement and business need
10 pts: Measurable success metrics and KPIs
10 pts: Expected outcomes and ROI justification
Functional Requirements (25 points)
10 pts: Complete user stories with acceptance criteria
10 pts: Clear feature descriptions and workflows
5 pts: Edge cases and error handling defined
User Experience (20 points)
8 pts: Well-defined user personas
7 pts: User journey and interaction flows
5 pts: UI/UX preferences and constraints
Technical Constraints (15 points)
5 pts: Performance requirements
5 pts: Security and compliance needs
5 pts: Integration requirements
Scope & Priorities (10 points)
5 pts: Clear MVP definition
3 pts: Phased delivery plan
2 pts: Priority rankings
Display format:
📊 Requirements Quality Score: [TOTAL]/100
Breakdown:
- Business Value & Goals: [X]/30
- Functional Requirements: [X]/25
- User Experience: [X]/20
- Technical Constraints: [X]/15
- Scope & Priorities: [X]/10
[If < 90]: Let me ask targeted questions to improve clarity...
[If ≥ 90]: Excellent! Ready to generate PRD.
Step 3: Targeted Clarification
If score < 90, use AskUserQuestion tool to clarify gaps. Focus on the lowest-scoring area first.
Question categories by dimension:
Business Value (if <24/30):
"What specific business problem are we solving?"
"How will we measure success?"
"What happens if we don't build this?"
Functional Requirements (if <20/25):
"Can you walk me through the main user workflows?"
"What should happen when [specific edge case]?"
"What are the must-have vs. nice-to-have features?"
User Experience (if <16/20):
"Who are the primary users?"
"What are their goals and pain points?"
"Can you describe the ideal user experience?"
Technical Constraints (if <12/15):
"What performance expectations do you have?"
"Are there security or compliance requirements?"
"What systems need to integrate with this?"
Scope & Priorities (if <8/10):
"What's the minimum viable product (MVP)?"
"How should we phase the delivery?"
"What are the top 3 priorities?"
Ask 2-3 questions at a time using AskUserQuestion tool. Don't overwhelm.
Step 4: Iterative Refinement
After each user response:
Update understanding
Recalculate quality score
Show progress: "Great! That improved [area] from X to Y."
Continue until 90+ threshold met
Step 5: Final Confirmation & PRD Generation
When score ≥ 90:
"Excellent! Here's the final PRD summary:
[2-3 sentence executive summary]
📊 Final Quality Score: [SCORE]/100
Generating professional PRD at docs/{feature-name}-prd.md..."
Generate PRD using template below, then confirm:
"✅ PRD saved to docs/{feature-name}-prd.md
Review the document and let me know if any adjustments are needed."
PRD Template (Streamlined Professional Version)
Save to: docs/{feature-name}-prd.md
# Product Requirements Document: [Feature Name]**Version**: 1.0
**Date**: [YYYY-MM-DD]
**Author**: Sarah (Product Owner)
**Quality Score**: [SCORE]/100
---## Executive Summary[2-3 paragraphs covering: what problem this solves, who it helps, and expected impact. Include business context and why this feature matters now.]
---## Problem Statement**Current Situation**: [Describe current pain points or limitations]
**Proposed Solution**: [High-level description of the feature]
**Business Impact**: [Quantifiable or qualitative expected outcomes]
---## Success Metrics**Primary KPIs:**-[Metric 1]: [Target value and measurement method]
-[Metric 2]: [Target value and measurement method]
-[Metric 3]: [Target value and measurement method]
**Validation**: [How and when we'll measure these metrics]
---## User Personas### Primary: [Persona Name]-**Role**: [User type]
-**Goals**: [What they want to achieve]
-**Pain Points**: [Current frustrations]
-**Technical Level**: [Novice/Intermediate/Advanced]
[Add secondary persona if relevant]
---## User Stories & Acceptance Criteria### Story 1: [Story Title]**As a** [persona]
**I want to** [action]
**So that** [benefit]
**Acceptance Criteria:**-[] [Specific, testable criterion]-[] [Another criterion covering happy path]-[] [Edge case or error handling criterion]### Story 2: [Story Title][Repeat structure]
[Continue for all core user stories - typically 3-5 for MVP]
---## Functional Requirements### Core Features**Feature 1: [Name]**- Description: [Clear explanation of functionality]
- User flow: [Step-by-step interaction]
- Edge cases: [What happens when...]
- Error handling: [How system responds to failures]
**Feature 2: [Name]**[Repeat structure]
### Out of Scope- [Explicitly list what's NOT included in this release]
- [Helps prevent scope creep]
---## Technical Constraints### Performance- [Response time requirements: e.g., "API calls < 200ms"]
- [Scalability: e.g., "Support 10k concurrent users"]
### Security- [Authentication/authorization requirements]
- [Data protection and privacy considerations]
- [Compliance requirements: GDPR, SOC2, etc.]
### Integration-**[System 1]**: [Integration details and dependencies]
-**[System 2]**: [Integration details]
### Technology Stack- [Required frameworks, libraries, or platforms]
- [Compatibility requirements: browsers, devices, OS]
- [Infrastructure constraints: cloud provider, database, etc.]
---## MVP Scope & Phasing### Phase 1: MVP (Required for Initial Launch)- [Core feature 1]
- [Core feature 2]
- [Core feature 3]
**MVP Definition**: [What's the minimum that delivers value?]
### Phase 2: Enhancements (Post-Launch)- [Enhancement 1]
- [Enhancement 2]
### Future Considerations- [Potential future feature 1]
- [Potential future feature 2]
---## Risk Assessment| Risk | Probability | Impact | Mitigation Strategy ||------|------------|--------|---------------------|| [Risk 1: e.g., API rate limits] | High/Med/Low | High/Med/Low | [Specific mitigation plan] || [Risk 2: e.g., User adoption] | High/Med/Low | High/Med/Low | [Mitigation plan] || [Risk 3: e.g., Technical debt] | High/Med/Low | High/Med/Low | [Mitigation plan]
Implementation Guide
Prerequisites
›Claude Desktop or compatible AI client with skill support
›Clear understanding of task or problem to solve
›Willingness to iterate and refine outputs
Time Estimate
15-45 minutes depending on use case complexity
Steps
1Install skill using provided installation command
2Test with simple use case relevant to your work
3Evaluate output quality and relevance
4Iterate on prompts to improve results
5Integrate into regular workflow if valuable
Common Pitfalls
⚠Expecting perfect results without iteration
⚠Not providing enough context in prompts
⚠Using skill for tasks outside its intended scope
⚠Accepting outputs without review and validation
Best Practices
✓ Do
+Start with clear, specific prompts
+Provide relevant context and constraints
+Review and refine all outputs before using
+Iterate to improve output quality
+Document successful prompt patterns
✗ Don't
−Don't use without understanding skill limitations
−Don't skip validation of outputs
−Don't share sensitive information in prompts
−Don't expect skill to replace human judgment
💡 Pro Tips
★Be specific about desired format and style
★Ask for multiple options to choose from
★Request explanations to understand reasoning
★Combine AI efficiency with human expertise
When to Use This
✓ Use when
Use when skill capabilities match your task, clear ROI on time saved, and you can validate outputs. Best for repetitive tasks, learning, and quality improvement.
✗ Avoid when
Avoid when task requires deep expertise you can't validate, involves sensitive decisions, or when learning process is more valuable than speed of completion.
Learning Path
1Familiarize yourself with skill capabilities and limitations
2Start with low-risk, non-critical tasks
3Progress to more complex and valuable use cases
4Build expertise through regular use and experimentation
