How to Use the prd-to-plan Skill to Create Multi-Phase Implementation Plans

The prd-to-plan skill converts a Product Requirements Document (PRD) into a structured, multi-phase implementation plan using tracer-bullet vertical slices that cross all architectural layers.

The prd-to-plan skill from the mattpocock/skills repository transforms high-level product requirements into actionable development roadmaps. According to prd-to-plan/SKILL.md, this skill automates the planning process by applying a systematic six-step methodology that emphasizes end-to-end vertical slices over traditional horizontal layer-by-layer development.

Installing the prd-to-plan Skill

Before generating implementation plans, you must install the skill into your environment. The skill is distributed via npm and integrates with the Opencode platform.

Install the skill using the following command:

npx skills@latest add mattpocock/skills/prd-to-plan

Once installed, invoke the skill interactively. The agent will automatically prompt you for the PRD if it is not already loaded in the conversation context.

skills run prd-to-plan

The Six-Step Workflow

As defined in prd-to-plan/SKILL.md, the skill executes a rigorous six-step process to transform PRD documents into executable plans. Each step builds upon the previous to ensure architectural coherence and implementation clarity.

Confirm the PRD Is in Context

The workflow begins by verifying that the Product Requirements Document is available within the conversation context. This ensures the agent has access to user stories, acceptance criteria, and functional requirements before proceeding with architectural analysis.

Explore the Codebase

The skill analyzes the existing codebase to understand current architecture, integration layers, and technical constraints. This exploration phase identifies existing patterns for routes, data models, and third-party integrations that will influence the implementation strategy.

Identify Durable Architectural Decisions

Before drafting phases, the skill isolates durable architectural decisions that will remain constant across all implementation phases. These include:

• Routes: API endpoint structures and URL patterns
• Schema: Database table definitions and relationships
• Key models: Core domain entities and business logic
• Auth: Authentication and authorization boundaries
• Third-party boundaries: External service integrations and APIs

Identifying these decisions early prevents rework and establishes the structural foundation for the entire plan.

Draft Vertical Slices (Tracer-Bullet Phases)

Using the tracer-bullet methodology, the skill drafts implementation phases as vertical slices rather than horizontal layers. Each slice must cross all architectural layers—schema, API, UI, and tests—to deliver a thin, end-to-end slice of demonstrable functionality.

According to the vertical-slice rules in prd-to-plan/SKILL.md, each phase avoids fragile implementation details while surfacing the durable decisions identified earlier. This approach ensures that each phase produces working software that validates the architecture.

Quiz the User on the Breakdown

The skill presents the proposed phase breakdown to the user for validation. This iterative review process continues until the granularity of each phase meets the project's specific requirements and constraints. The quizzing phase ensures that implementation complexity aligns with team capacity and sprint schedules.

Write the Plan File

Finally, the skill generates the implementation plan as a Markdown file in the ./plans/ directory. If the directory does not exist, the skill creates it automatically. Files follow the naming convention ./plans/feature-name.md, such as ./plans/user-onboarding.md.

The Plan Template Structure

The output follows a predefined Markdown template that includes standardized sections for architectural documentation and phase-specific implementation details.

Architectural Decisions Section

This section documents the fixed structures identified during the exploration phase:

• Route definitions and API versioning
• Database schema modifications
• Core model relationships
• Authentication requirements

Phase Sections

Each phase includes:

• Title: Descriptive name of the vertical slice
• User stories: Specific PRD requirements covered by this phase
• What to build: Concise description of the end-to-end functionality
• Acceptance criteria: Checkboxes for validation (e.g., [ ] API endpoint validates input)

Example Output

When executed against a user onboarding PRD, the skill generates a plan similar to this fragment:

# Plan: User Onboarding

## Architectural decisions

- **Routes**: /api/v1/onboarding, /welcome
- **Schema**: users table includes `onboarding_status`
- **Key models**: User, OnboardingSession

## Phase 1: Collect Basic Info

**User stories**: As a new user, I can submit my email and name.

### What to build

Create an end-to-end flow that captures name/email, stores it, and returns a welcome token.

### Acceptance criteria

- [ ] API endpoint validates input
- [ ] Data persists to `users` table
- [ ] UI shows success toast

Summary

• The prd-to-plan skill in mattpocock/skills converts PRDs into phased implementation plans using a six-step workflow defined in prd-to-plan/SKILL.md.
• It employs tracer-bullet vertical slices that cross all architectural layers (schema, API, UI, tests) to deliver demonstrable functionality in each phase.
• The skill identifies durable architectural decisions (routes, schema, models, auth) before drafting phases to ensure architectural consistency.
• Output is written to ./plans/ as Markdown files following a standardized template with sections for architectural decisions and phase-specific acceptance criteria.
• Install via npx skills@latest add mattpocock/skills/prd-to-plan and run with skills run prd-to-plan.

Frequently Asked Questions

What is the tracer-bullet methodology mentioned in the skill?

The tracer-bullet methodology is an approach to software development where each implementation phase delivers a thin, vertical slice of functionality that spans all architectural layers—from database schema to user interface. According to prd-to-plan/SKILL.md, this ensures each phase produces working, demonstrable software rather than building complete horizontal layers (like finishing all database work before starting UI work) that cannot be validated until the end of the project.

How does prd-to-plan differ from traditional project planning tools?

Unlike traditional planning tools that often organize work by technical layer (frontend, backend, database), the prd-to-plan skill organizes work by user-centric vertical slices that align with the PRD's user stories. As implemented in mattpocock/skills, it specifically requires each phase to cross schema, API, UI, and test layers simultaneously, ensuring architectural decisions are validated early through working code rather than documentation alone.

Can I customize the output template for the generated plans?

The skill utilizes a predefined Markdown template specified in prd-to-plan/SKILL.md that includes sections for Architectural decisions, Phase breakdowns, and Acceptance criteria. While the skill automatically populates this template based on the PRD content and codebase analysis, the template structure itself (including the <plan-template> definitions in the SKILL.md file) provides a consistent format that can be modified by forking the skill repository and adjusting the template definitions.

Where are the generated implementation plans stored?

The skill writes all generated plans to the ./plans/ directory relative to your project root. If this directory does not exist, the skill creates it automatically during execution. Each plan is saved as a Markdown file named after the feature being implemented, following the pattern ./plans/feature-name.md, such as ./plans/user-onboarding.md or ./plans/payment-processing.md.

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