Roadmap Build Planning

Instructions

Convert a product roadmap (Tiers 1-4 with S/M/L/XL effort estimates) into a phased, dependency-ordered build plan. Complete all steps for one product before starting the next.

Step 1 — Gather inputs

Read and internalize:

1. The product roadmap — tiered feature list with effort estimates, gap analysis, competitive context
2. Product context — CLAUDE.md, README.md, requirements docs, current architecture
3. Existing codebase state — what’s built, what’s partially built, known technical debt
4. Cross-product dependencies — shared library components, Skills, or infrastructure needed

Step 2 — Extract and classify roadmap items

Parse all roadmap features into a flat working list:

Field	Source
Feature name	Roadmap tier item text
Tier	1 (Critical), 2 (High Value), 3 (Strategic), 4 (Exploratory)
Effort	S / M / L / XL from roadmap
Rationale	Why it was prioritized (competitive parity, differentiation, AI-native)
Gap type	Parity, eroded differentiator, white-space, AI-native

Step 3 — Decompose into epics and tasks

For each feature, decompose based on effort size:

Effort	Decomposition depth
S (hours)	Single task. No epic wrapper needed. Define acceptance criteria only.
M (1-2 days)	1 epic with 2-4 tasks. Each task should be completable in a single session.
L (3-5 days)	1 epic with 4-8 tasks. Identify a spike task if technical approach is uncertain.
XL (1-2 weeks)	1-2 epics with 5-10 tasks each. Must include at least one spike and one integration test task.

For each task, define:

• Task name — verb-noun format (e.g., “Implement content scoring API endpoint”)
• Acceptance criteria — 2-4 testable statements
• Dependencies — which other tasks must complete first (by ID)
• Estimated effort — hours (S tasks) or sessions (M/L/XL tasks)

Step 4 — Identify dependencies and ordering constraints

Map three types of dependencies:

1. Technical dependencies — Task B requires Task A’s output (database schema before API, API before UI)
2. Shared infrastructure — Tasks requiring shared library components, new Skills, or platform changes
3. Knowledge dependencies — Spikes that must resolve before dependent implementation begins

Build a dependency list showing which tasks block which other tasks.

Step 5 — Sequence into phases

Group tasks into sequential phases:

Phase type	Contents	When
Phase 0: Foundation	Technical debt, infrastructure prerequisites, spikes for uncertain approaches	Before feature work begins
Phase 1: Critical Path	Tier 1 features in dependency order. Ship and verify before Phase 2.	First build cycle
Phase 2: High Value	Tier 2 features in dependency order. May run in parallel tracks if independent.	After Phase 1 verified
Phase 3: Strategic	Tier 3 features — plan at epic level only, defer task decomposition until Phase 2 is complete	Future cycle
Phase 4: Exploratory	Tier 4 — list only, no decomposition. Revisit at next roadmap refresh.	Backlog

Sequencing rules:

• Within a phase, order by dependency graph first, then by effort (smallest first for early momentum)
• Never start a dependent task before its prerequisite is verified
• Group related tasks into logical work streams when independent tracks exist
• A phase is “done” when all acceptance criteria pass and no regressions exist

Step 6 — Estimate phase durations

Apply the effort guide calibrated for a solo builder with AI agents:

Effort	Calendar time
S	2-4 hours
M	1-2 days
L	3-5 days
XL	1-2 weeks

Sum task estimates within each phase, then add:

• +20% buffer for integration and testing between tasks
• +1 day per spike for research resolution
• +0.5 days per phase for phase transition (verification, commit hygiene, documentation)

Step 7 — Flag risks and unknowns

For each phase, identify:

• Technical risks — uncertain approaches, unproven APIs, complex integrations
• Dependency risks — external services, shared library changes needed, upstream blockers
• Scope risks — features that may expand once implementation begins
• Mitigation — spike to reduce uncertainty, fallback approach, scope cap

Step 8 — Write the build plan

Save as [product-slug]-build-plan-YYYY-MM.md using the output template below.

Output Format

# [Product Name] — Build Plan
**Date:** [current date]
**Source roadmap:** [roadmap filename]
**Total features:** [count] across [tier count] tiers
**Estimated duration:** [total calendar estimate for Phases 0-2]

---

## Plan Summary

[3-5 sentences: what this plan covers, the phasing strategy, key dependencies,
biggest risks, and expected delivery timeline for the critical path]

---

## Phase 0: Foundation
**Duration estimate:** [X days]
**Goal:** [what this phase accomplishes]

### Tasks

| ID | Task | Effort | Dependencies | Acceptance Criteria |
|----|------|--------|-------------|-------------------|
| 0.1 | [task] | S | — | [criteria] |

---

## Phase 1: Critical Path (Tier 1)
**Duration estimate:** [X days]
**Goal:** [what ships at the end of this phase]

### Epic 1.1: [Feature Name] (from roadmap)
**Roadmap rationale:** [why this is Tier 1]
**Gap type:** [parity / eroded / white-space / AI-native]

| ID | Task | Effort | Dependencies | Acceptance Criteria |
|----|------|--------|-------------|-------------------|
| 1.1.1 | [task] | M | 0.1 | [criteria] |
| 1.1.2 | [task] | S | 1.1.1 | [criteria] |

### Epic 1.2: [Feature Name]
[... same structure ...]

---

## Phase 2: High Value (Tier 2)
[... same structure, epic/task level ...]

---

## Phase 3: Strategic (Tier 3) — Epic-Level Only
| Epic | Features | Estimated Effort | Key Dependencies |
|------|----------|-----------------|-----------------|
| 3.1 | [feature] | L | Phase 2 complete |

---

## Phase 4: Exploratory (Tier 4) — List Only
- [ ] [Feature] — [one-line rationale]

---

## Risk Register

| Risk | Phase | Likelihood | Impact | Mitigation |
|------|-------|-----------|--------|-----------|
| [risk] | 1 | Medium | High | [action] |

---

## Dependency Graph

[List critical-path dependencies as: Task A → Task B → Task C]

---

## New Skills / Shared Library Needed

| Skill or Component | Products Affected | When Needed |
|-------------------|------------------|-------------|
| [skill-id] | [products] | Phase [N] |

Inputs Required

1. Product roadmap file — the [product]-roadmap-YYYY-MM.md file
2. Product context files — CLAUDE.md, README.md, architecture docs
3. Output directory — where to save the build plan

Anti-Patterns

• Over-decomposing small items. An S-effort feature is a single task. Don’t create an epic with 5 tasks for adding a settings toggle.
• Planning Tier 3-4 at task level. These are too far out. Plan at epic level (Tier 3) or list only (Tier 4). Detailed planning becomes stale before execution.
• Ignoring dependency order. The most common build failure is starting features whose prerequisites aren’t done. The dependency graph is the most important artifact.
• Padding estimates. The 20% buffer is already built in. Don’t double-buffer individual tasks.
• Treating the plan as immutable. Plans are living documents. Update phase estimates after each phase completes. Reprioritize when the roadmap changes.
• Skipping spikes. If you’re uncertain about a technical approach, schedule a spike. Building on assumptions is the fastest path to rework.