# Product Management Roadmap > Use when managing products and building roadmaps. - Skill: `loopyluci/product-management-roadmap` (Agent Skill) - Install (CLI): `npx skillmds@latest add loopyluci/product-management-roadmap` - Raw SKILL.md: https://api.skillmd.com/api/skills/loopyluci/product-management-roadmap/raw - Safety review: pending (external: skill-scanner PASS, skillspector PASS) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Product & Planning - License: MIT - Author: LoopyLuci (https://skillmd.com/u/loopyluci) - Updated: 2026-09-08 - Page: https://skillmd.com/skills/loopyluci/product-management-roadmap --- # Product Management and Roadmapping Managing products end-to-end — from strategy and roadmapping through backlog prioritization, user stories, releases, and stakeholder communication. ## When to Use - Building and maintaining a product roadmap - Prioritizing features and managing backlog - Writing user stories and acceptance criteria - Running product discovery and validation - Communicating product plans to stakeholders ## Roadmap Framework ``` Now (0-3 months) — Committed, concrete, in progress Next (3-6 months) — Likely but not committed, being validated Later (6-12 months) — Exploration, not yet scoped ``` ## Prioritization Frameworks ```python from typing import Dict, List, Optional from datetime import datetime, timedelta import math class Prioritization: """Score and prioritize features using multiple frameworks.""" @staticmethod def rice(features: List[Dict]) -> List[Dict]: """Score features using RICE: Reach, Impact, Confidence, Effort.""" scored = [] for f in features: reach = f.get('reach', 0) # How many users per quarter impact = f.get('impact', 2) # 1-massive, 2-high, 3-medium, 4-low confidence = f.get('confidence', 2) # 1-high, 2-medium, 3-low effort = f.get('effort', 10) # Person-weeks # Invert impact and confidence (lower = better) impact_score = 4 - impact confidence_score = 4 - confidence rice_score = (reach * impact_score * confidence_score) / max(effort, 1) scored.append({ 'feature': f.get('name', ''), 'reach': reach, 'impact': impact, 'confidence': confidence, 'effort': effort, 'rice_score': round(rice_score, 1), }) return sorted(scored, key=lambda x: x['rice_score'], reverse=True) @staticmethod def value_vs_effort(features: List[Dict]) -> Dict: """Plot features on a value vs effort matrix.""" matrix = {'quick_wins': [], 'big_bets': [], 'fill_ins': [], 'time_wasters': []} for f in features: value = f.get('value', 5) # 1-10 effort = f.get('effort', 5) # 1-10 (higher = more effort) if value >= 6 and effort <= 4: matrix['quick_wins'].append(f['name']) elif value >= 6 and effort > 4: matrix['big_bets'].append(f['name']) elif value < 6 and effort <= 4: matrix['fill_ins'].append(f['name']) else: matrix['time_wasters'].append(f['name']) return matrix @staticmethod def now_next_later(prioritized: List[Dict], quarterly_capacity: int = 50) -> Dict: """Distribute features into Now/Next/Later buckets.""" buckets = {'now': [], 'next': [], 'later': []} effort_used = 0 for item in prioritized: effort = item.get('effort', 5) if effort_used + effort <= quarterly_capacity * 0.6: buckets['now'].append(item) effort_used += effort elif effort_used + effort <= quarterly_capacity * 0.9: buckets['next'].append(item) effort_used += effort else: buckets['later'].append(item) return buckets ``` ## User Story Builder ```python class UserStory: """Write and manage user stories with acceptance criteria.""" @staticmethod def create(role: str, goal: str, benefit: str) -> str: """As a [user], I want [goal], so that [benefit].""" return f"As a **{role}**, I want **{goal}**, so that **{benefit}**." @staticmethod def add_acceptance_criteria(user_story: str, criteria: List[str]) -> str: """Append Gherkin-style acceptance criteria.""" result = user_story + "\n\n**Acceptance Criteria:**\n" for c in criteria: result += f"\n- [ ] {c}" return result @staticmethod def add_gherkin_scenarios(user_story: str, scenarios: List[Dict]) -> str: """Add Given/When/Then scenarios.""" result = user_story + "\n\n**Scenarios:**\n" for s in scenarios: result += f"\n**Scenario:** {s.get('name', '')}" result += f"\n Given {s.get('given', '')}" result += f"\n When {s.get('when', '')}" result += f"\n Then {s.get('then', '')}\n" return result ``` ## Release Planning ```python class ReleasePlanner: """Plan and communicate product releases.""" def __init__(self, version: str, release_date: str): self.version = version self.release_date = release_date self.features = [] self.bugs = [] self.risks = [] def add_feature(self, feature: str, impact: str = 'medium', effort: str = 'medium') -> 'ReleasePlanner': self.features.append({'feature': feature, 'impact': impact, 'effort': effort}) return self def add_bug_fix(self, bug: str, severity: str): self.bugs.append({'bug': bug, 'severity': severity}) return self def generate_release_notes(self) -> str: notes = f"🚀 Release v{self.version} — {self.release_date}\n" notes += "=" * 50 + "\n" notes += f"\n**New Features:**\n" for f in self.features: notes += f" ✨ {f['feature']}\n" notes += f"\n**Bug Fixes:**\n" if self.bugs: for b in self.bugs: notes += f" 🐛 Fixed: {b['bug']}\n" else: notes += " None\n" return notes ``` ## Common Pitfalls 1. **Roadmap as a commitment** — roadmap is a plan, not a promise; communicate uncertainty 2. **No discovery before building** — building features nobody wants wastes time; validate first 3. **Everything is P1** — if everything is priority 1, nothing is; force hard trade-offs 4. **Stakeholder-driven roadmap** — every request goes to the top without prioritization 5. **No exit criteria for experiments** — run experiments with clear go/no-go thresholds 6. **Not shipping** — perfect features never ship; focus on 80% solutions that deliver value now ## Verification Checklist - [ ] Product strategy documented (vision, target users, differentiators) - [ ] Roadmap with Now/Next/Later buckets - [ ] Prioritization framework chosen (RICE, value/effort, etc.) - [ ] User stories follow standard format with acceptance criteria - [ ] Release plan with date, scope, and risks documented - [ ] Product discovery process defined (user research, testing) - [ ] Success metrics defined for each major feature - [ ] Stakeholder communication cadence established ## See Also - saas-metrics-reporting — measuring product impact - project-management-workflows — executing the roadmap - customer-feedback-surveys — input for product decisions - competitive-intelligence-analysis — market positioning