anthropics/knowledge-work-plugins

roadmap-update

Update, create, or reprioritize your product roadmap.

Ver código-fonte

Como usar

  1. Copie o comando e verifique o pacote antes de instalar no seu ambiente de agente.
  2. Consulte no original as ferramentas, credenciais e ambientes necessários.
  3. Descreva os dados de entrada e a entrega esperada; confira a saída com as fontes.
npx skills add https://github.com/anthropics/knowledge-work-plugins --skill roadmap-update

Antes de começar

  • A instalação não inclui assinatura de modelo, franquia API ou acesso aos seus arquivos.
  • Estrelas e instalações indicam atividade, não um teste independente de qualidade ou segurança.
Documento original do Skill

Renderizado do repositório de origem, preservando títulos, exemplos, código, tabelas, links e imagens.

Roadmap Update

If you see unfamiliar placeholders or need to check which tools are connected, see CONNECTORS.md.

Update, create, or reprioritize a product roadmap.

Usage

/roadmap-update $ARGUMENTS

Workflow

1. Understand Current State

If ~~project tracker is connected:

  • Pull current roadmap items with their statuses, assignees, and dates
  • Identify items that are overdue, at risk, or recently completed
  • Surface any items without clear owners or dates

If no project management tool is connected:

  • Ask the user to describe their current roadmap or paste/upload it
  • Accept any format: list, table, spreadsheet, screenshot, or prose description

2. Determine the Operation

Ask what the user wants to do:

Add item: New feature, initiative, or work item to the roadmap

  • Gather: name, description, priority, estimated effort, target timeframe, owner, dependencies
  • Suggest where it fits based on current priorities and capacity

Update status: Change status of existing items

  • Options: not started, in progress, at risk, blocked, completed, cut
  • For "at risk" or "blocked": ask for the blocker and mitigation plan

Reprioritize: Change the order or priority of items

  • Ask what changed (new information, strategy shift, resource change, customer feedback)
  • Apply a prioritization framework if helpful — see Prioritization Frameworks below for RICE, MoSCoW, ICE, and value-vs-effort
  • Show before/after comparison

Move timeline: Shift dates for items

  • Ask why (scope change, dependency slip, resource constraint)
  • Identify downstream impacts on dependent items
  • Flag items that move past hard deadlines

Create new roadmap: Build a roadmap from scratch

  • Ask about timeframe (quarter, half, year)
  • Ask about format preference (Now/Next/Later, quarterly columns, OKR-aligned) — see Roadmap Frameworks below
  • Gather the list of initiatives to include

3. Generate Roadmap Summary

Produce a roadmap view with:

Status Overview

Quick summary: X items in progress, Y completed this period, Z at risk.

Roadmap Items

For each item, show:

  • Name and one-line description
  • Status indicator (on track / at risk / blocked / completed / not started)
  • Target timeframe or date
  • Owner
  • Key dependencies

Group items by:

  • Timeframe (Now / Next / Later) or quarter, depending on format
  • Or by theme/goal if the user prefers

Risks and Dependencies

  • Items that are blocked or at risk, with details
  • Cross-team dependencies and their status
  • Items approaching hard deadlines

Changes This Update

If this is an update to an existing roadmap, summarize what changed:

  • Items added, removed, or reprioritized
  • Timeline shifts
  • Status changes

4. Follow Up

After generating the roadmap:

  • Offer to format for a specific audience (executive summary, engineering detail, customer-facing)
  • Offer to draft communication about roadmap changes
  • If project management tool is connected, offer to update ticket statuses

Roadmap Frameworks

Now / Next / Later

The simplest and often most effective roadmap format:

  • Now (current sprint/month): Committed work. High confidence in scope and timeline. These are the things the team is actively building.
  • Next (next 1-3 months): Planned work. Good confidence in what, less confidence in exactly when. Scoped and prioritized but not yet started.
  • Later (3-6+ months): Directional. These are strategic bets and opportunities we intend to pursue, but scope and timing are flexible.

When to use: Most teams, most of the time. Especially good for communicating externally or to leadership because it avoids false precision on dates.

Quarterly Themes

Organize the roadmap around 2-3 themes per quarter:

  • Each theme represents a strategic area of investment (e.g., "Enterprise readiness", "Activation improvements", "Platform extensibility")
  • Under each theme, list the specific initiatives planned
  • Themes should map to company or team OKRs
  • This format makes it easy to explain WHY you are building what you are building

