RICE Prioritization with Claude Skills

RICE is a great framework. Applying it to 40 ideas every quarter is the worst part of your week. A Claude Skill for RICE prioritization gives you the same rigor without the spreadsheet fatigue.

Why RICE Falls Apart at Scale (and How a Skill Fixes That)

The framework is fine. The execution drifts.

Confidence scores creep upward as people get attached to their ideas. Reach estimates round generously. Impact ratings get political because nobody wants to call a colleague's pet project "low impact." By the time you've scored 40 backlog items in a spreadsheet, the cell on row 32 was scored by a different version of you than the one who scored row 4.

A RICE prioritization Claude Skill applies the same rubric to every idea. Row 4 and row 32 get the same hard questions about confidence. Reach gets estimated using the same definition every time. Impact gets anchored to the same examples instead of vibes. That's what makes a Claude prioritization workflow reliable enough to actually trust six months later.

The honest tradeoff: the Skill is only as good as the inputs you feed it. If your problem statement for an idea is "make onboarding better," no Skill will save you. But if you're feeding in real customer pain points and reasonable effort estimates, a Skill removes the variance that kills RICE in practice.

What Your RICE Skill Needs to Know

A working RICE prioritization Claude Skill encodes four things:

Your reach estimation method. Is reach "active users affected in the next quarter," or "eligible cohort across the next year"? Both are valid. Pick one and write it down, because Claude will guess if you don't.

Your impact rubric. Most teams use a 5-level scale (massive, high, medium, low, minimal) but the anchors matter more than the labels. What's an example of a "massive impact" change in your product? What's a "low" one? Without examples, Claude defaults to generic SaaS comparisons that may not match your business.

Your confidence anchors. This is the dimension most teams hand-wave. We'll get to it in detail in a minute, but for now: 100% means you've shipped something exactly like it before. 80% means you have direct customer evidence. 50% means it's an educated guess. Below 50%, you're speculating.

Your effort estimation conventions. Person-months, t-shirt sizes, story points, sprint counts. Pick the unit your team actually uses. Skills work best when they speak your team's existing language, not a generic version of it.

Building the RICE Prioritization SKILL.md

Three files in one folder. SKILL.md holds the instructions and trigger description. RUBRIC.md holds the scoring anchors with specific examples from your product. OUTPUT_TEMPLATE.md holds the format the scored backlog takes (usually a table sorted by score, with a one-line rationale per row).

Here's a working SKILL.md to copy and adapt:

---
name: rice-prioritizer
description: Scores a backlog of product ideas using the RICE framework
  (Reach, Impact, Confidence, Effort). Use this when the user asks to
  prioritize a backlog, score ideas with RICE, rank features for next
  quarter, or decide what to ship next. Trigger on "score this backlog,"
  "RICE these ideas," "prioritize Q[N]," "what should we ship next," or
  any request to rank product ideas using a consistent scoring framework.
