Skip to content This library is free, offered as dana. If it helps your work, donate here →
penguin tree ai
← back to libraryDonate here

This is one of 3,622 free prompts in the penguin tree ai library. Sign up once and the whole library opens, with new prompts by email.

open the library →

Backlog prioritization engine

Scores and ranks a product backlog using the RICE or ICE framework, converting reach, impact, confidence, and effort inputs into a prioritized delivery order with tier bands, quick-win callouts, and sequencing…

download .md

Purpose

Convert a raw list of backlog items into a scored, ranked, and tiered priority order using RICE or ICE — so the next sprint or quarter is decided by consistent math rather than the loudest voice in the room. Produces defensible scores, sequencing logic, and quick-win callouts a PM can present to stakeholders without further rework.

When to Use

Invoke this skill when the user asks to:

  • Prioritize or rank a product backlog
  • Decide what to build next quarter or next sprint
  • Resolve competing feature requests with a consistent framework
  • Score features using RICE or ICE
  • Turn a messy list of ideas into a defensible roadmap order
  • Justify prioritization decisions to leadership or engineering

Inputs Required

Before starting, collect:

  • Backlog items: The list of features, fixes, or initiatives to score (name + 1-line description each)
  • Framework preference: RICE or ICE (default to RICE if effort estimates are available)
  • Reach data: How many users/accounts each item affects per time period (or a way to estimate it)
  • Impact scale: Business goal being optimized (revenue, activation, retention, NPS) so impact scores map to something real
  • Effort estimates: Person-months or story points per item (required for RICE)
  • Confidence signals: Evidence level behind each item — data-backed, informed guess, or speculative
  • Constraints: Any hard dependencies, deadlines, or team capacity limits that override pure score

If reach, effort, or confidence data is missing for an item, estimate using stated assumptions and flag the item as "needs validation" rather than skipping it.

Instructions

Step 1: Confirm Framework and Scoring Scales

Lock the scoring model before touching items.

RICE — (Reach × Impact × Confidence) ÷ Effort

  • Reach: absolute count of users/accounts affected per quarter (e.g., 5,000)
  • Impact: 3 = massive, 2 = high, 1 = medium, 0.5 = low, 0.25 = minimal
  • Confidence: 100% = high (hard data), 80% = medium (some data), 50% = low (guess)
  • Effort: total person-months across all functions

ICE — (Impact × Confidence × Ease) ÷ 3 or averaged, scored 1–10 each

  • Use when effort estimates are unreliable or the team wants faster, lighter scoring
  • Ease replaces effort: 10 = trivial, 1 = massive lift

State the chosen scales explicitly so every item is scored against the same yardstick.

Step 2: Score Every Item

For each backlog item, assign each component with a one-line justification — never a bare number.

  • Anchor Impact to the stated business goal, not generic "value"
  • Set Confidence based on the evidence signal provided (data → high, informed guess → medium, speculation → low)
  • Note the assumption when any input was estimated rather than provided
  • Do not let a single dominant input silently drive the score — flag when one item scores high only because of an unvalidated reach or impact guess

Step 3: Calculate and Rank

Compute each score using the chosen formula. Rank all items highest to lowest. Present as a table with columns: Rank, Item, each component, Score, and a Flag column ("needs validation" / "dependency" / "quick win").

Step 4: Assign Priority Tiers

Group ranked items into decision-ready bands:

  • Do Now (top tier): highest scores, no blocking dependencies — commit these first
  • Do Next: strong scores or high value gated by a dependency or capacity
  • Do Later: moderate scores — revisit next cycle
  • Deprioritize / Kill: low scores with low confidence — recommend dropping or validating cheaply before reconsidering

Step 5: Surface Quick Wins and Big Bets

  • Quick wins: high score driven primarily by low effort/high ease — call these out for early momentum
  • Big bets: high impact + high effort — flag as roadmap-level decisions requiring explicit leadership buy-in
  • Traps: items ranking high only on speculative reach or impact — recommend a cheap validation step before committing

Step 6: Apply Constraints and Recommend Sequencing

Layer real-world constraints over the pure score:

  • Reorder for hard dependencies (item B can't ship before item A regardless of score)
  • Respect deadlines and team capacity limits provided in inputs
  • Where a constraint overrides score, state why explicitly

Close with a recommended build order for the next cycle and a one-line rationale per selected item.

Output Format

  • Structure: Framework/scale summary → full scored ranking table → priority tiers → quick wins & big bets → constraint-adjusted sequencing recommendation
  • Length: 700–1,100 words plus the scoring table
  • Format: A scored table as the centerpiece, with tiers and recommendations in structured lists
  • Sections: Scoring Model → Scored Ranking (table) → Priority Tiers → Quick Wins & Big Bets → Sequencing Recommendation
  • Tone: Decisive product-manager voice — quantitative, opinionated, and transparent about assumptions

Quality Checklist

Before delivering output, verify:

  • [ ] Every backlog item has a complete set of component scores — no blanks
  • [ ] Each component score has a one-line justification, not just a number
  • [ ] Scores are computed with the correct formula and the math is consistent across all items
  • [ ] Ranking order matches the calculated scores (highest to lowest)
  • [ ] Every estimated input is flagged "needs validation"
  • [ ] At least one quick win and any big bets are explicitly called out
  • [ ] Final sequencing accounts for stated dependencies and constraints, not score alone

Notes

  • RICE favors items with broad reach and low effort; ICE moves faster but is more subjective — pick RICE when defending decisions to leadership, ICE for rapid internal triage
  • The most common prioritization error is inflated Confidence on speculative items — hold the line and score speculation as 50%
  • A single high-reach guess can rocket a weak item to the top; the validation flag exists to catch exactly this
  • Re-run this scoring each planning cycle rather than trusting a stale ranking — reach and confidence change as data comes in

How to use this skill

This file is a Claude Code skill in Anthropic's standard format — markdown with YAML frontmatter at the top.

Installing in Claude Code:

  • ~/.claude/skills/<folder-name>/SKILL.md — auto-loads in every session anywhere on your machine (recommended for skills you'll use across multiple projects)
  • <your-project>/.claude/skills/<folder-name>/SKILL.md — auto-loads only when working in that project (recommended for project-specific skills)

Restart Claude Code or open a new session to register.

Using in Claude.ai, ChatGPT, Gemini, or other AI tools:

  1. Drag this file into a new chat, or copy and paste its contents
  2. Send your task or request as your next message — the AI will apply the skill where it fits

For Claude Code skill details: https://docs.anthropic.com/en/docs/claude-code/skills