Skip to main content
skill CX Codex

prioritization · yonatangross — Claude Code skill: backlog ranking frameworks

prioritization — a skill for ranking backlog items using RICE, WSJF, ICE, MoSCoW and opportunity-cost analysis. The agent calculates scores, builds comparison tables and justifies trade-offs between competing features.

MIT 125 installs ★ 305 updated 2026-11-07

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add yonatangross/orchestkit --skill prioritization -a claude-code
Open on GitHub

What prioritization does

Includes five frameworks and a decision tree for when to apply each. RICE scores based on user reach, impact on metrics, confidence in data and effort — requires analytics and quantitative input. WSJF uses Fibonacci scales to assess user value, time criticality, risk reduction and job size — fits SAFe teams and deadline-driven work. ICE works without data, rating impact, confidence and ease on a 1-10 scale — useful for fast triage in early-stage products. MoSCoW sorts features into Must/Should/Could/Won't buckets — helps negotiate release scope with stakeholders. The skill adds a Value-Effort matrix for visual placement and a trade-off template when two features compete for the same team.

Signs of gaming metrics and common mistakes are listed in the pitfalls table: bloated Must-Haves over 70 % of release scope, mixing frameworks in one table, comparing RICE scores across different goals. The skill is not user-invocable, triggered by the product-strategist agent when prioritization or release planning comes up.

What it helps with

  • Pick three out of five tasks for the next sprint
  • Calculate RICE scores for backlog features and sort by descending value
  • Justify choosing a low-RICE migration over a high-scoring feature
  • Sort release requirements into MoSCoW buckets and mark the MVP boundary
  • Compare two features by cost of delay and recommend sequencing

Example prompts for the agent

  • Build a RICE table for tasks in backlog.md and sort by score
  • Compare smart search and dark mode using WSJF — which comes first
  • Split release 2.0 features into MoSCoW, keep Must-Haves under 60 % of effort

How to install prioritization

1Skills CLI (Vercel)

npx skills add yonatangross/orchestkit --skill prioritization -a claude-code

2Manually: put the files in place

~/.claude/skills/prioritization/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/prioritization/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about prioritization

How to install prioritization in Claude Code?

Run npx skills add yonatangross/orchestkit --skill prioritization -a claude-code, the skill will appear in ~/.claude/skills/prioritization/SKILL.md.

What does prioritization do?

The skill ranks backlog items using five methods: RICE for data-rich teams, WSJF for SAFe and regulated work, ICE for quick triage without data, MoSCoW for release scope negotiation, Value-Effort for visual placement.

When to use RICE versus WSJF?

RICE requires user count data and works for steady-state prioritization. WSJF fits hard deadlines or regulatory pressure — Cost of Delay determines task sequencing.

Source text

SKILL.md · MIT
---
name: prioritization
compatibility: "Claude Code 2.1.277+"
description: "RICE, WSJF, ICE, MoSCoW and opportunity-cost scoring. Use when ranking a backlog or justifying roadmap trade-offs."
user-invocable: false
disable-model-invocation: false
metadata:
  owner-agent: "product-strategist"
  category: document-asset-creation
  version: "1.0.0"
  author: "OrchestKit"
  complexity: "medium"
  tags: "rice, wsjf, ice, moscow, prioritization, backlog, scoring, ranking"
allowed-tools: "Read Glob Grep WebFetch WebSearch"
---

# Prioritization Frameworks

Score, rank, and justify backlog decisions using the right framework for the situation.

## Decision Tree: Which Framework to Use

```
Do you have a hard deadline or regulatory pressure?
  YES → WSJF (Cost of Delay drives sequencing)
  NO  → Do you have reach/usage data?
          YES → RICE (data-driven, accounts for user reach)
          NO  → Are you in a time-boxed planning session?
                  YES → ICE (fast, 1-10 scales, no data required)
                  NO  → Is this a scope negotiation with stakeholders?
                          YES → MoSCoW (bucket features, control scope creep)
                          NO  → Value-Effort Matrix (quick 2x2 triage)
```

