| name | feature-prioritizer |
| description | Evaluate and prioritize product features using RICE, ICE, and Value vs Effort frameworks with visual matrices |
Feature Prioritizer
Overview
The Feature Prioritizer skill helps AI Product Managers make data-driven decisions about what to build next. It applies multiple prioritization frameworks (RICE, ICE, Value vs. Effort), generates comparison matrices, and provides strategic recommendations for feature roadmapping.
When to Use This Skill
- Planning quarterly or annual roadmaps
- Evaluating a large feature backlog
- Making build vs. buy vs. partner decisions
- Responding to stakeholder feature requests
- Resolving conflicts about priorities
- Communicating trade-offs to leadership
- Balancing technical debt vs. new features
- Comparing AI/ML investment opportunities
PM Frameworks Applied
- RICE Scoring: Reach × Impact × Confidence / Effort
- ICE Scoring: (Impact + Confidence + Ease) / 3
- Value vs. Effort Matrix: 2x2 matrix for visual prioritization
- Weighted Scoring: Custom weights for company priorities
- Strategic Alignment: Fit with company OKRs and vision
- Dependency Mapping: Understanding feature relationships
- Risk-Adjusted Scoring: Accounting for uncertainty
Inputs Required
{
"features": [
{
"name": "string",
"description": "string",
"reach": "number (users affected per quarter)",
"impact": "number (0.25-3.0 scale)",
"confidence": "number (0.0-1.0 scale)",
"effort": "number (person-months)",
"strategic_alignment": "number (1-5 scale, optional)",
"dependencies": ["list of feature names, optional"],
"risk_level": "string (low/medium/high, optional)"
}
],
"company_priorities": {
"growth_weight": "number (0.0-1.0, optional)",
"retention_weight": "number (0.0-1.0, optional)",
"monetization_weight": "number (0.0-1.0, optional)"
},
"constraints": {
"max_effort_per_quarter": "number (optional)",
"required_features": ["list, optional"]
}
}
Outputs Produced
- Prioritized Feature List - Features ranked by RICE and ICE scores
- Value vs. Effort Matrix - Visual 2x2 matrix in ASCII or data format
- Strategic Recommendations - Which features to build, defer, or cut
- Roadmap Scenarios - Different options based on resource availability
- Risk Analysis - Highlighting high-risk features
- Dependency Map - Features that should be built together
- Trade-off Analysis - What you're giving up by choosing certain features
Usage Instructions
Basic Invocation
Prioritize these features using RICE: [list 3-5 features with reach, impact, confidence, effort]
Detailed Invocation
I need to prioritize my feature backlog for Q1 planning. Here are the features:
1. AI-powered search - 50K users, high impact (2.0), 80% confidence, 4 months effort
2. Mobile app dark mode - 100K users, low impact (0.5), 95% confidence, 1 month effort
3. Advanced analytics dashboard - 10K users, massive impact (3.0), 60% confidence, 6 months effort
4. Social sharing - 75K users, medium impact (1.0), 70% confidence, 2 months effort
Company priorities: 60% growth, 30% retention, 10% monetization
Constraint: Maximum 8 person-months available
Generate RICE scores, ICE scores, value vs. effort matrix, and recommend Q1 roadmap.
Best Practices
- Use consistent units - Always measure reach in same timeframe (e.g., quarterly)
- Calibrate impact scale - 0.25=minimal, 0.5=low, 1.0=medium, 2.0=high, 3.0=massive
- Be honest about confidence - Low confidence should penalize risky bets
- Include all effort - Design, engineering, testing, documentation
- Consider dependencies - Some features unlock others
- Validate with stakeholders - Scoring is subjective, get alignment
- Revisit regularly - Priorities change, update scores quarterly
- Balance frameworks - No single framework is perfect
- Account for strategic value - Some features are strategic bets
Composition with Other Skills
Recommended Workflow
-
Before Prioritization:
user-research-analyzer → Understand user needscompetitive-analyzer → Know market dynamicsmetrics-dashboard-builder → Define success metrics
-
During Prioritization:
- Use this skill (
feature-prioritizer) → Score and rank features
- Iterate on assumptions with team
-
After Prioritization:
prd-generator → Create PRDs for top featuresroadmap-planner → Build visual roadmapstakeholder-communicator → Explain priorities and trade-offs
Common Pitfalls to Avoid
- Optimism bias - Overestimating impact, underestimating effort
- Recency bias - Overweighting recently requested features
- HiPPO effect - Letting highest paid person's opinion dominate
- Analysis paralysis - Over-analyzing instead of deciding
- Ignoring technical debt - Only prioritizing new features
- Missing dependencies - Building features in wrong order
- Forgetting maintenance - Not accounting for support burden
- Local optimization - Optimizing for team vs. company goals
Prioritization Framework Details
RICE Scoring
Formula: (Reach × Impact × Confidence) / Effort
When to use:
- Large feature sets (10+ features)
- Need quantitative justification
- Want to compare very different features
Strengths:
- Comprehensive and objective
- Forces thinking about all dimensions
- Easy to communicate to stakeholders
Limitations:
- Requires good data/estimates
- Doesn't capture strategic value well
- Can be gamed if not careful
ICE Scoring
Formula: (Impact + Confidence + Ease) / 3
When to use:
- Quick prioritization needed
- Early-stage features with limited data
- Evaluating experiments or bets
Strengths:
- Simple and fast
- Good for experiments
- Less data-intensive than RICE
Limitations:
- Doesn't account for reach
- All factors weighted equally
- More subjective
Value vs. Effort Matrix
Quadrants:
- Quick Wins (High Value, Low Effort) → Build first
- Big Bets (High Value, High Effort) → Plan carefully
- Fill Ins (Low Value, Low Effort) → Build if capacity
- Time Sinks (Low Value, High Effort) → Avoid
When to use:
- Visual communication to executives
- Simplifying complex decisions
- First-pass filtering of backlog
Python Functions
calculate_rice(reach: int, impact: float, confidence: float, effort: float) -> float
Calculates RICE prioritization score.
calculate_ice(impact: float, confidence: float, ease: float) -> float
Calculates ICE prioritization score.
generate_value_effort_matrix(features: list) -> dict
Creates 2x2 matrix categorizing features into quadrants.
apply_strategic_weights(features: list, weights: dict) -> list
Adjusts scores based on company strategic priorities.
identify_dependencies(features: list) -> dict
Maps feature dependencies and suggests build order.
generate_roadmap_scenarios(features: list, constraints: dict) -> list
Creates different roadmap options based on resource constraints.
assess_portfolio_balance(features: list) -> dict
Analyzes if feature mix balances growth, retention, technical debt, etc.
Output Format Example
## Feature Prioritization Results
### RICE Scores (Ranked)
| Rank | Feature | Reach | Impact | Confidence | Effort | RICE Score |
|------|---------|-------|--------|------------|--------|------------|
| 1 | Feature A | 50,000 | 2.0 | 80% | 4 | 20.0 |
| 2 | Feature B | 100,000 | 0.5 | 95% | 1 | 47.5 |
### Value vs. Effort Matrix
│
High │ [Big Bets] [Quick Wins]
│ Feature A Feature B
VALUE│
│ [Time Sinks] [Fill Ins]
Low │ Feature C Feature D
│
└─────────────────────────────
High Low
EFFORT
### Strategic Recommendations
**Build Now (Q1)**:
1. Feature B - Quick win with massive reach
2. Feature A - Strategic bet, high impact
**Defer to Q2**:
- Feature D - Low value, wait for capacity
**Cut from Roadmap**:
- Feature C - Time sink, recommend alternative approach
Related Documentation
- See
prd-generator for creating specs for prioritized features
- See
roadmap-planner for visual roadmap creation
- See
user-research-analyzer for validating impact assumptions
- See
stakeholder-communicator for explaining priority decisions
Version: 1.0.0
Last Updated: November 2025
Skill Type: Analytical (with Python)
Complexity: Intermediate
