Skip to main content
skill CX Codex

roadmap-planning · rampstackco — Claude Code skill: planning and setup

roadmap-planning turns goals, backlog items, and constraints into a multi-quarter roadmap. Use it to rank work, map dependencies, and explain what stays out of scope.

MIT 283 installs ★ 1,107 updated 2026-10-19

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add rampstackco/claude-skills --skill roadmap-planning -a claude-code
Open on GitHub

What roadmap-planning does

This skill turns a pile of ideas, requests, and ongoing initiatives into a release plan with reasons behind the choices. It works through five layers: strategic themes, initiatives, sequencing, team capacity, and a “not now” list. Each initiative can be described by its outcome, rough size, confidence, and prerequisites.

The planning input is a set of team goals, a complete backlog, available capacity, known constraints, and a planning horizon. You can apply RICE, MoSCoW, Kano, cost of delay, or a strategy-and-impact score, then use the same method across the backlog. A strategy is required first; without it, the roadmap becomes a feature queue.

What it helps with

  • build a roadmap for a quarter or a year
  • rank initiatives inside strategic themes
  • sequence work around dependencies
  • match planned work to team capacity
  • justify which requests stay out of scope

Example prompts for the agent

  • Build a roadmap for next quarter from this backlog and our team goals.
  • Rank these initiatives, map their dependencies, and compare the plan with available capacity.
  • Create a “not now” list and state what would move each item into the roadmap.

How to install roadmap-planning

1Skills CLI (Vercel)

npx skills add rampstackco/claude-skills --skill roadmap-planning -a claude-code

2Manually: put the files in place

~/.claude/skills/roadmap-planning/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/roadmap-planning/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about roadmap-planning

How do I install roadmap-planning in Claude Code?

Run npx skills add rampstackco/claude-skills --skill roadmap-planning -a claude-code, then check ~/.claude/skills/roadmap-planning/SKILL.md.

What does roadmap-planning do?

It builds a multi-quarter roadmap from strategy, backlog items, constraints, and capacity. The skill ranks initiatives, orders dependent work, and records reasons for deferred requests.

What does roadmap-planning need before it can plan?

Prepare team goals or themes, the full candidate backlog, available capacity, constraints, and the planning horizon. Strategy comes first, or the result becomes a list of features.

Source text

SKILL.md · MIT
---
name: roadmap-planning
description: "Build a multi-quarter roadmap from a backlog of ideas, requests, and ongoing initiatives. Use this skill when planning the next quarter, sequencing dependent work, balancing build vs improve vs maintain, or making the case for what NOT to do. Triggers on roadmap, quarterly planning, what should we build next, sequencing, prioritization, OKR planning, capacity planning, what's on the roadmap, plan the year, what to ship next quarter. Also triggers when stakeholders are pulling in different directions and the team needs a defensible plan."
category: product
catalog_summary: "Quarterly planning, prioritization, dependency mapping"
display_order: 2
---

# Roadmap Planning

Take a pile of ideas, requests, and ongoing work. Produce a defensible plan for what to ship, when, and why. The output is a roadmap document plus the prioritization work that made it credible.

---

## When to use

- Planning the next quarter or the next year
- Sequencing work where some items depend on others
- Balancing new builds, improvements, and maintenance
- Saying no (or "not yet") to specific requests with a defensible reason
- Aligning a team around a single shared plan
- Communicating the plan to stakeholders outside the team
- Replanning after a strategy shift, a missed quarter, or new constraints

## When NOT to use

- Specifying a single feature for development (use `pm-spec-writing`)
- Validating whether the idea is worth building (use `ux-research`)
- Designing the feature itself (use `design-standards`)
- Writing the launch plan for a single initiative (use `launch-runbook`)
- Reviewing what shipped vs what was promised (use `after-action-report`)

---

## Required inputs

- The team's strategy or top-level goals (1 to 5 OKRs, themes, or pillars)
- The backlog: every candidate item, with at least a one-sentence description
- The team's capacity (people × time)
- Known constraints (deadlines, dependencies, hiring, budget)
- The planning horizon (a quarter, two quarters, a year)

If the strategy is missing, the roadmap will be a list of features, not a plan. Push back and get the strategy first. A roadmap without strategy is just a queue.

---

## The framework: 5 layers

Roadmaps fail at five different layers. A roadmap is only as good as its weakest one.

### Layer 1: Themes (the WHY)

Top-level groupings tied to strategy. Every theme answers: "If we do nothing else this period, this is the outcome we want."

Good themes are:
- Outcome-shaped, not feature-shaped ("Reduce time-to-first-value" beats "Build onboarding")
- Limited (3 to 5 max)
- Defensible (you can explain why this and not something else)
- Measurable (each maps to one or two metrics)

Bad themes look like a junk drawer: "Improvements," "Tech debt," "Misc." If it can't be defended in one sentence, it isn't a theme.

### Layer 2: Initiatives (the WHAT)

Multi-week or multi-month efforts that ladder up to a theme. Each initiative is bigger than a feature but smaller than a theme. Initiatives have:

- A clear outcome (the metric or result it should produce)
- A rough size (S / M / L / XL)
- A confidence rating (how sure are we this is the right initiative?)
- A dependency map (what has to happen first)