| Framework | Best For | Data Required | Time to Score |
|-----------|----------|---------------|---------------|
| RICE | Data-rich teams, steady-state prioritization | Analytics, user counts | 30-60 min |
| WSJF | SAFe orgs, time-sensitive or regulated work | Relative estimates only | 15-30 min |
| ICE | Startup speed, early validation, quick triage | None | 5-10 min |
| MoSCoW | Scope negotiation, release planning | Stakeholder input | 1-2 hours |
| Value-Effort | 2x2 visual, quick team alignment | None | 10-15 min |

---

## RICE

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

| Factor | Scale | Notes |
|--------|-------|-------|
| Reach | Actual users/quarter | Use analytics; do not estimate |
| Impact | 0.25 / 0.5 / 1 / 2 / 3 | Minimal → Massive per user |
| Confidence | 0.3 / 0.5 / 0.8 / 1.0 | Moonshot → Strong data |
| Effort | Person-months | Include design, eng, QA |

```markdown
## RICE Scoring: [Feature Name]

| Feature     | Reach  | Impact | Confidence | Effort | Score  |
|-------------|--------|--------|------------|--------|--------|
| Smart search| 50,000 | 2      | 0.8        | 3      | 26,667 |
| CSV export  | 10,000 | 0.5    | 1.0        | 0.5    | 10,000 |
| Dark mode   | 30,000 | 0.25   | 1.0        | 1      |  7,500 |
```

See [rules/prioritize-rice.md](rules/prioritize-rice.md) for ICE, Kano, and full scale tables.

---

## WSJF

```
WSJF = Cost of Delay / Job Size
Cost of Delay = User Value + Time Criticality + Risk Reduction  (1-21 Fibonacci each)
```

Higher WSJF = do first. Fibonacci scale (1, 2, 3, 5, 8, 13, 21) forces relative sizing.

```markdown
## WSJF: GDPR Compliance Update

User Value:       8   (required for EU customers)
Time Criticality: 21  (regulatory deadline this quarter)
Risk Reduction:   13  (avoids significant fines)
Job Size:          8  (medium complexity)

Cost of Delay = 8 + 21 + 13 = 42
WSJF = 42 / 8 = 5.25
```

See [rules/prioritize-wsjf.md](rules/prioritize-wsjf.md) for MoSCoW buckets and practical tips.
See [references/wsjf-guide.md](references/wsjf-guide.md) for the full scoring guide.

---

## ICE

```
ICE Score = Impact × Confidence × Ease    (all factors 1-10)
```

No user data required. Score relative to other backlog items. Useful for early-stage products and rapid triage sessions.

---

## MoSCoW

Bucket features before estimation. Must-Haves alone should ship a viable product.

```markdown
## Release 1.0 MoSCoW

### Must Have (~60% of effort)
- [ ] User authentication
- [ ] Core CRUD operations

### Should Have (~20%)
- [ ] Search, export, notifications

### Could Have (~20%)
- [ ] Dark mode, keyboard shortcuts

### Won't Have (documented out-of-scope)
- Mobile app (Release 2.0)
- AI features (Release 2.0)
```

---

## Opportunity Cost & Trade-Off Analysis

When two items compete for the same team capacity, quantify what delaying each item costs per month.

```markdown
## Trade-Off: AI Search vs Platform Migration (Q2 eng team)

### Option A: AI Search
- Cost of Delay: $25K/month (competitive risk)
- RICE Score: 18,000
- Effort: 6 weeks

### Option B: Platform Migration
- Cost of Delay: $5K/month (tech debt interest)
- RICE Score: 4,000
- Effort: 8 weeks

### Recommendation
Human decides. Key factors:
1. Q2 OKR: Increase trial-to-paid conversion (favors AI Search)
2. Engineering capacity: Only one team, sequential not parallel
3. Customer commitment: No contractual deadline for either
```

See [rules/prioritize-opportunity-cost.md](rules/prioritize-opportunity-cost.md) for the Value-Effort Matrix and full trade-off template.
See [references/rice-scoring-guide.md](references/rice-scoring-guide.md) for detailed RICE calibration.

---

## Common Pitfalls

