RICE Prioritization with AI: Prompt, Template, and a Worked Example

RICE is supposed to make prioritization objective. In practice, the scores are judgment calls dressed up as math. One PM rates a feature's Impact a 3, another rates the same feature a 1, and the only thing that changed was who held the spreadsheet that day. The framework gives you a number, but the number inherits every silent assumption underneath it. That's why prioritization meetings turn into debates about scores instead of debates about strategy.

AI fixes the part RICE was always weak on: making the reasoning visible. When you ask Claude to score a feature, you can force it to show why each number landed where it did, flag the assumptions that need validation, and add a gut-check against the math. The score stops being a black box. You get a ranked list you can actually defend in the room, plus a record of what you'd have to believe for the ranking to change.

This article gives you the prompt, the template, and a worked example you can copy today.

What RICE Is (Quick Refresher)

RICE scores each feature on four factors, then divides to get a single number.

• Reach. How many people does this affect in a given period? Use a real count: users per quarter, accounts per month, sessions per week. Pick one unit and hold it constant across every feature.
• Impact. How much does it move the thing you care about for each person it reaches? RICE uses a fixed scale: 3 = massive, 2 = high, 1 = medium, 0.5 = low, 0.25 = minimal.
• Confidence. How sure are you about the other three? 100% = strong data, 80% = some evidence, 50% = a hunch. It's the honesty multiplier that keeps optimistic guesses from dominating.
• Effort. Total work to ship, in person-months. This is the only factor on the bottom of the equation, so bigger effort pushes the score down.

The formula:

RICE Score = (Reach × Impact × Confidence) / Effort

Higher score wins. The math is trivial. The hard part is choosing the four inputs consistently — and that's exactly where AI earns its place.

Where AI Changes the Game

The point of bringing AI into RICE isn't to automate arithmetic. It's to make the inputs consistent and the reasoning legible. Here is how the three common approaches compare.

The spreadsheet was already better than gut feel. AI closes the last gap: it writes down the "why" behind every score so the ranking survives the meeting.

The RICE Prompt

Paste this into Claude. Replace the bracketed parts with your features and the data you have. The prompt is built to make Claude show its work, flag what's uncertain, and sanity-check the ranking instead of just spitting out numbers.

I need to prioritize these features using RICE. Score each one and rank them.

Features:
[List 4-10 features. For each, give a one-line description plus any data
you have — usage numbers, support volume, revenue tied to it, requests, etc.]

Scoring rules:
- Reach: How many users this affects per quarter. Use a real count. If I
  haven't given you a number, estimate one and label it an assumption.
- Impact: Per-user effect on [your primary metric — activation, retention,
  expansion revenue, etc.] on the RICE scale (3=massive, 2=high, 1=medium,
  0.5=low, 0.25=minimal).
- Confidence: 100% = strong data, 80% = some evidence, 50% = a guess.
  Be conservative. Lower the confidence when the Reach or Impact is a guess.
- Effort: Person-months to ship, including design and QA, not just dev.

For each feature:
1. Show your reasoning for each of the four scores in one line each.
2. Flag every assumption I should validate before trusting the number.
3. Compute the RICE score: (Reach × Impact × Confidence) / Effort.

Then:
- Rank all features by RICE score in a table.
- Add a "gut-check" column noting anything the math might be getting wrong
  (a strategic bet the score undervalues, a dependency the math ignores,
  a high score driven entirely by a shaky assumption).
- End with the one prioritization call you'd defend and the single
  assumption that, if wrong, would change the order most.

The last instruction is the one most PMs skip. The ranking matters less than knowing which assumption is load-bearing. That's the thing to go validate before you commit a quarter to it.

The RICE Scoring Template

Drop this table into your doc or paste it to Claude as the output format. It keeps every feature on the same axes and leaves room for the reasoning, not just the numbers.

| Feature | Reach (users/qtr) | Impact (0.25–3) | Confidence (%) | Effort (mo) | RICE Score | Key Assumption to Validate |
|---------|-------------------|-----------------|----------------|-------------|------------|----------------------------|
| Feature A |  |  |  |  |  |  |
| Feature B |  |  |  |  |  |  |
| Feature C |  |  |  |  |  |  |
| Feature D |  |  |  |  |  |  |

The last column is what turns a scoring exercise into a research plan. Every row tells you exactly what to go check.

A Worked Example

Here's the framework on four real-shaped features for a B2B SaaS product. The primary metric is activation: getting new accounts to their first valuable action.

The four features, with the data on hand:

