Prioritization Frameworks

# Create a "Prioritization Frameworks" AI Skill

I want you to help me set up a reusable AI skill that I can use in future conversations. Read the complete skill definition below, then help me install it.

## Complete Skill Definition

# Prioritization Framework Expert

## Overview

A comprehensive reference to 9 prioritization frameworks with automated scoring, ranking, and guidance on which framework to use in which situation. The core principle: prioritize problems (opportunities), not features. Features are solutions to problems. If you prioritize features directly, you skip the step of understanding whether the problem is worth solving.

### When to Use

- **Backlog Grooming** -- Too many items, need to rank them objectively.
- **Quarterly Planning** -- Deciding which initiatives to invest in.
- **Stakeholder Alignment** -- Need a structured way to resolve competing priorities.
- **Feature Triage** -- Quick sorting of a long list into actionable categories.

## Framework Decision Tree

Use this to pick the right framework for your situation:

```
START: What are you prioritizing?
  |
  +-- Customer problems/opportunities
  |     -> Opportunity Score (recommended)
  |
  +-- Features or initiatives
  |     |
  |     +-- Need a quick sort (< 15 items)?
  |     |     -> ICE or Impact vs Effort
  |     |
  |     +-- Need rigorous scoring (15+ items)?
  |     |     -> RICE
  |     |
  |     +-- Need stakeholder buy-in on criteria?
  |     |     -> Weighted Decision Matrix
  |     |
  |     +-- Need to categorize requirements?
  |           -> MoSCoW
  |
  +-- Personal PM tasks
  |     -> Eisenhower Matrix
  |
  +-- High-uncertainty initiatives
  |     -> Risk vs Reward
  |
  +-- Understanding user expectations (not prioritizing)
        -> Kano Model
```

## The 9 Frameworks

### 1. Opportunity Score (Recommended for Customer Problems)

**Source:** Dan Olsen, *Lean Product Playbook*

**Formula:** `Score = Importance x (1 - Satisfaction)`

- **Importance** (0-10): How important is this problem to the customer?
- **Satisfaction** (0-1): How well do existing solutions satisfy this need? (0 = not at all, 1 = perfectly)

**Why it works:** It identifies the biggest gaps between what customers need and what they currently have. High importance + low satisfaction = high opportunity.

**Example:**

| Problem | Importance | Satisfaction | Score |
|---------|-----------|-------------|-------|
| Finding products quickly | 9 | 0.3 | 6.3 |
| Comparing prices | 7 | 0.8 | 1.4 |
| Tracking order status | 8 | 0.6 | 3.2 |

"Finding products quickly" scores highest because it is very important and poorly solved today.

### 2. ICE -- Impact x Confidence x Ease

**Best for:** Quick prioritization of a short list (under 15 items).

**Formula:** `Score = Impact x Confidence x Ease`

All three scored 1-10:
- **Impact:** How much will this move the target metric?
- **Confidence:** How sure are we about the impact estimate?
- **Ease:** How easy is this to implement? (10 = trivial, 1 = massive effort)

**Strengths:** Fast, simple, includes uncertainty.
**Weakness:** Subjective. Different people give different scores. Best used as a starting point for discussion, not a final answer.

### 3. RICE -- (Reach x Impact x Confidence) / Effort

**Best for:** Rigorous prioritization of a longer list.

**Formula:** `Score = (Reach x Impact x Confidence) / Effort`

- **Reach:** How many users/customers will this affect in a given time period? (number)
- **Impact:** How much will it affect each user? (3 = massive, 2 = high, 1 = medium, 0.5 = low, 0.25 = minimal)
- **Confidence:** How sure are we? (100% = high, 80% = medium, 50% = low)
- **Effort:** Person-months of work required (number)

**Strengths:** Reach adds a dimension that ICE misses. Effort is estimated in real units, not abstract scores.
**Weakness:** Requires more data (reach estimates, effort sizing).

### 4. Eisenhower Matrix

**Best for:** Personal task management for PMs, not product prioritization.

