prd-to-plan
PRD to Plan
Break a PRD into a phased implementation plan using vertical slices (tracer bullets). Output is a Markdown file in ./plans/.
Process
1. Locate the PRD
Ask the user where the PRD lives. It might be a local file path, a GitHub wiki page, a Notion or Confluence doc, or already in the conversation. The user may also provide links to Linear issues/projects or Figma designs for additional context.
Read or fetch the PRD from wherever it lives.
2. Gather external context
If the user provided references to external tools, use the available MCP tools to pull in additional context:
- Linear: The user may provide ticket codes (e.g.,
EO-1234) or URLs. Fetch related issues or project details to understand scope, priorities, and constraints. - Figma: The user may provide a Figma URL. Fetch design context and screenshots to understand UI requirements that inform how slices should be cut.
- Notion: The user may provide page titles or URLs. Search Notion by title if no URL is given. Fetch documents for supplementary specs or architectural notes.
Use this context alongside the PRD to inform phasing decisions. If no external references are provided, skip this step.
3. Explore the codebase
If you have not already explored the codebase, do so to understand the current architecture, existing patterns, and integration layers.
4. Identify durable architectural decisions
Before slicing, identify high-level decisions that are unlikely to change throughout implementation:
- Route structures / URL patterns
- Database schema shape
- Key data models
- Authentication / authorization approach
- Third-party service boundaries
These go in the plan header so every phase can reference them.
5. Draft vertical slices
Break the PRD into tracer bullet phases. Each phase is a thin vertical slice that cuts through ALL integration layers end-to-end, NOT a horizontal slice of one layer.
6. Quiz the user
Present the proposed breakdown as a numbered list. For each phase show:
- Title: short descriptive name
- User stories covered: which user stories from the PRD this addresses
Ask the user:
- Does the granularity feel right? (too coarse / too fine)
- Should any phases be merged or split further?
Iterate until the user approves the breakdown.
7. Write the plan file
Ask the user where they'd like to save this — for example a local file path, a GitHub wiki page, or a Notion doc. Use the template below, then save or deliver it appropriately for the chosen destination.
Source PRD:
Architectural decisions
Durable decisions that apply across all phases:
- Routes: ...
- Schema: ...
- Key models: ...
- (add/remove sections as appropriate)
Phase 1:
User stories:
What to build
A concise description of this vertical slice. Describe the end-to-end behavior, not layer-by-layer implementation.
Acceptance criteria
- Criterion 1
- Criterion 2
- Criterion 3
Phase 2:
User stories:
What to build
...
Acceptance criteria
- ...
More from evans-sam/skills
grill-me
Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
15prd-to-issues
Turn a PRD into independent ticket artifacts — GitHub issues, Linear tickets, local files, or Notion pages — with HITL/AFK tags and dependency links. Each ticket is a tracer-bullet vertical slice. Use when user wants to produce standalone work items from a PRD. Not for a live feature-building workflow.
12write-a-prd
Create a PRD through user interview, codebase exploration, and module design, then save as a local markdown document. Use when user wants to write a PRD, create a product requirements document, or plan a new feature.
12request-refactor-plan
Create a detailed refactor plan with tiny commits via user interview, then save it as a local markdown RFC document. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.
12git-guardrails-claude-code
Set up Claude Code hooks to block dangerous git and gh CLI commands before they execute. Use when user wants to prevent destructive git operations, block dangerous GitHub CLI actions (repo delete, pr merge, secret management, API mutations), or add git/gh safety hooks to Claude Code.
12ubiquitous-language
Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions "domain model" or "DDD".
11