When to use: When you need to show strategic alignment. Good for planning meetings and executive communication.

OKR-Aligned Roadmap

Map roadmap items directly to Objectives and Key Results:

  • Start with the team's OKRs for the period
  • Under each Key Result, list the initiatives that will move that metric
  • Include the expected impact of each initiative on the Key Result
  • This creates clear accountability between what you build and what you measure

When to use: Organizations that run on OKRs. Good for ensuring every initiative has a clear "why" tied to measurable outcomes.

Timeline / Gantt View

Calendar-based view with items on a timeline:

  • Shows start dates, end dates, and durations
  • Visualizes parallelism and sequencing
  • Good for identifying resource conflicts
  • Shows dependencies between items

When to use: Execution planning with engineering. Identifying scheduling conflicts. NOT good for communicating externally (creates false precision expectations).

Prioritization Frameworks

RICE Score

Score each initiative on four dimensions, then calculate RICE = (Reach x Impact x Confidence) / Effort

  • Reach: How many users/customers will this affect in a given time period? Use concrete numbers (e.g., "500 users per quarter").
  • Impact: How much will this move the needle for each person reached? Score on a scale: 3 = massive, 2 = high, 1 = medium, 0.5 = low, 0.25 = minimal.
  • Confidence: How confident are we in the reach and impact estimates? 100% = high confidence (backed by data), 80% = medium (some evidence), 50% = low (gut feel).
  • Effort: How many person-months of work? Include engineering, design, and any other functions.

When to use: When you need a quantitative, defensible prioritization. Good for comparing a large backlog of initiatives. Less good for strategic bets where impact is hard to estimate.

MoSCoW

Categorize items into Must have, Should have, Could have, Won't have:

  • Must have: The roadmap is a failure without these. Non-negotiable commitments.
  • Should have: Important and expected, but delivery is viable without them.
  • Could have: Desirable but clearly lower priority. Include only if capacity allows.
  • Won't have: Explicitly out of scope for this period. Important to list for clarity.

When to use: Scoping a release or quarter. Negotiating with stakeholders about what fits. Good for forcing prioritization conversations.

ICE Score

Simpler than RICE. Score each item 1-10 on three dimensions:

  • Impact: How much will this move the target metric?
  • Confidence: How confident are we in the impact estimate?
  • Ease: How easy is this to implement? (Inverse of effort — higher = easier)

ICE Score = Impact x Confidence x Ease

When to use: Quick prioritization of a feature backlog. Good for early-stage products or when you do not have enough data for RICE.

Value vs Effort Matrix

Plot initiatives on a 2x2 matrix:

  • High value, Low effort (Quick wins): Do these first.
  • High value, High effort (Big bets): Plan these carefully. Worth the investment but need proper scoping.
  • Low value, Low effort (Fill-ins): Do these when you have spare capacity.
  • Low value, High effort (Money pits): Do not do these. Remove from the backlog.

When to use: Visual prioritization in team planning sessions. Good for building shared understanding of tradeoffs.

Dependency Mapping

Identifying Dependencies

Look for dependencies across these categories:

  • Technical dependencies: Feature B requires infrastructure work from Feature A
  • Team dependencies: Feature requires work from another team (design, platform, data)
  • External dependencies: Waiting on a vendor, partner, or third-party integration
  • Knowledge dependencies: Need research or investigation results before starting
  • Sequential dependencies: Must ship Feature A before starting Feature B (shared code, user flow)

Managing Dependencies

  • List all dependencies explicitly in the roadmap
  • Assign an owner to each dependency (who is responsible for resolving it)
  • Set a "need by" date: when does the depending item need this resolved
  • Build buffer around dependencies — they are the highest-risk items on any roadmap
  • Flag dependencies that cross team boundaries early — these require coordination
  • Have a contingency plan: what do you do if the dependency slips?

Reducing Dependencies

  • Can you build a simpler version that avoids the dependency?
  • Can you parallelize by using an interface contract or mock?
  • Can you sequence differently to move the dependency earlier?
  • Can you absorb the work into your team to remove the cross-team coordination?

Capacity Planning

Estimating Capacity

  • Start with the number of engineers and the time period
  • Subtract known overhead: meetings, on-call rotations, interviews, holidays, PTO
  • A common rule of thumb: engineers spend 60-70% of time on planned feature work
  • Factor in team ramp time for new members

