ClawHub

Phy Prd Writer

Other

Multi-turn PRD (Product Requirements Document) creation assistant. Asks clarifying questions one at a time to gather requirements, then generates a complete, professional PRD. Use when starting a new feature, product, or project. Triggers on 'write PRD', 'create PRD', 'new feature', 'product requirements', or '/prd'.

Install

openclaw skills install phy-prd-writer

PRD Writer - Multi-Turn Requirements Gathering

Overview

Guide users through creating a professional PRD by asking focused questions one at a time. The goal is to produce a complete, actionable PRD that serves as the single source of truth for the team.

The Process

Phase 1: Problem Discovery (2-3 questions)

Start by understanding the core problem:

  1. Problem Statement: "What specific problem are you trying to solve? Describe the user pain point."
  2. Why Now: "Why is this important to solve now? What happens if we don't solve it?"
  3. Existing Solutions: "How are users currently solving this problem (workarounds, competitors)?"

Phase 2: User & Market (2-3 questions)

  1. Target Users: Ask who the primary users are. Offer common persona types:

    • End consumers (B2C)
    • Business users (B2B)
    • Internal team members
    • Developers/Technical users
    • Other (specify)

  2. User Context: "In what context will users encounter this? (e.g., mobile on-the-go, desktop at work, specific workflow)"

  3. Market Size/Impact: "How many users will this affect? Is this a core feature or nice-to-have?"

Phase 3: Success Metrics (1-2 questions)

  1. Definition of Success: Ask what success looks like. Offer metric types:

    • User engagement (DAU, retention, time spent)
    • Business metrics (revenue, conversion, cost reduction)
    • Technical metrics (performance, reliability, error rates)
    • User satisfaction (NPS, CSAT, support tickets)

  2. Specific Targets: "What specific numbers would indicate success? (e.g., 'reduce load time to <2s', 'increase conversion by 15%')"

Phase 4: Scope Definition (2-3 questions)

  1. Core Features: "What are the MUST-have features for v1? List the absolute minimum for launch."

  2. Out of Scope: "What should we explicitly NOT build in this phase? (This prevents scope creep)"

  3. Future Considerations: "What features might come in v2/v3? (Park these for later)"

Phase 5: Constraints & Dependencies (1-2 questions)

  1. Technical Constraints: Ask about limitations:

    • Existing tech stack requirements
    • Integration dependencies
    • Performance requirements
    • Security/compliance needs
    • Budget/resource constraints

  2. Timeline: "What's the target launch date or deadline? Any external dependencies?"

Phase 6: Prioritization (1 question)

  1. MoSCoW Ranking: Present the collected features and ask user to categorize:
    • Must: Essential for launch
    • Should: Important but can defer if needed
    • Could: Nice-to-have
    • Won't: Explicitly excluded

Questioning Guidelines

  • One question at a time - Never overwhelm with multiple questions
  • Use AskUserQuestion tool with multiple choice options when categories are clear
  • Offer "Other" option for open-ended responses
  • Summarize understanding after each phase before moving on
  • Allow backtracking - If user wants to revise earlier answers, accommodate
  • Skip if already answered - If user provided info upfront, don't re-ask

Example Question Flow

Q1: "What problem are you solving?"
→ User describes pain point

Q2: "Why is solving this urgent now?"
→ User explains timing

[Summary]: "So we're solving [X] because [Y]. Correct?"
→ User confirms or corrects

Q3: "Who are the primary users?"
→ [Multiple choice with AskUserQuestion]

... continue through phases ...

Output: PRD Document

After gathering all information, generate a complete PRD with this structure:

# PRD: [Product/Feature Name]

## Metadata
| Field | Value |
|-------|-------|
| Author | [User name] |
| Status | Draft |
| Created | [Date] |
| Last Updated | [Date] |

## 1. Problem Statement
[Clear description of the problem and why it matters]

### Why Now?
[Urgency and timing rationale]

## 2. Goals & Success Metrics
### Objectives
- [SMART goal 1]
- [SMART goal 2]

### Success Metrics (KPIs)
| Metric | Current | Target | Timeline |
|--------|---------|--------|----------|
| [Metric 1] | [Baseline] | [Goal] | [When] |

## 3. User & Market
### Target Users
[Primary persona description]

### User Stories
- As a [user type], I want [action] so that [benefit]

### Competitive Landscape
[How users solve this today]

## 4. Scope
### In Scope (v1)
- [Must-have feature 1]
- [Must-have feature 2]

### Out of Scope
- [Explicitly excluded 1]
- [Explicitly excluded 2]

### Future Considerations (v2+)
- [Deferred feature 1]

## 5. Feature Requirements
### Feature: [Name]
**Priority**: Must/Should/Could
**Description**: [What it does]
**Acceptance Criteria**:
- [ ] [Criterion 1]
- [ ] [Criterion 2]

## 6. Technical Constraints
- [Constraint 1]
- [Constraint 2]

### Dependencies
- [External dependency 1]

## 7. Timeline & Milestones
| Milestone | Target Date |
|-----------|-------------|
| Design Complete | [Date] |
| Development Start | [Date] |
| Beta/Testing | [Date] |
| Launch | [Date] |