**Quadrants:**

|  | Urgent | Not Urgent |
|--|--------|------------|
| **Important** | Do First | Schedule |
| **Not Important** | Delegate | Eliminate |

- **Q1 (Do First):** Crisis, deadline-driven. Handle immediately.
- **Q2 (Schedule):** Strategic work, planning, prevention. This is where PMs should spend most of their time.
- **Q3 (Delegate):** Interruptions, some meetings, some emails. Hand off if possible.
- **Q4 (Eliminate):** Time-wasters, unnecessary meetings. Stop doing these.

### 5. Impact vs Effort (2x2 Matrix)

**Best for:** Quick visual triage in a group setting.

**Quadrants:**

|  | Low Effort | High Effort |
|--|-----------|-------------|
| **High Impact** | Quick Wins (do first) | Major Projects (plan carefully) |
| **Low Impact** | Fill-ins (do if time allows) | Money Pits (avoid) |

**How to use:** Plot items on a whiteboard. Discuss placement. The conversation matters more than the exact position.

### 6. Risk vs Reward

**Best for:** Initiatives with significant uncertainty.

**Extension of Impact vs Effort** that adds an uncertainty dimension:

- **Reward** = Expected impact if successful
- **Risk** = Probability of failure x cost of failure

**Quadrants:**

|  | Low Risk | High Risk |
|--|---------|-----------|
| **High Reward** | Safe Bets (prioritize) | Bold Bets (invest selectively) |
| **Low Reward** | Incremental (batch) | Avoid |

### 7. Kano Model

**Best for:** Understanding customer expectations. Not for prioritization directly.

**Categories:**

- **Must-Be (Basic):** Customers expect these. Absence causes dissatisfaction. Presence does not cause delight. (Example: a login page works.)
- **One-Dimensional (Performance):** More is better, linearly. (Example: faster page loads = happier users.)
- **Attractive (Delighters):** Unexpected features that create excitement. Absence does not cause dissatisfaction. (Example: automatic dark mode based on system setting.)
- **Indifferent:** Customers do not care either way.
- **Reverse:** Some customers actively dislike this feature.

**Use Kano to understand**, then use another framework (RICE, ICE) to prioritize.

### 8. Weighted Decision Matrix

**Best for:** Multi-factor decisions that need stakeholder buy-in.

**Process:**
1. Define criteria (e.g., customer impact, revenue potential, technical feasibility, strategic alignment).
2. Assign weights to each criterion (must sum to 100%).
3. Score each option against each criterion (1-5 or 1-10).
4. Multiply scores by weights and sum.
5. Rank by total weighted score.

**Strengths:** Transparent, auditable, gets stakeholders to agree on criteria before scoring.
**Weakness:** Time-consuming. Best for 5-10 high-stakes decisions, not 50-item backlogs.

### 9. MoSCoW

**Best for:** Requirements categorization within a fixed scope.

**Categories:**
- **Must Have:** Non-negotiable. Without these, the release has no value.
- **Should Have:** Important but not critical. Painful to leave out but the release still works.
- **Could Have:** Desirable. Include if time and resources allow.
- **Won't Have (this time):** Explicitly out of scope. Acknowledged but deferred.

**Rule of thumb:** Must-Haves should be no more than 60% of the total effort. If everything is a Must-Have, nothing is.

## Core Principle: Prioritize Problems, Not Features

Features are solutions. Problems are what matter. Two teams can build different features to solve the same problem. If you prioritize features, you lock in a solution before understanding the problem space.

**Workflow:**
1. List customer problems (use Opportunity Score to rank them).
2. Pick the top problems to solve.
3. Generate multiple solution ideas for each problem.
4. Prioritize solutions using RICE or ICE.
5. Build the highest-scoring solutions.

This two-step approach (prioritize problems, then prioritize solutions) produces better outcomes than a single pass over a feature list.

## Tools

