# ICE, RICE, Kano, and Opportunity Score Prioritization Frameworks Compared

> Compare ICE, RICE, Kano, and Opportunity Score prioritization frameworks. Understand their unique approaches to scoring and selecting initiatives for maximum impact.

- Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills)
- Tags: comparison
- Published: 2026-06-13

---

**ICE, RICE, Kano, and Opportunity Score differ fundamentally in scope and calculation: Opportunity Score quantifies problem value using importance and satisfaction gaps; ICE extends this to initiatives by multiplying impact, confidence, and ease; RICE scales ICE by separating reach and dividing by effort; while Kano abandons numeric scoring to classify features by their influence on customer delight.**

Product management teams require systematic methods to decide which ideas deserve immediate attention. The **phuryn/pm-skills** repository provides a comprehensive reference for these decision-making tools, detailing exactly when to apply each framework. Understanding the differences between ICE, RICE, Kano, and Opportunity Score prioritization frameworks ensures you select the right model for your specific decision context.

## Opportunity Score: Quantifying Problem Value

The **Opportunity Score** serves as the foundational calculation for identifying which customer problems to solve. According to the source code in [`pm-execution/skills/prioritization-frameworks/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/prioritization-frameworks/SKILL.md) (lines 14-23), this framework calculates value using the formula:

```python
Opportunity Score = Importance × (1 − Satisfaction)

```

This metric measures how important a need is **and** how poorly it is currently satisfied. Unlike the other frameworks, Opportunity Score focuses exclusively on *problems* rather than solutions, making it ideal for the discovery phase before committing to specific features.

## The ICE Framework: Rapid Initiative Triage

**ICE** provides a lightweight method for ranking initiatives when teams need quick decisions. As implemented in the repository's prioritization skill (lines 27-35), ICE multiplies three factors:

```python
ICE Score = Impact × Confidence × Ease

```

Where **Impact** itself is defined as `Opportunity Score × #Customers`, ensuring the calculation remains rooted in actual problem value. This framework excels when teams need fast triage of ideas without extensive overhead.

## The RICE Framework: Scaled Prioritization with Effort

**RICE** extends ICE to handle larger product backlogs where resource constraints matter. The formula, detailed in [`pm-execution/skills/prioritization-frameworks/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/prioritization-frameworks/SKILL.md) (lines 37-46), adds granularity by separating reach and explicitly accounting for effort:

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

```

Here, **Reach** represents the number of customers affected per quarter, while **Effort** estimates the total work required (typically in person-months). This denominator ensures high-effort initiatives must demonstrate significantly higher value to rank above quick wins.

## The Kano Model: Qualitative Feature Classification

Unlike the numeric approaches above, the **Kano Model** uses qualitative classification to map how features influence customer satisfaction. According to the framework overview in the same SKILL file (lines 55-60), features fall into categories including:

- **Must-Be**: Basic expectations whose absence causes dissatisfaction but whose presence goes unnoticed
- **Performance**: Features where satisfaction increases linearly with investment
- **Attractive**: Delighters that create disproportionate satisfaction when present but don't cause dissatisfaction when absent
- **Indifferent**: Features customers don't care about
- **Reverse**: Features that actively annoy users

This framework answers *what type* of feature will delight customers rather than generating a sortable numeric rank.

## Key Differences and Selection Criteria

| Framework | Formula Type | Primary Question | Best For |
|-----------|--------------|------------------|----------|
| **Opportunity Score** | `Importance × (1 − Satisfaction)` | Which problems should we solve? | Discovery and problem validation |
| **ICE** | `Impact × Confidence × Ease` | Which initiatives should we start now? | Fast triage with limited data |
| **RICE** | `(Reach × Impact × Confidence) / Effort` | Which initiatives maximize value per unit effort? | Large backlogs with varying effort levels |
| **Kano** | Qualitative classification | What type of feature meets expectations? | Roadmap shaping and feature design |

The **pm-product-discovery/skills/prioritize-features/SKILL.md** file provides additional guidance on selecting between these frameworks based on your team's current maturity and data availability.

## Practical Implementation Examples

Below are Python implementations demonstrating how to calculate each score using the formulas from the phuryn/pm-skills repository:

```python

# Base metrics from user research

importance = 0.9          # 0-1 scale (high importance)

satisfaction = 0.2        # 0-1 scale (low satisfaction)

customers = 1500          # affected users

confidence = 8            # 1-10 scale (high confidence)

ease = 6                  # 1-10 scale (moderate ease)

effort = 3                # person-months

# Opportunity Score: Foundational problem value

opp_score = importance * (1 - satisfaction)
print(f"Opportunity Score: {opp_score:.2f}")  # 0.72

# ICE: Quick initiative ranking

impact = opp_score * customers
ice_score = impact * confidence * ease
print(f"ICE Score: {ice_score}")  # 51840

# RICE: Scaled prioritization with effort denominator

reach = customers
rice_score = (reach * opp_score * confidence) / effort
print(f"RICE Score: {rice_score:.2f}")  # 2880.0

```

For Kano classification, you typically analyze survey responses using a helper function:

```python
def kano_category(func_satis, dissat):
    """
    Classify features based on satisfaction percentages.
    func_satis: % satisfied when feature is present
    dissat: % dissatisfied when feature is absent
    """
    if func_satis > 80 and dissat < 20:
        return "Must-Be"
    if func_satis > 60 and dissat > 40:
        return "Performance"
    if func_satis > 60 and dissat < 40:
        return "Attractive"
    if func_satis < 30:
        return "Indifferent"
    return "Reverse"

# Example: A basic login feature

print(kano_category(85, 10))  # Output: Must-Be

```

The **pm-product-discovery/skills/prioritize-assumptions/SKILL.md** file demonstrates applying these same formulas specifically to assumption testing, reinforcing their use beyond feature prioritization.

## Summary

- **Opportunity Score** provides the foundational metric for valuing customer problems using importance and satisfaction gaps, calculated as `Importance × (1 − Satisfaction)`.
- **ICE** extends Opportunity Score to initiatives by multiplying impact (problem value × customers), confidence, and ease for rapid triage.
- **RICE** scales ICE for complex backlogs by separating reach from impact and dividing by effort, revealing true value-per-unit-cost.
- **Kano** abandons numeric scoring to classify features by their emotional impact on customers, guiding roadmap strategy rather than immediate rankings.

## Frequently Asked Questions

### Which prioritization framework works best for early-stage startups?

Early-stage startups with limited user data should start with **Opportunity Score** to validate which problems matter most, then graduate to **ICE** for quick initiative ranking. According to the `prioritize-features` skill in the phuryn/pm-skills repository, RICE often proves too heavy for nascent products with small teams, while Kano requires substantial user research that pre-launch startups may lack.

### Can I combine the Kano Model with ICE or RICE?

Yes. Use **Kano** first to determine *what type* of feature you're building (Must-Be, Performance, or Attractive), then apply **ICE** or **RICE** to prioritize among features within the same category. This hybrid approach ensures you balance customer expectation mapping with resource allocation, as suggested in the repository's prioritization framework documentation.

### How should I calculate confidence scores objectively?

The **phuryn/pm-skills** repository recommends anchoring confidence to evidence quality rather than gut feeling. In the [`prioritization-frameworks/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/prioritization-frameworks/SKILL.md) file, confidence scores typically range 1-10 based on: direct customer validation (9-10), wireframe testing (6-8), or pure assumption (1-5). The `prioritize-assumptions` skill specifically applies ICE and RICE to test risky assumptions by forcing teams to justify confidence ratings with concrete data.

### Why does RICE divide by effort while ICE multiplies by ease?

**ICE** uses **Ease** (higher is better) as a multiplier because it targets fast triage where effort estimation may be imprecise. **RICE** uses **Effort** (higher is worse) as a divisor to create a true cost-benefit ratio suitable for larger backlogs where resource constraints dominate decisions. This mathematical distinction reflects the different scales at which each framework operates, as detailed in lines 27-46 of the repository's prioritization skill file.