How to Write a PRD from a Feature Idea: The Complete 8-Section Template

Writing a PRD from a feature idea follows a disciplined two-step workflow: invoke the /write-prd command to capture critical context, then apply the create-prd skill to generate a comprehensive eight-section document that aligns stakeholders and guides development.

Transforming a vague feature concept into a development-ready specification requires structured guidance. The phuryn/pm-skills repository provides an open-source product management framework that converts raw ideas into actionable Product Requirements Documents (PRDs) through a standardized template and command-driven workflow. By following the /write-prd command and adhering to the eight-section structure defined in the source code, product teams can eliminate ambiguity and ensure every PRD addresses user problems, success metrics, and technical constraints.

The Two-Step Workflow from Idea to Document

The phuryn/pm-skills implementation splits PRD creation into distinct capture and generation phases, enforced by the logic in pm-execution/commands/write-prd.md and pm-execution/skills/create-prd/SKILL.md.

Step 1: Capture the Feature Idea with /write-prd

Begin by invoking the /write-prd command with a one-line description, problem statement, or uploaded brief. According to the command implementation in pm-execution/commands/write-prd.md, the system prompts for the most critical missing details: the user problem, target users, success metrics, constraints, prior art, and scope. This ensures the PRD is grounded in reality rather than speculation before any writing begins.

Step 2: Generate the Document with create-prd

Once the necessary context is gathered, the command calls the create-prd skill, defined in pm-execution/skills/create-prd/SKILL.md. This skill expands the input into a complete eight-section markdown document saved as PRD-[product-name].md in the user's workspace (line 72 of the skill file).

The 8-Section PRD Structure

The create-prd skill enforces a standardized template with eight mandatory sections. Each section targets specific stakeholder needs and decision-making criteria:

Section	Content Requirements
1. Executive Summary	2-3 sentences answering "what, for whom, why now"
2. Background & Context	Problem space, market context, prior research, and triggers for the idea
3. Objectives & Success Metrics	Clear goals, non-goals, and SMART-style metrics (e.g., "increase NPS from 32 → 45 within 90 days")
4. Target Users & Segments	User personas, segment sizing, and jobs-to-be-done analysis
5. User Stories & Requirements	Prioritized story tables (P0 must-have, P1 should-have, P2 nice-to-have) with acceptance criteria
6. Solution Overview	High-level design, key features, optional tech stack, and assumptions
7. Open Questions	Unresolved items with assigned owners and deadlines
8. Timeline & Phasing	Milestones, dependencies, and phased rollout using relative timeframes rather than exact dates

Key Architectural Principles

The phuryn/pm-skills implementation enforces four critical quality gates during PRD generation, as defined in the source files:

• Step-by-step thinking: Before writing, the skill forces enumeration of the problem, audience, success criteria, and constraints (lines 20-24 of pm-execution/skills/create-prd/SKILL.md). This prevents speculative documentation.

• Accessible language: The template demands plain-English (grade-5 readability) to maintain stakeholder alignment (line 68).

• Iterative refinement: After the first draft, /write-prd offers follow-up actions including scope tightening, pre-mortem risk analysis, or story decomposition (lines 101-108).

• File persistence: Generated PRDs are automatically saved as PRD-[product-name].md to ensure version control and traceability (line 72).

Practical Implementation: Writing a PRD from an SSO Feature Idea

The following example demonstrates how to write a PRD from a feature idea for an enterprise single sign-on capability:

First, invoke the command with your feature idea:

# Invoke the /write-prd command with a simple feature description

/write-prd "SSO support for enterprise customers"

The system will prompt for clarifying questions regarding user pain points and constraints, then generate a structured markdown document:

## Product Requirements Document: SSO Support for Enterprise Customers

### 1. Executive Summary

Enable single-sign-on (SSO) for enterprise accounts to reduce login friction and improve security compliance.

### 2. Background & Context

Enterprise customers have repeatedly requested centralized authentication. Competitors already offer SSO, creating churn risk for accounts with >100 users.

### 3. Objectives & Success Metrics

- **Goal:** Increase enterprise adoption by 30% within 6 months
- **Success Metric:** Reduce login-failure tickets from 5% to <1% post-launch

### 4. Target Users & Segments

- **Primary Segment:** IT administrators at mid-market SaaS firms (≈200k potential users)

### 5. User Stories & Requirements

| Priority | User Story | Acceptance Criteria |
|----------|------------|---------------------|
| P0 | As an admin, I can link my IdP to the product so my team uses existing credentials | Successful login via SAML 2.0 with no password prompts |
| P1 | As an admin, I can configure SSO settings in the UI | UI contains fields for IdP metadata and test connection button |

### 6. Solution Overview

- **UX:** Add SSO settings page under Account → Security
- **Key Features:** IdP metadata upload, SAML assertion validation, fallback login
- **Assumptions:** Customers maintain SAML-compatible identity providers

### 7. Open Questions

| Question | Owner | Deadline |
|----------|-------|----------|
| Which SAML versions to support? | Security lead | 2024-04-15 |

### 8. Timeline & Phasing

- **Phase 1 (4 weeks):** Core SAML flow and admin UI
- **Phase 2 (2 weeks):** Documentation and pilot with 3 enterprise accounts

Source File Reference

The PRD generation logic exists across three primary files in the phuryn/pm-skills repository:

• pm-execution/skills/create-prd/SKILL.md: Defines the eight-section template and step-by-step thinking process (lines 20-24, 68, 72).
• pm-execution/commands/write-prd.md: Implements the user-facing command that gathers feature ideas and orchestrates the create-prd skill invocation.
• pm-execution/README.md: Provides the execution suite overview, contextualizing PRDs within broader product management workflows including pre-mortems and red-team analysis.

Summary

Writing a PRD from a feature idea using the phuryn/pm-skills framework ensures documentation quality through enforced structure and iterative refinement:

• Invoke /write-prd to capture critical context before writing begins
• The create-prd skill generates an eight-section document covering summary, background, metrics, users, stories, solution, questions, and timeline
• Step-by-step thinking (lines 20-24) prevents speculative requirements
• Grade-5 readability standards (line 68) ensure stakeholder alignment
• Automatic file persistence as PRD-[product-name].md maintains version control
• Post-generation workflows support scope tightening and risk analysis (lines 101-108)

Frequently Asked Questions

What command initiates the process of writing a PRD from a feature idea in phuryn/pm-skills?

The /write-prd command serves as the entry point. According to pm-execution/commands/write-prd.md, you invoke this command followed by a one-line feature description, problem statement, or uploaded brief to initiate the context-gathering phase that precedes document generation.

How does the phuryn/pm-skills template ensure PRDs are actionable rather than speculative?

The create-prd skill enforces step-by-step thinking (lines 20-24 of pm-execution/skills/create-prd/SKILL.md), requiring explicit enumeration of the user problem, target audience, success criteria, and technical constraints before generating any document content. This prevents scope creep and ensures ground-truthed requirements.

Can the generated PRD be modified after the initial creation?

Yes. The workflow supports iterative refinement through follow-up actions available immediately after generation (lines 101-108). These actions include scope tightening, pre-mortem risk analysis, and story decomposition to refine the initial PRD-[product-name].md file.

What readability standard does the phuryn/pm-skills PRD template enforce?

The template mandates grade-5 readability (line 68 of pm-execution/skills/create-prd/SKILL.md), requiring plain-English explanations that keep all stakeholders—including non-technical teams—aligned on requirements and implementation details.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}