| Pitfall | Mitigation |
|---------|------------|
| Gaming scores to justify pre-decided work | Calibrate as a team; document assumptions |
| Mixing frameworks in one table | Pick one framework per planning session |
| Only tracking high-RICE items; ignoring cost of delay | Combine RICE with explicit delay cost analysis |
| MoSCoW Must-Have bloat (>70% of scope) | Must-Haves alone must ship a viable product |
| Comparing RICE scores across different goals | Only compare within the same objective |

---

## Related Skills

- `product-frameworks` — Full PM toolkit (value prop, market sizing, competitive analysis, user research, business case)
- `write-prd` — Convert prioritized features into product requirements documents
- `product-analytics` — Define and instrument the metrics that feed RICE reach/impact scores
- `okr-design` — Set the objectives that determine which KPIs drive RICE impact scoring
- `market-sizing` — TAM/SAM/SOM analysis that informs strategic priority
- `competitive-analysis` — Competitor context that raises or lowers WSJF time criticality scores

---

**Version:** 1.0.0

© OrchestKit · MIT · yonatangross/orchestkit

Similar skills

All skills for Agent setup: memory, context, orchestration →

prioritization by other authors comes first.

prioritization ysskrishna The prioritization Claude Code skill ranks work by value and effort, then draws a cut line. It applies to oversized backlogs, MVP scope decisions, and task lists that exceed capacity. CX Codex +1 ★ 25repo stars feature-prioritization Rudolf S. feature-prioritization applies RICE, MoSCoW, Kano, and value-effort frameworks to rank backlog items. Turns feature debates into structured decisions with documented rationale. CX Codex +1 ★ 587repo stars prioritization-advisor deanpeters prioritization-advisor picks a prioritization framework for your product stage and team, then explains how to run it. Useful when RICE, ICE and value/effort all look plausible. CX Codex +1 3,200installs roadmap-prioritization RefoundAI roadmap-prioritization turns a messy backlog into an ROI-based plan: RICE or DRICE scoring, portfolio balance, and a roadmap draft. Useful when feature requests pile up faster than you can rank them. CX Codex +1 509installs prioritization-frameworks borghei The prioritization-frameworks Claude Code skill selects a prioritization method and ranks backlog items. It covers problems, features, and initiatives. CX Codex +1 119installs define-prioritization-framework product-on-purpose define-prioritization-framework runs applicable prioritization frameworks across features to pinpoint where scoring models agree or clash. Useful when planning product roadmaps. CX Codex +1 737installs feature-prioritization-assistant pmprompt feature-prioritization-assistant calculates RICE scores and prioritizes feature backlogs systematically. Helps justify roadmap decisions to stakeholders with structured numbers. CX Codex +1 552installs

From the same set86

The whole set →
brainstorm The brainstorm skill explores a design question with parallel agents, filters ideas for feasibility, and compares trade-offs. It does not build or fix code. CX Codex +1 133installs setup Scans a project, identifies its stack, suggests skills and MCP servers, then rates readiness. It also supports rescans and focused setup modes. CX Codex +1 133installs testing-integration The testing-integration skill supports integration and contract tests for APIs, services, databases, and Zod schemas. It applies when testing API or service boundaries. CX Codex +1 131installs testing-llm The testing-llm skill covers tests for LLM-powered features, from mocked replies to RAG quality checks and structured output validation. Use it while building an AI test suite. CX Codex +1 126installs competitive-analysis competitive-analysis generates Porter's Five Forces models, SWOT grids, competitor dossiers, and positioning maps. Runs when researching market viability or crafting sales battlecards. CX Codex +1 125installs visualize-plan visualize-plan turns a proposed change into before-and-after architecture views, a risk map, and an execution sequence. Use it to review a plan or changes on the current branch. CX Codex +1 124installs market-sizing market-sizing is a Claude Code skill that calculates TAM, SAM and SOM using top-down and bottom-up methods, then cross-validates them. It runs when sizing a market or preparing pitch slides. CX Codex +1 124installs ai-ui-generation ai-ui-generation — a skill for Claude Code and Codex that enforces rules for generating, reviewing, and integrating AI-built UI components. Triggers on UI component creation and MCP visual rendering. CX Codex +1 123installs

Project sponsors

Companies that keep this analytics open