agentleFS
varunk130varunk130/claude-code-skills/skills/product-management/product-roadmap-prioritizer/SKILL.md

product-roadmap-prioritizer

Skill1 starsChanged 23 days agoMITView on GitHub

Runs candidate features through Reach-Impact-Confidence-Effort (RICE), Kano, Must-Should-Could-Won't (MoSCoW), and Cost-of-Delay scoring, surfaces convergence and divergence across frameworks, and produces a defensible quarterly priority list with explicit trade-offs. Use when building a quarterly or annual roadmap; resolving conflicting stakeholder input; justifying a deprioritization to a stakeholder; or normalizing requests from multiple sources (sales, customer success, leadership) into one queue.

The file

We split this skill into the rules it gives an agent

4 rules. About 0 are common, 4 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈4

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Document the data source behind each number.

    line 57
  2. Distinctive:

    Document why each declined item was declined

    line 142
  3. Distinctive:

    Use one framework alone

    line 146
  4. Distinctive:

    Treat technical debt as automatically deferrable

    line 148

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Product Roadmap Prioritizer

Multi-framework feature ranking that withstands stakeholder pushback.

What this skill is

A workflow that scores candidate features across four complementary prioritization frameworks - Reach-Impact-Confidence-Effort (RICE), Kano, Must-Should-Could-Won't (MoSCoW), and Cost of Delay - surfaces where they agree and disagree, and turns that into a ranked quarterly roadmap with explicit reasoning. Designed so that every "no" can be defended with the same rigor as every "yes."

What it solves

  • Highest-Paid-Person's-Opinion (HiPPO) driven prioritization
  • Feature ranking that ignores effort or confidence
  • Single-framework analysis that misses the trade-off (RICE without Kano misses delighters; Kano without RICE misses scale)
  • Sales, customer success, and executive requests that bypass any structured queue
  • Inability to explain to a stakeholder why their request didn't make the cut

When to invoke

  • Quarterly or annual roadmap planning
  • Resolving conflicting input from sales, customer success, and leadership
  • Justifying a deprioritization in writing
  • Normalizing a backlog of 50+ requests into a ranked queue
  • Pre-Objectives and Key Results (pre-OKR) planning to align roadmap with stated objectives

Phase 1: Inventory candidates

Collect every candidate from every source:

  • Sales requests (deal-driven asks)
  • Customer success and support themes (volume, severity)
  • Leadership, board, or strategy directives
  • Customer interview opportunity tree
  • Technical debt and platform investments
  • Engineering quality and reliability work

For each, capture: title, sponsor, source link, hypothesized outcome, hypothesized customer.

Reject anything missing sponsor or outcome.

Phase 2: Score with RICE

For each candidate:

Reach-Impact-Confidence-Effort (RICE) = (Reach × Impact × Confidence) / Effort
  • Reach - number of users affected per time period
  • Impact - 0.25 (minimal) / 0.5 / 1 (medium) / 2 / 3 (massive)
  • Confidence - 50% / 80% / 100% - based on quality of evidence
  • Effort - person-months

Document the data source behind each number. A RICE score with no evidence is a feeling.

Phase 3: Classify with Kano

For each candidate, classify the customer perception:

Kano categoryDefinitionInvestment posture
Must-haveExpected baseline; absence → dissatisfactionReach parity, then stop
PerformanceMore is better; linear satisfactionInvest while Return on Investment (ROI) holds
DelighterUnexpected; non-linear satisfactionInvest selectively for differentiation
IndifferentNo effect on satisfactionDefer or kill
ReverseMore → less satisfactionAvoid

Classification source: survey, interview, behavioral data, or analyst hypothesis (flag the confidence).

A roadmap of all must-haves is a defensive crouch. A roadmap of all delighters is fragile. Balance.

Phase 4: Categorize with MoSCoW (per release)

For each candidate within a release window, apply the Must-Should-Could-Won't (MoSCoW) categorization:

  • Must - non-negotiable; release fails without it
  • Should - important; release weaker without it
  • Could - nice to have; first to cut
  • Won't (this time) - explicitly out of scope

Rule of thumb: Must ≤ 60% of release capacity. Anything higher means everything is "must," which means nothing is.

Phase 5: Weight with Cost of Delay

For time-sensitive items, compute Cost of Delay Divided by Duration (CD3):

CD3 = Cost of Delay / Duration

Cost of delay components:

  • Revenue at risk (deal blockers, churn risk)
  • Competitive timing (feature parity windows)
  • Compliance or regulatory deadlines
  • Dependency unblocking (other teams gated)
  • Brand or public-relations opportunity

CD3 sorts the queue for sequencing within a release.

Phase 6: Convergence analysis

Build the convergence table:

CandidateRICE rankKanoMoSCoWCD3 rankConvergence
A1PerformanceMust1Strong yes
B5DelighterShould3Mixed - investigate
C12Must-haveMust8Table stakes - do
D2IndifferentCould15RICE alone is misleading

Where frameworks agree → high confidence to commit. Where they disagree → the disagreement IS the strategy conversation. Don't average; investigate.

Phase 7: Quarterly roadmap

For the chosen quarter:

  • 60% capacity → must-haves and high-converging items
  • 25% capacity → performance and delighter bets
  • 10% capacity → technical debt and platform investment
  • 5% capacity → discovery experiments (no committed output)

Stakeholder reply template for declined requests:

Thanks for the request. We scored [X] using RICE / Kano / MoSCoW. It scored [Y], which puts it behind [Z]. We'd reconsider if [explicit trigger]. Here's what we're doing instead: [items A, B, C] and the outcome we expect.

Output

  • Scored candidate table across all four frameworks
  • Convergence and divergence analysis with reasoning
  • Ranked quarterly roadmap with capacity allocation
  • Explicit "won't do this quarter" list with reasoning
  • Stakeholder decline templates per declined request
  • Re-evaluation triggers for next quarter

Operating rules

Always

  • Source every RICE input from evidence
  • Apply at least two frameworks before committing
  • Investigate divergence - don't average it away
  • Cap "Must" at 60% of release capacity
  • Document why each declined item was declined

Never

  • Score with confidence above what the evidence supports
  • Use one framework alone
  • Promote a request because the sponsor is senior
  • Treat technical debt as automatically deferrable
  • Confuse a feature with an outcome

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.