Allocating Capacity

A healthy allocation for most product teams:

  • 70% planned features: Roadmap items that advance strategic goals
  • 20% technical health: Tech debt, reliability, performance, developer experience
  • 10% unplanned: Buffer for urgent issues, quick wins, and requests from other teams

Adjust ratios based on team context:

  • New product: more feature work, less tech debt
  • Mature product: more tech debt and reliability investment
  • Post-incident: more reliability, less features
  • Rapid growth: more scalability and performance

Capacity vs Ambition

  • If roadmap commitments exceed capacity, something must give
  • Do not solve capacity problems by pretending people can do more — solve by cutting scope
  • When adding to the roadmap, always ask: "What comes off?"
  • Better to commit to fewer things and deliver reliably than to overcommit and disappoint

Communicating Roadmap Changes

When the Roadmap Changes

Common triggers for roadmap changes:

  • New strategic priority from leadership
  • Customer feedback or research that changes priorities
  • Technical discovery that changes estimates
  • Dependency slip from another team
  • Resource change (team grows or shrinks, key person leaves)
  • Competitive move that requires response

How to Communicate Changes

  1. Acknowledge the change: Be direct about what is changing and why
  2. Explain the reason: What new information drove this decision?
  3. Show the tradeoff: What was deprioritized to make room? Or what is slipping?
  4. Show the new plan: Updated roadmap with the changes reflected
  5. Acknowledge impact: Who is affected and how? Stakeholders who were expecting deprioritized items need to hear it directly.

Avoiding Roadmap Whiplash

  • Do not change the roadmap for every piece of new information. Have a threshold for change.
  • Batch roadmap updates at natural cadences (monthly, quarterly) unless something is truly urgent.
  • Distinguish between "roadmap change" (strategic reprioritization) and "scope adjustment" (normal execution refinement).
  • Track how often the roadmap changes. Frequent changes may signal unclear strategy, not good responsiveness.

Output Format

Use a clear, scannable format. Tables work well for roadmap items. Use text status labels: Done, On Track, At Risk, Blocked, Not Started.

Tips

  • A roadmap is a communication tool, not a project plan. Keep it at the right altitude — themes and outcomes, not tasks.
  • When reprioritizing, always ask what changed. Priority shifts should be driven by new information, not whim.
  • Flag capacity issues early. If the roadmap has more work than the team can handle, say so.
  • Dependencies are the biggest risk to roadmaps. Surface them explicitly.
  • If the user asks to add something, always ask what comes off or moves. Roadmaps are zero-sum against capacity.

Relacionados por tarefa

do mesmo repositório

Mais Skills

Todos os Skills
anthropics
Oficial

contract-review

Lightweight NDA, MSA, and vendor contract review for SMBs without legal on staff. Reads contracts from local files, mail attachments (Gmail or M365), a connected file store (Google Drive or M365), or DocuSign envelopes; flags non-standard terms; explains risks in plain English; and outputs a marked-up redline as a separate DOCX. Use when the user says "review this contract," "what am I signing," "red flags," "flag any concerns," "check the payment terms," or uploads/forwards a contract or legal

Instalações / 1h
2
GitHub Stars
36,7 mil
Atualizado
21 de nov.
anthropics
Oficial

process-doc

Document a business process — flowcharts, RACI, and SOPs. Use when formalizing a process that lives in someone's head, building a RACI to clarify who owns what, writing an SOP for a handoff or audit, or capturing the exceptions and edge cases of how work actually gets done.

Instalações / 1h
1
GitHub Stars
36,6 mil
Atualizado
20 de nov.
anthropics
Oficial

data-visualization

Create effective data visualizations with Python (matplotlib, seaborn, plotly). Use when building charts, choosing the right chart type for a dataset, creating publication-quality figures, or applying design principles like accessibility and color theory.

Instalações / 1h
5
GitHub Stars
36,6 mil
Atualizado
20 de nov.
anthropics
Oficial

accessibility-review

Run a WCAG 2.1 AA accessibility audit on a design or page. Trigger with "audit accessibility", "check a11y", "is this accessible?", or when reviewing a design for color contrast, keyboard navigation, touch target size, or screen reader behavior before handoff.

Instalações / 1h
4
GitHub Stars
36,6 mil
Atualizado
20 de nov.