Initiatives are where stakeholders push hard. Resist the urge to commit to dates here. Commit to outcomes and rough sizes.

### Layer 3: Sequencing (the WHEN)

The order things happen. Sequencing is constrained by:

- **Dependencies** (X must finish before Y can start)
- **Capacity** (the team can do N things at once)
- **Calendar reality** (Q4 has fewer working days, certain teams have hiring gaps)
- **Strategic windows** (some launches need to land before a season, conference, or competitive moment)

Build the sequence after the prioritization. Putting things in time-order before deciding what matters produces a plan optimized for calendar fit, not impact.

### Layer 4: Capacity reality (the HOW MUCH)

Most roadmaps fail here. The plan looks good on paper but assumes 100% of every person's time on roadmap work. Real capacity is much lower.

Default capacity assumptions:

- Engineers: 60-70% of time on roadmap initiatives. The rest is meetings, reviews, on-call, support, interviews, debugging, ramp-up.
- Designers: 50-60%. Same reasons plus more cross-team support.
- PMs: 40-50%. The rest is planning, comms, stakeholder management, async writing.
- New hires: assume 50% of full capacity for the first quarter, 75% for the second, 100% from Q3 on.
- On-call rotations, leave, holidays: subtract before sizing.

If the math says the plan needs 100% of the team, the plan is wrong. Cut.

### Layer 5: Trade-off communication (the WHY NOT)

Every roadmap has a "Not now" list as important as the "Doing" list. The "Not now" is what makes the plan defensible.

Include:
- The top requests you considered and rejected
- The reason for each rejection (not the right time, not the right size, conflicts with theme, lower expected impact)
- The condition that would make it move into "Doing" (a metric, a date, a finished prerequisite)

Stakeholders pushing for cut items can argue against the rejection criteria, not the omission. That's a productive argument.

---

## Workflow

### Step 1: Anchor the strategy

Before touching the backlog, write down 3 to 5 themes. If the team's OKRs or strategy doc gives you these, copy them. If not, draft them and validate with the people who own strategy.

If the strategy is missing or vague, stop. Producing a roadmap against an unclear strategy is worse than producing nothing. Surface the gap.

### Step 2: Catalog the backlog

Every candidate gets:
- Name (one phrase)
- Theme it ladders up to (or "no theme" - flag for later)
- Source (request, OKR, retro, customer feedback, leadership ask, technical need)
- Rough size (S / M / L / XL)
- Owner or proposed owner
- Status (idea, validated, scoped, ready)

Items with "no theme" are warning flags. Either the theme list is incomplete, or the item should be cut.

### Step 3: Prioritize within each theme

Inside each theme, rank the initiatives. Use one prioritization framework consistently. Common ones:

