Skip to content

jacob-balslev/skill-graph / marketplace/skills/prioritization

prioritization

Verified

This skill provides prioritization frameworks for AI engineering: RICE-A (adding AI Ambiguity to RICE) for product features, ICE for research experiments, and MoSCoW for MVP/Release scoping. Use when ranking the backlog, deciding which model research path to follow, or defining the scope of a new feature. Do NOT use for one-off task sequencing (use task skill) or personal time management.

Prioritization

Concept of the skill

This skill provides prioritization frameworks for AI engineering: RICE-A (adding AI Ambiguity to RICE) for product features, ICE for research experiments, and MoSCoW for MVP/Release scoping.

Domain Context

What is this skill? This skill provides prioritization frameworks for AI engineering: RICE-A (adding AI Ambiguity to RICE) for product features, ICE for research experiments, and MoSCoW for MVP/Release scoping. Use when ranking the backlog, deciding which model research path to follow, or defining the scope of a new feature. Do NOT use for one-off task sequencing (use task skill) or personal time management.

Workflow

Use the ordered phases, checklists, and guardrails in the sections below as the canonical workflow for this skill. When multiple subsections describe steps, follow them in the order presented.

Coverage

Three prioritization frameworks (RICE-A, ICE, MoSCoW), the Human vs AI Matrix for task delegation, accuracy threshold setting to prevent scope creep, and framework selection rules for matching the right framework to the current development phase.

Philosophy of the skill

Without explicit prioritization frameworks, agents default to working on whatever seems most interesting or most recently mentioned. In AI-assisted development, this is especially dangerous because research tasks have unbounded ambiguity. The RICE-A extension adds an Ambiguity denominator that forces experimental work through a research phase before it competes with proven features for engineering time. This skill prevents the two most common prioritization failures: shipping low-confidence features ahead of proven ones, and chasing diminishing accuracy returns instead of delivering core value.

Prioritization is the science of ranking work by expected impact vs. effort. In AI development, traditional prioritization fails because it ignores research uncertainty. Good prioritization accounts for model ambiguity while maximizing the delivery of core product value.

1. RICE-A Framework — Product Feature Prioritization

Use for ranking user-facing features when you have a baseline model.

$$Score = \frac{Reach \times Impact \times Confidence}{Effort \times (\frac{Ambiguity}{2})}$$

RICE-A Definitions

FactorDefinitionScale
ReachUsers/quarter affectedAbsolute number
ImpactContribution to core value proposition3 (Massive) to 0.25 (Minimal)
ConfidenceData quality & baseline model presence100% (Proven) to 50% (Guess)
EffortPerson-weeks (Inference + Data effort)Number
Ambiguity"Unknown unknowns" of model performance1 (Deterministic) to 5 (Highly Experimental)

Rule: A high Ambiguity (A) score acts as a denominator that lowers the priority of experimental features until they move through the ICE research phase.

2. ICE Framework — Research Prioritization

Use for ranking 10+ experiments when you are in the "Discovery" phase.

$$Score = Impact \times Confidence \times Ease$$

FactorScale (1-10)Definition
Impact1-10How much does this improve the baseline metric?
Confidence1-10How sure are we that this experiment will succeed?
Ease1-10How fast can we run this experiment (ignoring long-term COGS)?

Rule: ICE is for "fail-fast" research. Prioritize the highest score to find the working model architecture before applying RICE-A for product integration.

3. MoSCoW Method — MVP/Release Scoping

Use for defining the "Musts" of a specific delivery milestone.

CategoryDefinitionAI Example
Must-HaveNon-negotiable core functionality"Model must correctly calculate profit_cents"
Should-HaveHigh priority but not critical for launch"Latency should be < 2s for 95% of queries"
Could-HaveDesirable enhancements ("Nice-to-have")"Multi-modal image support for product matching"
Won't-HaveOut of scope for this milestone" chasing the final 0.1% of accuracy"

Rule: Protect the team from "Accuracy Creep". Define the "Must-Have" accuracy threshold before starting implementation.

4. The Human vs. AI Matrix (The Gold Quadrant)

Prioritize work based on who is best suited for the task.

       High |  (1) AI ASSISTED       |  (2) THE GOLD QUADRANT 
Human       |  (Research, Strategy)  |  (Bulk Gen, Triage, Tests)
Effort      |------------------------|--------------------------
            |  (3) IGNORE            |  (4) HUMAN ONLY
       Low  |  (Trivial Tasks)       |  (Creative, High-Stakes)
            ----------------------------------------------------
                   High              Low
                       AI Effort
  • The Gold Quadrant: High Human Effort / Low AI Effort. These tasks have the highest ROI for AI agents (e.g., generating 50 tests, triaging 1000 logs).

Verification

PRIORITIZATION CHECK
====================
[ ] Framework matches the phase (ICE for Research, RICE-A for Product)
[ ] Ambiguity (A) score assigned for experimental features
[ ] Confidence score grounded in data quality (not just vibes)
[ ] MoSCoW defined for the current milestone
[ ] Accuracy threshold set (prevents Accuracy Creep)
[ ] Task sits in the "Gold Quadrant" for AI agents

Do NOT Use When

Instead of this skillUseWhy
Sequencing the steps inside one chosen tasktask-path-optimizationTask-path optimization owns execution order; prioritization owns which work item should be selected.
Estimating confidence under uncertaintybayesian-reasoningBayesian reasoning owns evidence updates; prioritization consumes confidence as one scoring input.
Competitive positioning or market strategypositioningPositioning shapes market claims and alternatives; prioritization ranks work after strategy inputs are known.
Defining product requirements or specificationsspec-driven-developmentPrioritization ranks work; SDD defines what the work contains

Source: REPORTS/Report_UI-UX-Thesis-Audit_Gemini-3-Flash_13-03-2026-05-15.md

Skill Graph context

Classification

  • Subject: software-engineering-method (also: reasoning-strategy)
  • Public: true
  • Scope: Teaches work-ranking frameworks for AI-assisted engineering: RICE-A for product feature priority under ambiguity, ICE for research experiment ordering, MoSCoW for release scope, and human-vs-AI effort mapping. Portable across backlogs, roadmap choices, and model-research queues. Excludes within-session task sequencing, raw effort estimation, market-positioning strategy, and requirements definition.

When to use

  • Triggers: prioritization-skill, roadmap-skill, priority-planning-mode

Related skills

  • Related: constraint-awareness, bayesian-reasoning, playing-to-win, porters-five-forces, seven-powers

Keywords

  • prioritization, RICE, ICE, MoSCoW, RICE-A, AI ambiguity, feature ranking, research prioritization, backlog management, MVP scope
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 465kUpdated Claude CodeCodexUnverifiedInstall
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 465kUpdated Claude CodeCodexUnverifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 318kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 318kUpdated Claude CodeCodexVerifiedInstall