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

> Learn how to write a PRD from a feature idea using a powerful 8-section template. Streamline stakeholder alignment and guide development effectively.

- Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills)
- Tags: how-to-guide
- Published: 2026-06-15

---

**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`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/commands/write-prd.md) and [`pm-execution/skills/create-prd/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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:

```bash

# 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:

```markdown

## 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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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.