- **RICE** (Reach × Impact × Confidence ÷ Effort): good for feature-heavy roadmaps
- **MoSCoW** (Must / Should / Could / Won't): good for fixed-deadline projects
- **Kano** (Threshold / Performance / Excitement): good for product investment decisions
- **Cost of delay**: good when timing matters more than effort
- **Strategic alignment + impact**: good for executive-facing roadmaps

The framework matters less than the consistency. Pick one. Use it the same way for every initiative. Document the math.

See [`references/prioritization-frameworks.md`](references/prioritization-frameworks.md) for the full breakdown.

### Step 4: Build the dependency map

For every "Doing" initiative, list what must happen first:
- Other initiatives
- Hiring
- External dependencies (vendor delivery, partner readiness)
- Research or validation work
- Infrastructure or platform readiness

Visualize as a graph or a Gantt-style sequence. Items with no dependencies can start immediately. Items with multiple unmet dependencies are warning flags.

### Step 5: Lay out the sequence

Now place initiatives in time. Use the dependency map. Use the capacity math. Match initiatives to people who can actually do them.

Default cadence: month-by-month for one quarter, quarter-by-quarter beyond that. Weekly is too granular for most roadmaps. Half-year buckets are too vague to commit to.

### Step 6: Validate with the team

Before sharing externally, validate with the people doing the work:
- Are the size estimates realistic?
- Are the dependencies correctly mapped?
- Are the capacity assumptions accurate?
- Is anyone overcommitted?

If the team says the plan is impossible, the plan is impossible. Adjust. Going to leadership with a plan the team disagrees with is how trust gets broken.

### Step 7: Write the "Not now" list

For every "Doing" item, name what got cut to make room. Document why. Document the trigger that would move it to "Doing" later.

### Step 8: Communicate

Different audiences need different views:

- **Team:** detailed sequence, owners, dependencies, sizes
- **Cross-functional partners:** themes, initiatives, rough timing, what they need to provide
- **Leadership:** themes, expected outcomes, key initiatives, top trade-offs
- **Public or customer-facing:** themes, no specific dates, "what to expect"

The same roadmap should produce all four. If it can't, the roadmap is incomplete.

---

## Failure patterns

**A list of features instead of a plan.** Themes are missing. The roadmap is a backlog with months attached. Fix: start over from strategy.

**Date-driven thinking.** "What can we ship by end of Q2?" instead of "What is the most important thing to do in Q2?" Dates are constraints, not goals.

**Capacity fantasy.** The plan adds up to 100% of every person's time. No room for support, interrupts, planning, or unknown unknowns. Roadmap dies in week three.

**Stakeholder pressure overrides strategy.** A loud customer or executive request gets prioritized because they pushed hard, not because it ladders up. The "Not now" list saves you here.

**Missing dependencies.** Initiative B depends on initiative A, but A is scheduled later. Or A depends on a hire that hasn't happened. The plan looks fine until execution starts.

**Too far out.** Specific commitments six months out create promises the team can't keep. Use ranges or themes for far horizons, specifics for near horizons.

**One framework for every level.** RICE for the whole roadmap including platform work, infra, and exploration. RICE is great for features, weak for foundational work. Use different lenses for different initiative types.

**No "Not now."** Stakeholders rediscover their cut requests every two weeks because there's no record of why they were cut. Document once, point to it forever.

---

## Output format

The roadmap document includes:

- **Strategy summary** (1 page or section): themes, why these themes, how they ladder to top-level goals
- **The plan** (the visual): a quarter-by-quarter or month-by-month view, color-coded by theme
- **Initiative briefs** (one per initiative): outcome, size, owner, dependencies, success metric
- **Capacity model**: who is doing what, with utilization math
- **Trade-offs and "Not now"**: top items considered and rejected, with reasons
- **Risks and assumptions**: what could derail the plan
- **Update cadence**: when the roadmap will be revisited (monthly is typical)

The roadmap is a living document. Plan to revisit it monthly. Replan it formally each quarter. Do not treat it as a contract.

---

## Reference files

- [`references/prioritization-frameworks.md`](references/prioritization-frameworks.md) - Detailed breakdown of RICE, MoSCoW, Kano, Cost of Delay, and Strategic Alignment frameworks. When to use each, how to apply them, common mistakes.

© rampstackco · MIT · rampstackco/claude-skills

Similar skills

All skills for Notes, tasks and projects →

roadmap-planning by other authors comes first.

roadmap-planning deanpeters roadmap-planning turns scattered feature backlogs and business goals into a sequenced product roadmap. Useful for planning priorities across quarters. CX Codex +1 3,900installs roadmap-prioritization RefoundAI roadmap-prioritization turns a messy backlog into an ROI-based plan: RICE or DRICE scoring, portfolio balance, and a roadmap draft. Useful when feature requests pile up faster than you can rank them. CX Codex +1 509installs technical-roadmap-planning aj-geddes technical-roadmap-planning builds a technical roadmap across quarters and years: architecture, infrastructure, stack investments. Useful before a big modernization push. CX Codex +1 584installs plan-bi-roadmap gtmagents plan-bi-roadmap — a Claude Code command that scores a BI initiative backlog by impact, effort, and strategic alignment, then drafts a governed roadmap. CX Codex +1 ★ 450repo stars scope jsmastery-pro The skill adds a /scope command that turns a product idea into a phased feature plan in docs/scope/, then reconciles that plan with what actually shipped. CX Codex +1 5,100installs sprint-planning official anthropics sprint-planning — a skill for Claude Code, Codex, Cursor, GitHub Copilot, and Gemini CLI that scopes work, estimates team capacity against PTO and meetings, and produces a sprint plan document. CX Codex +1 3,300installs outcome-roadmap phuryn outcome-roadmap rewrites feature-heavy roadmaps into outcome-focused statements tied to business and customer impact. Helps teams replace rigid feature lists with measurable strategic goals. CX Codex +1 10,200installs

From the same set102

The whole set →
stakeholder-communication stakeholder-communication — a skill for Claude Code, Cursor and other platforms: structures project status updates, executive summaries, decision requests and bad news messages. CX Codex +1 284installs discovery-research-synthesis discovery-research-synthesis turns interview transcripts, support tickets, and sales calls into actionable product decisions without vanity decks or lost signal. CX Codex +1 283installs experimentation-analytics experimentation-analytics — a skill for Claude Code, Codex, Cursor, Copilot, and Gemini CLI that walks through a finished experiment result panel before a ship-or-kill call. CX Codex +1 283installs data-warehouse-experimentation The data-warehouse-experimentation Claude Code skill explains how to run A/B tests in a data warehouse without vendor platforms. It covers user assignment, metric calculation, and statistical analysis. CX Codex +1 283installs cost-optimization cost-optimization — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that audits cloud and SaaS spend through five structured levers. CX Codex +1 283installs domain-strategy domain-strategy guides DNS architecture planning, canonical domain choices between apex and www, registrar security audits, and redirect strategies across multi-domain portfolios. CX Codex +1 283installs documentation-strategy documentation-strategy is a Claude Code skill that designs a documentation system for a team or product, helping choose what to document, where to store docs, and how to keep them current. CX Codex +1 282installs content-refresh-system content-refresh-system is a skill for Claude Code and other platforms that runs quarterly audits and prioritizes refreshes by signals. It triggers on content refresh questions, traffic erosion or lifecycle management. CX Codex +1 282installs

Project sponsors

Companies that keep this analytics open