## 8. Open Questions
- [Unresolved question 1]
- [Unresolved question 2]

## 9. Appendix
[Any additional context, wireframes references, research links]

After PRD Generation

Step 1: Save & Share

  1. Save PRD: Ask where to save (docs/prd/, docs/specs/, or custom path)
  2. Commit to git: Create a commit with the PRD document
  3. Share for review: Suggest sending to stakeholders for feedback

Step 2: Design (if UI/UX involved)

Ask: "Does this feature need UI design?"

  • Yes → Suggest using /brainstorming skill to explore design approaches
  • Yes + need mockups → Suggest /frontend-design for wireframes/prototypes
  • No → Skip to implementation planning

Step 3: Technical Architecture

Ask: "Is this feature complex enough to need a technical architecture design?"

  • Complex feature → Use architect subagent for system design
    • Output: component breakdown, data flow, tech selection, interface design
  • Simple feature → Skip to task breakdown

Step 4: Break into Tasks

Ask: "Do you want to break the PRD into development tasks?"

  • Yes → Use planner subagent to create implementation plan
    • Break down based on architecture design
    • Generate TaskCreate items with:
      • Clear acceptance criteria from PRD
      • Dependencies marked (blockedBy)
      • Priority from MoSCoW ranking

Step 5: Implementation

Once tasks are created:

  1. planner → Detailed implementation plan per task
  2. Write code
  3. code-reviewer → Auto-review before commit
  4. test-creator → Generate tests
  5. security-reviewer → If sensitive code

Step 6: Validation

Before shipping:

  1. e2e-runner → Automated testing
  2. Compare against PRD success metrics
  3. Update PRD status to "Shipped"

Workflow Cheatsheet

Phase 0: Requirements
/prd-writer          → Multi-turn Q&A to gather requirements, generate PRD

Phase 1: Planning
architect agent      → Technical architecture design (how to build it)
planner agent        → Break into implementation tasks (what to build)

Phase 2: Implementation
[write code]

Phase 3: Quality Assurance (parallel)
code-reviewer + security-reviewer  → simultaneous review
test-creator                       → add tests

Phase 4: Validation
e2e-runner           → end-to-end validation
doc-updater          → update documentation

PRD status → Shipped

Handoff Prompts

After PRD is complete, offer these next actions:

PRD generated! What would you like to do next?

1. UI/UX Design Exploration (/brainstorming) - if there's an interface
2. Technical Architecture Design (architect) - decide how to build it
3. Break into Development Tasks (planner) - decide what to build
4. Save for now, continue later

Use AskUserQuestion to let user choose.

Key Principles

  • Problem before solution - Never jump to features before understanding the problem
  • Quantify success - Vague goals lead to vague outcomes
  • Explicit exclusions - What you DON'T build is as important as what you do
  • Living document - Remind user to update as requirements evolve
  • YAGNI - Ruthlessly cut features that aren't essential for v1

Lenny's Podcast Wisdom Integration

When writing PRDs, automatically surface relevant wisdom from top product leaders. Use these to enrich the PRD process:

Phase 1: Problem Discovery

April Dunford: "Really great positioning feels so clear, so simple - of course that's what it is."

  • Ask: What are competitive alternatives (including status quo)?
  • Remember: 40% of B2B deals are lost to "no decision" - you're competing with spreadsheets!

Shreyas Doshi: "Most execution problems are actually strategy problems."

  • If user describes execution problems, dig deeper into strategy clarity

Phase 2: Why Now?

Brian Chesky: "If you build a great product and no one knows about it, did you even build a product?"

  • Ask: How will you tell the story of this product?
  • Think about every release as a chapter of a story

Phase 3: Scope Definition

Brian Chesky: "Five teams should do one thing rather than one team do five things."

  • Ruthlessly cut scope
  • Ask: "What would you cut to concentrate on fewer things?"

Brian Chesky: "The best way to slow a project down is add more people to it."

  • Small team, focused scope = faster delivery

Phase 4: Success Metrics

Marty Cagan: "Optimization is easier than innovation; but only innovation wins."

  • Don't just optimize metrics - ask what new value is created
  • Everything in the backlog is a bet - make better bets

Phase 5: Risk Assessment

Shreyas Doshi: Pre-mortem framework After PRD is drafted, suggest running a pre-mortem:

  • Tigers: Real threats that could kill the project
  • Paper Tigers: Seeming threats that aren't real
  • Elephants: Things nobody is talking about

Ask: "What 3 tigers (real threats) could derail this project?"

Phase 6: Prioritization

Shreyas Doshi: LNO Framework

  • L (Leverage): Which features give 10-100x return? Focus here.
  • N (Neutral): Standard features, 1x return
  • O (Overhead): Features with less return than effort

Reference: Wisdom Source

All wisdom sourced from Lenny's Podcast. If you have local transcripts, search them for additional context.

Quick Mode

If user says "quick PRD" or "lean PRD", use abbreviated flow:

  1. Problem (1 question)
  2. Users (1 question)
  3. Success metric (1 question)
  4. Must-have features (1 question)
  5. Generate One-Pager PRD format

Author

Canlah AI — Run performance marketing without breaking your brand.