| Tool | Purpose | Command |
|------|---------|---------|
| `prioritization_scorer.py` | Score and rank items | `python scripts/prioritization_scorer.py --input items.json --framework rice` |
| `prioritization_scorer.py` | Demo with sample data | `python scripts/prioritization_scorer.py --demo --framework rice` |

Supported frameworks: `rice`, `ice`, `opportunity`, `moscow`, `weighted`

## Troubleshooting

| Symptom | Likely Cause | Resolution |
|---------|-------------|------------|
| RICE scores dominated by high-reach items regardless of impact | Reach values vary by orders of magnitude, drowning out other factors | Normalize reach to a consistent time window (e.g., users per quarter); consider log-scale for extreme ranges |
| ICE scores feel arbitrary and inconsistent across raters | No calibration on 1-10 scale definitions; different people use different anchors | Define what 1, 5, and 10 mean for each dimension; score independently first, then discuss outliers |
| MoSCoW results in 80% Must-Haves | Team reluctant to deprioritize anything, or no effort constraint applied | Enforce the rule: Must-Haves should be no more than 60% of total effort; make the constraint visible |
| Opportunity Score returns 0 for satisfied needs | Satisfaction scored at 1.0 (fully satisfied), zeroing out the score | Verify satisfaction is on 0-1 scale; values above 1 are auto-converted from 0-10 scale |
| Weighted Decision Matrix produces tied scores | Criteria weights are too evenly distributed, or scoring lacks variance | Increase weight differentiation; force-rank criteria by importance; use the full 1-10 scoring range |
| Framework selection is itself a bottleneck | Team spends time debating which framework to use instead of scoring | Use the Decision Tree in this skill; default to RICE for 15+ items with data, ICE for quick sorts under 15 items |
| Stakeholders disagree with prioritization results | Framework selected does not match stakeholder values, or inputs not transparent | Use Weighted Decision Matrix when multiple stakeholder groups are involved; agree on criteria and weights before scoring |

## Success Criteria

- Prioritization framework selected using the Decision Tree, not by habit or preference
- All items scored with consistent definitions for each dimension (documented before scoring begins)
- Results reviewed and discussed as a team, not treated as a mechanical ranking
- Top-priority items have clear next steps (assigned to sprints, PRDs, or experiments)
- Prioritization is repeated at least quarterly, or when significant new information arrives
- The two-step approach is followed: prioritize problems first (Opportunity Score), then prioritize solutions (RICE/ICE)
- MoSCoW Must-Haves never exceed 60% of total effort for a release

## Scope & Limitations

**In Scope:**
- 9 prioritization frameworks with scoring, ranking, and explanation (RICE, ICE, Opportunity Score, Eisenhower, Impact vs. Effort, Risk vs. Reward, Kano, Weighted Decision Matrix, MoSCoW)
- Automated scoring and ranking for RICE, ICE, Opportunity Score, MoSCoW, and Weighted Decision Matrix
- Framework selection guidance via Decision Tree
- Demo data for each framework to illustrate input/output formats

**Out of Scope:**
- Real-time Jira/Linear backlog integration (manual JSON input required)
- Cost-of-delay or WSJF calculations (see `senior-pm/` skill for SAFe portfolio prioritization)
- User research to gather importance/satisfaction data for Opportunity Score (see `product-team/` skills)
- Strategic portfolio allocation decisions (see `senior-pm/` skill)

**Important Caveats:**
- No framework produces a "correct" answer. Prioritization frameworks are decision-support tools that structure conversation, not algorithms that replace judgment.
- RICE and ICE are best for data-rich environments. If your reach and impact estimates are pure guesses, the precision of the formula is misleading.
- The most successful teams combine frameworks: start with Opportunity Score to identify the right problems, then use RICE to rank solutions. Single-framework teams often prioritize solutions to the wrong problems.
- For teams with 50+ people or multiple stakeholder groups, use WSJF or Weighted Decision Matrix with agreed criteria to ensure buy-in.

## Integration Points

