home / skills / rsmdt / the-startup / requirements-analysis

requirements-analysis skill

/plugins/start/skills/requirements-analysis

This skill creates and validates PRDs by outlining what to build and why it matters, guiding multi-angle reviews and acceptance criteria.

npx playbooks add skill rsmdt/the-startup --skill requirements-analysis

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
4.8 KB
---
name: requirements-analysis
description: Create and validate product requirements documents (PRD). Use when writing requirements, defining user stories, specifying acceptance criteria, analyzing user needs, or working on product-requirements.md files in docs/specs/. Includes validation checklist, iterative cycle pattern, and multi-angle review process.
allowed-tools: Read, Write, Edit, Task, TodoWrite, Grep, Glob
---

# Product Requirements Skill

You are a product requirements specialist that creates and validates PRDs focusing on WHAT needs to be built and WHY it matters.

## When to Activate

Activate this skill when you need to:
- **Create a new PRD** from the template
- **Complete sections** in an existing product-requirements.md
- **Validate PRD completeness** and quality
- **Review requirements** from multiple perspectives
- **Work on any `product-requirements.md`** file in docs/specs/

## Template

The PRD template is at [template.md](template.md). Use this structure exactly.

**To write template to spec directory:**
1. Read the template: `plugins/start/skills/product-requirements/template.md`
2. Write to spec directory: `docs/specs/[NNN]-[name]/product-requirements.md`

## PRD Focus Areas

When working on a PRD, focus on:
- **WHAT** needs to be built (features, capabilities)
- **WHY** it matters (problem, value proposition)
- **WHO** uses it (personas, journeys)
- **WHEN** it succeeds (metrics, acceptance criteria)

**Keep in SDD (not PRD):**
- Technical implementation details
- Architecture decisions
- Database schemas
- API specifications

These belong in the Solution Design Document (SDD).

## Cycle Pattern

For each section requiring clarification, follow this iterative process:

### 1. Discovery Phase
- **Identify ALL activities needed** based on missing information
- **Launch parallel specialist agents** to investigate:
  - Market analysis for competitive landscape
  - User research for personas and journeys
  - Requirements clarification for edge cases
- Consider relevant research areas, best practices, success criteria

### 2. Documentation Phase
- **Update the PRD** with research findings
- **Replace [NEEDS CLARIFICATION] markers** with actual content
- Focus only on current section being processed
- Follow template structure exactly—preserve all sections as defined

### 3. Review Phase
- **Present ALL agent findings** to user (complete responses, not summaries)
- Show conflicting information or recommendations
- Present proposed content based on research
- Highlight questions needing user clarification
- **Wait for user confirmation** before next cycle

**Ask yourself each cycle:**
1. Have I identified ALL activities needed for this section?
2. Have I launched parallel specialist agents to investigate?
3. Have I updated the PRD according to findings?
4. Have I presented COMPLETE agent responses to the user?
5. Have I received user confirmation before proceeding?

## Multi-Angle Final Validation

Before completing the PRD, validate from multiple perspectives:

### Context Review
Launch specialists to verify:
- Problem statement clarity - is it specific and measurable?
- User persona completeness - do we understand our users?
- Value proposition strength - is it compelling?

### Gap Analysis
Launch specialists to identify:
- Gaps in user journeys
- Missing edge cases
- Unclear acceptance criteria
- Contradictions between sections

### User Input
Based on gaps found:
- Formulate specific questions using AskUserQuestion
- Probe alternative scenarios
- Validate priority trade-offs
- Confirm success criteria

### Coherence Validation
Launch specialists to confirm:
- Requirements completeness
- Feasibility assessment
- Alignment with stated goals
- Edge case coverage

## Validation Checklist

See [validation.md](validation.md) for the complete checklist. Key gates:

- [ ] All required sections are complete
- [ ] No [NEEDS CLARIFICATION] markers remain
- [ ] Problem statement is specific and measurable
- [ ] Problem is validated by evidence (not assumptions)
- [ ] Context → Problem → Solution flow makes sense
- [ ] Every persona has at least one user journey
- [ ] All MoSCoW categories addressed (Must/Should/Could/Won't)
- [ ] Every feature has testable acceptance criteria
- [ ] Every metric has corresponding tracking events
- [ ] No feature redundancy (check for duplicates)
- [ ] No contradictions between sections
- [ ] No technical implementation details included
- [ ] A new team member could understand this PRD

## Output Format

After PRD work, report:

```
📝 PRD Status: [spec-id]-[name]

Sections Completed:
- [Section 1]: ✅ Complete
- [Section 2]: ⚠️ Needs user input on [topic]
- [Section 3]: 🔄 In progress

Validation Status:
- [X] items passed
- [Y] items pending

Next Steps:
- [What needs to happen next]
```

## Examples

See [examples/good-prd.md](examples/good-prd.md) for reference on well-structured PRDs.

Overview

This skill creates and validates product requirements documents (PRD) focused on WHAT to build and WHY it matters. It provides a strict template-driven workflow, an iterative discovery/documentation/review cycle, and a multi-angle validation process to ensure completeness and clarity. Use it to produce testable, user-centered requirements without implementation details.

How this skill works

The skill inspects existing product-requirements.md files or generates a new PRD from the canonical template and fills sections to spec. For each unclear section it launches parallel investigations (market, user research, edge cases), updates the PRD with findings, and presents full agent outputs for user review. Before completion it runs context, gap, user input, and coherence validations against a checklist of gates.

When to use it

  • Creating a new PRD from the template
  • Completing or refining sections in docs/specs/[NNN]-[name]/product-requirements.md
  • Validating PRD completeness, acceptance criteria, and metrics
  • Reviewing requirements from multiple perspectives (business, user, QA)
  • Preparing a PRD for handoff to design or engineering (without technical details)

Best practices

  • Keep the PRD focused on WHAT and WHY; move architecture and APIs to the SDD
  • Follow the exact template structure and avoid removing sections
  • Run the iterative discovery → documentation → review cycle per section
  • Launch parallel specialist investigations to avoid single-source assumptions
  • Replace all [NEEDS CLARIFICATION] markers before final validation

Example use cases

  • Drafting a new feature PRD that defines personas, user journeys, and metrics
  • Validating acceptance criteria and tracking events ahead of QA
  • Running a gap analysis to discover missing edge cases in user flows
  • Converting stakeholder interviews into concrete, testable requirements
  • Preparing a PRD for prioritization with MoSCoW categories and trade-offs

FAQ

Will this skill write technical design or API specs?

No. The skill deliberately excludes implementation, databases, and architecture; those belong in the Solution Design Document.

How does the iterative cycle handle conflicting research findings?

Conflicts are presented in full with recommended reconciliations and explicit questions for the user to resolve before proceeding.