home / skills / ozten / skills / tpm-roadmap-slice

tpm-roadmap-slice skill

/tpm-roadmap-slice

This skill generates a Phase PRD by extracting features from an annotated Vision PRD, detailing requirements, priorities, and traceability.

This is most likely a fork of the tpm-roadmap-slice skill from neversight
npx playbooks add skill ozten/skills --skill tpm-roadmap-slice

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.6 KB
---
name: tpm-roadmap-slice
description: Generate a Phase Spec/PRD by extracting features from an annotated Vision PRD. Use when user wants to create quarterly phase documentation, extract requirements from vision, plan a development phase, or decompose features into R-nnnn requirements. Requires annotated Vision PRD with F-nnn tags and Coverage Index.
---

# PRD Phase Generator

Extract features from a Vision PRD into a detailed Phase PRD with requirements, priorities, and traceability.

## Inputs Required

1. **Vision PRD** — Annotated with `[F-nnn]` tags (use `prd-vision-annotator` first if missing)
2. **Coverage Index** — To identify which features are `Planned` vs already assigned

## Capacity Defaults

Per phase, target approximately:
- **10 features** (F-nnn)
- **50 functional requirements** (R-nnnn)  
- **100 acceptance criteria** (AC-nnnn)

Adjust based on user input about team size or timeline.

## Workflow

1. **Select features** — Choose ~10 `Planned` features from Coverage Index
2. **Decompose requirements** — Extract R-nnnn from each feature's vision prose
3. **Assign priorities** — Must / Should / Could for each requirement
4. **Generate Phase PRD** — Using template in `assets/phase-prd-template.md`
5. **Update Coverage Index** — Mark selected features as `In Progress`

## Step 1: Feature Selection

Review `Planned` features in Coverage Index. Select based on:

- **Dependencies** — Foundation features before dependent ones
- **Cohesion** — Group related features (e.g., all calendar views together)
- **Business priority** — Per user input or stakeholder notes
- **Complexity** — Balance large and small features

Present selection to user for approval before proceeding.

## Step 2: Requirement Decomposition

For each selected feature, read the Vision PRD section and extract atomic requirements.

**Vision prose:**
> User selects quantity, enters name/email, receives confirmation email immediately.

**Becomes:**
```markdown
### R-0141: RSVP Quantity Selection
**Parent:** F-014
**Priority:** Must

Users shall select the number of seats when submitting an RSVP.

### R-0142: RSVP Data Collection  
**Parent:** F-014
**Priority:** Must

The RSVP form shall collect attendee name and email address.

### R-0143: RSVP Confirmation Email
**Parent:** F-014
**Priority:** Must

The system shall send a confirmation email upon RSVP submission.
```

**Decomposition guidelines:**
- One behavior per requirement
- Use "shall" for required behaviors
- Keep requirements testable and atomic
- ~5 requirements per feature is typical

## Step 3: Priority Assignment

| Priority | Meaning | Guidance |
|----------|---------|----------|
| **Must** | Required for phase to ship | Core functionality, blockers |
| **Should** | Expected but negotiable | Important but not critical |
| **Could** | Nice to have | Enhancements, polish |

Aim for roughly 60% Must, 30% Should, 10% Could.

## Step 4: Generate Phase PRD

Use template at `assets/phase-prd-template.md`. Structure:

1. Phase Overview (goals, scope, timeline)
2. Features in Scope (list with F-nnn)
3. Functional Requirements (R-nnnn grouped by feature)
4. Quality Requirements section (placeholder — populated by `prd-qa-enricher`)
5. Acceptance Criteria section (placeholder — populated by `prd-qa-enricher`)

## Requirement Numbering

Continue R-nnnn sequence across phases:
- Phase I: R-0001 → R-0089
- Phase II: R-0090 → R-0179
- Phase III: R-0180 → R-0269

Check previous Phase PRDs to find the last used R-nnnn.

## References

- `references/naming-conventions.md` — ID formats and rules
- `references/phasing-process.md` — Detailed extraction workflow

Overview

This skill generates a Phase PRD by extracting features from an annotated Vision PRD and producing atomic functional requirements, priorities, and traceability. It selects planned features from a Coverage Index, decomposes vision prose into R-nnnn requirements, and produces a phase-ready document with scope and acceptance placeholders. Output is tailored to quarterly phase planning and can update the Coverage Index to mark progress.

How this skill works

Provide an annotated Vision PRD with F-nnn tags and a Coverage Index that marks feature status. The skill selects ~10 Planned features (adjustable), reads each feature section, extracts atomic requirements phrased as testable R-nnnn entries, assigns Must/Should/Could priorities, and assembles a Phase PRD with feature lists, grouped requirements, and placeholders for QA/acceptance. It also flags which features are moved to In Progress and continues requirement numbering from the previous phase.

When to use it

  • Creating quarterly phase documentation from a product vision
  • Decomposing vision prose into testable R-nnnn requirements
  • Planning a development phase with balanced scope and priorities
  • Converting Coverage Index Planned features into actionable work
  • Preparing a Phase PRD for stakeholder review and handoff

Best practices

  • Provide a Vision PRD annotated with F-nnn tags and a current Coverage Index before running the skill
  • Aim for ~10 features, ~50 functional requirements, and ~100 acceptance criteria per phase as a starting guideline
  • Select features based on dependencies, cohesion, business priority, and complexity balance
  • Keep requirements atomic and testable; use ‘shall’ language for Must items
  • Target roughly 60% Must, 30% Should, 10% Could when assigning priorities
  • Verify last used R-nnnn in prior phase docs to continue numbering sequentially

Example use cases

  • Turn a product vision into a Phase I PRD ready for engineering planning
  • Extract and number requirements for a specific quarter from Planned features
  • Decompose large features into 5–10 atomic R-nnnn requirements each for sprint planning
  • Create a traceable scope list and mark selected features In Progress in the Coverage Index
  • Produce a Phase PRD that includes placeholders for QA and acceptance criteria enrichment

FAQ

What inputs are required to run this skill?

An annotated Vision PRD with F-nnn tags and a current Coverage Index that marks which features are Planned or already assigned.

How many features and requirements will the phase contain?

Default targets are ~10 features per phase, ~50 functional requirements, and ~100 acceptance criteria, adjustable for team size or timeline.

How are priorities assigned?

Requirements get Must/Should/Could priorities; aim for ~60% Must, ~30% Should, and ~10% Could based on shipping needs and blockers.