| Integration | Direction | Description |
|------------|-----------|-------------|
| `execution/outcome-roadmap/` | Feeds into | Prioritized items inform Now/Next/Later horizon placement |
| `execution/create-prd/` | Feeds into | Top-priority items become PRD candidates with P0/P1/P2 feature labels |
| `execution/brainstorm-okrs/` | Complements | Prioritized initiatives inform which OKR theme to focus on this quarter |
| `discovery/identify-assumptions/` | Receives from | Assumption risk scores inform item confidence ratings in RICE/ICE |
| `scrum-master/` | Feeds into | Prioritized backlog items feed sprint planning commitment decisions |
| `senior-pm/` | Receives from | Portfolio-level WSJF or strategic priorities constrain team-level prioritization |

## Tool Reference

### prioritization_scorer.py

Scores and ranks items using 5 supported prioritization frameworks. Outputs sorted results with scores, formulas, and category breakdowns.

| Flag | Type | Default | Description |
|------|------|---------|-------------|
| `--input` | string | (required, mutually exclusive with --demo) | Path to JSON file containing items to score |
| `--demo` | flag | off | Run scoring on built-in demo data for the selected framework |
| `--framework` | choice | (required) | Framework to use: `rice`, `ice`, `opportunity`, `moscow`, `weighted` |
| `--format` | choice | `text` | Output format: `text` or `json` |

**Input JSON schema by framework:**

- **RICE:** `{"items": [{"name": "...", "reach": N, "impact": N, "confidence": N, "effort": N}]}`
- **ICE:** `{"items": [{"name": "...", "impact": N, "confidence": N, "ease": N}]}`
- **Opportunity:** `{"items": [{"name": "...", "importance": N, "satisfaction": N}]}`
- **MoSCoW:** `{"items": [{"name": "...", "category": "must|should|could|wont", "effort": N}]}`
- **Weighted:** `{"items": [{"name": "...", "scores": {"criterion": N}}], "criteria": [{"name": "...", "weight": N}]}`

## References

- `references/prioritization-guide.md` -- Detailed formulas, decision tree, and facilitation tips
- `assets/prioritization_matrix_template.md` -- Scoring templates for each framework

---

## What I Need You to Do

First, detect which platform I'm using (Claude.ai, ChatGPT, etc.) and follow the matching instructions below.

### If I'm on Claude.ai:

Walk me through these exact steps:

1. **Create the Project:** Tell me to go to **claude.ai > Projects > Create project** and name it **"Prioritization Frameworks"**

2. **Add Project Knowledge:** Give me the COMPLETE skill definition above as a single copyable text block inside a code fence. Tell me to click **"Add content" > "Add text content"** inside the project, then paste that entire block. Do NOT say "paste from above" -- give me the actual text to copy right there.

3. **Set Custom Instructions:** Tell me to open project settings and paste this exact instruction:
   "You are an expert Prioritization Frameworks in the Project Management domain. Use the project knowledge as your expertise. Follow the workflows, frameworks, and templates defined there. Always provide specific, actionable output."

4. **Test It:** Give me a specific sample prompt I can use inside the new project to verify it works. Pick a real task from the skill's workflows.

### If I'm on ChatGPT:

Walk me through these exact steps:

1. **Create a Custom GPT:** Tell me to go to **chatgpt.com > Explore GPTs > Create**
2. **Configure it:**
   - Name: **"Prioritization Frameworks"**
   - Description: "Comprehensive prioritization framework expert covering 9 methods with scoring tools and decision guidance for product managers."
   - Instructions: Give me the COMPLETE skill definition above as a single copyable text block inside a code fence to paste into the Instructions field. Do NOT say "paste from above."
3. **Test It:** Give me a sample prompt to verify it works.

### If I'm on another platform:
Ask which tool I'm using and adapt the instructions accordingly.

## Important
- Always provide the full skill text in a ready-to-copy code block -- never tell me to "scroll up" or "copy from above"
- Keep the setup steps simple and numbered
- After setup, test it with me using a real workflow from the skill

Source: https://github.com/borghei/Claude-Skills/tree/main/project-management/execution/prioritization-frameworks/SKILL.md