---
# RICE Prioritizer
Score a list of product ideas using the RICE framework. Follow RUBRIC.md
for scoring anchors. Output in the format defined by OUTPUT_TEMPLATE.md.
## Process
1. For each idea, gather the four RICE inputs:
   - Reach: users affected per [your team's time period]
   - Impact: massive (3) / high (2) / medium (1) / low (0.5) / minimal (0.25)
   - Confidence: percentage, anchored to RUBRIC.md
   - Effort: in person-months
2. If an input is missing, do not guess. Ask one clarifying question
   per idea, then proceed.
3. Calculate: (Reach × Impact × Confidence) / Effort
4. Return ideas sorted by score with one-line rationales.
## Rules
- Confidence above 80% requires citing direct customer evidence
  (a quote, ticket, or research finding). Without evidence, cap at 60%.
- Impact ratings should reference RUBRIC.md examples, not generic
  SaaS comparisons.
- Flag any score that depends on inputs you had to guess at.
- Surface the top 5, middle 20, and bottom items separately so the
  user can focus their decisions.
- Never invent customer evidence. If asked to score without inputs,
  return [INPUTS NEEDED] for each missing field.

The trigger description is what tells Claude when to fire. "When prioritizing a backlog" is too vague. Name the specific phrases your team uses: "score this backlog," "RICE these ideas," "what should we ship next quarter." The more specific the trigger phrases, the more reliably the Skill fires when you want it to.

The Hardest Part: Teaching Claude What "Confidence" Actually Means

Confidence is where most RICE scores go wrong. People rate things 80% confident when they really mean "I want this to be true." A research-backed bet and a hopeful guess end up scored the same, which is why post-mortems on prioritization decisions are so painful six months later.

The fix is to encode confidence as an evidence-based scale, not a feelings scale:

• 100%: You've shipped this exact change before and measured the outcome. The new version is a refinement.
• 80%: You have direct customer evidence (interviews, support tickets, behavioral data) that this is a real problem.
• 60%: You have indirect evidence (a related feature did well, a similar competitor saw uplift) but not direct evidence for this specific change.
• 40%: This is an educated guess based on team intuition or one strong customer signal.
• 20%: This is a hypothesis. The first ship is the experiment.

Write these into RUBRIC.md with specific examples from your product. The Skill should refuse to score above 80% confidence if no customer evidence is cited. If your roadmap process doesn't reward citing evidence, that's the bigger issue, but a Skill that demands it at scoring time pushes the team in the right direction.

From RICE Scores to Roadmap Decisions

A RICE score is the start of a conversation, not the end of one. The Skill output should be a ranked list with rationales, not a single number you defer to.

Three rules for using the output well:

Treat scores as a sort order, not a verdict. The top five are worth debating. The middle twenty are probably right. The bottom fifteen are probably right too. Spend your meeting time on the top five, not on relitigating the whole list.

Override transparently, with a reason. The Skill says ship feature X first. The team says no, ship feature Y because of a strategic narrative the Skill doesn't know about. That's fine. But write down the override reason in the same doc, so next quarter you can see what you knew versus what you decided.

Audit the Skill quarterly. Look at which "high" items actually shipped, which "low" items got bumped, and which "medium" items kept getting deferred. If your scored-high items keep failing to ship, the impact rubric is too generous. If "low" items keep shipping, the team is overriding the Skill so often that the score isn't carrying any weight.

This is also where understanding the customer clarity gap matters. A RICE score grounded in real customer evidence holds up under pressure. A score grounded in team intuition gets challenged the moment leadership pushes back.

Where to go from here

A RICE prioritization Claude Skill is the front end of roadmap planning. The natural next step is feeding the scored output into a Roadmap Skill in Claude that turns the prioritized backlog into a visual plan. Together, the two compress the gap between "we have 40 ideas" and "here's what we're building next quarter, and why."

Frequently asked questions about building a RICE prioritization Claude Skill

What is a RICE prioritization Claude Skill?

A RICE prioritization Claude Skill is a reusable instruction set that scores a backlog of product ideas using the Reach, Impact, Confidence, Effort framework. The Skill encodes your team's specific rubric (what counts as "high impact," what evidence justifies high confidence) and applies the same scoring discipline to every idea. The output is a ranked list with rationales, not just a number.

Can a Claude Skill score my entire backlog at once?

Yes. Paste in or upload the full list of ideas (with the four RICE inputs for each), and the Skill returns a sorted ranking with one-line rationales. For backlogs larger than 50 items, it helps to split into batches so the Skill can produce useful comparisons. The Skill should flag any items where inputs were missing or where the score depends heavily on a guessed value.

How is a RICE prioritization Claude Skill different from a RICE spreadsheet?

A spreadsheet stores the scores. A Claude prioritization Skill enforces the scoring discipline. The spreadsheet doesn't care if your confidence rating drifted from 60% to 80% halfway through the list, or if your impact anchors changed between Q1 and Q3. A Skill applies the same rubric to every row, refuses to accept "80% confidence" without cited customer evidence, and surfaces the items where you had to guess.

What's the right way to encode confidence in an AI RICE score?

Use an evidence-based scale, not a feelings scale. 100% means you've shipped this exact change before. 80% means you have direct customer evidence (interviews, tickets, behavioral data). 60% means indirect evidence. 40% is an educated guess. 20% is a hypothesis. Write these into the Skill's rubric file with specific examples from your product, and have the Skill refuse to score above 80% without cited evidence.

Should I override the Skill's prioritization?

Yes, sometimes. The Skill knows the score; you know the context. Strategic narratives, leadership commitments, and quarter-end politics aren't in the rubric. The rule is to override transparently: when you bump a low-scored item up, write down why in the same doc. Quarterly, review which overrides paid off and which didn't. That's how you learn whether your rubric or your overrides are off.

‍