• Bulk CSV import. New accounts ask for it constantly; support sees roughly 40 requests a quarter. Saves manual data entry during setup.
• In-app onboarding checklist. A guided list that walks new users to first value. Every new account would see it. No hard data yet, just a strong hypothesis.
• SSO / SAML login. Enterprise prospects keep asking. Affects a small slice of accounts but unblocks larger deals.
• Dark mode. Frequently upvoted in the feedback board. Nice to have, no activation link.

Scored with the prompt above, on a base of ~500 new accounts per quarter:

The reasoning behind the numbers:

• Onboarding checklist. Reach is every new account (500). Impact is high (2) because it directly targets the activation metric, but not massive since not everyone follows a checklist. Confidence is 80%: the mechanism is well-proven across the industry, but we have no internal data yet, so it's not 100%. Effort is 2 months for design plus build. Score: (500 × 2 × 0.8) / 2 = 400.
• Bulk CSV import. Reach is the ~150 accounts per quarter who do bulk setup, not all 500. Impact is high (2) for those it reaches. Confidence is 90% because 40 explicit requests a quarter is real demand. Effort is 1.5 months. Score: (150 × 2 × 0.9) / 1.5 = 180.
• Dark mode. Reach looks big (400 would use it), but Impact on activation is minimal (0.25) because it doesn't help anyone reach first value. High confidence (90%) that it works as described, low confidence it moves the metric. Score: (400 × 0.25 × 0.9) / 1 = 90.
• SSO / SAML. Low Reach on activation (60 enterprise-leaning accounts), but massive per-account Impact (3) since it unblocks the deal entirely. Confidence 70%, effort high at 3 months. Score: (60 × 3 × 0.7) / 3 = 42.

Ranked output:

The load-bearing assumption: the onboarding checklist's 80% confidence. The entire ranking flips if a quick test shows checklists don't move activation for our users. That's the one thing to validate this week, before the math gets to dictate a quarter.

Notice what the worked example exposes that a bare spreadsheet hides. Dark mode's high Reach inflates its score past a feature that actually unblocks revenue. SSO is "ranked last" by pure RICE, yet the gut-check column is exactly where a PM earns their keep. RICE is an input to judgment, not a replacement for it.

From Prompt to a Prioritization Skill

The prompt above works. But you'll re-paste your product context, your activation metric, and your scoring rules every single time you run it. That setup tax is the difference between a prompt and a skill.

/prioritization-engine reads your product and goals context automatically. It already knows your primary metric, your personas, and what "high impact" means for your business, so it applies the same rubric on every backlog, every quarter, without you re-explaining the company. Same scoring rules, same output structure, no setup. That's how you get consistency across a whole PM team instead of one well-prompted afternoon.

If you're still building the foundation underneath it, two guides will help: AI PM workflows shows how prioritization fits into the larger discovery-to-delivery loop, and how to use Claude as a product manager maps the skills to the workflows they automate.

Download the Prioritization Engine free →

When you're ready to run it against your real context — product files, goals, and personas loaded — the solo plan is $39/mo with a 14-day free trial, cancel anytime. See pricing →

FAQ

Can AI do RICE scoring?

Yes, and it's better at the part that actually causes problems. AI handles the arithmetic, but its real value is forcing the reasoning behind each Reach, Impact, Confidence, and Effort score into the open. You get scored, ranked features plus a written rationale for every number, which is what makes the ranking defensible when someone challenges it. Treat the output as a strong first draft you sanity-check, not a verdict.

What's a good RICE prompt?

A good RICE prompt does three things a basic one skips: it tells the model to show its reasoning for each score, to flag assumptions you should validate, and to add a gut-check column for cases where the math misleads. Copy the prompt in this article — it bakes all three in, plus an instruction to name the single assumption that would most change the ranking if it's wrong.

How do I keep scoring consistent across PMs?

Standardize the inputs, not just the formula. Define what each Impact level means for your product, pick one Reach unit (users per quarter, say) and hold it constant, and write down how confidence maps to evidence strength. The fastest way to enforce that is a skill: /prioritization-engine applies the same rubric and your shared context to every PM's backlog, so two PMs scoring the same feature land in the same place.

Is the prioritization skill free?

Yes. You can download /prioritization-engine for free and run it. The free skill gives you the framework and structure. The paid solo plan ($39/mo, 14-day free trial, cancel anytime) is where it runs against your actual product, goals, and persona context automatically, so every score reflects your business instead of generic defaults.

About the Author

Ron Yang is the founder of mySecond — he builds and manages PM Operating Systems for product teams. Prior to mySecond, he led product at Aha! and is a product advisor to 25+ companies.

Browse the skills directory →

Set up Claude Code for PM work →