prioritization-calculator

Prioritization Calculator Skill

Calculate and validate scores for multiple prioritization frameworks with weighted scoring, normalization, and confidence-adjusted rankings.

Overview

This skill provides robust calculation engines for popular prioritization frameworks used in product management. It handles score normalization, validation, custom weighting, and generates actionable priority rankings.

Capabilities

RICE Scoring

• Calculate Reach, Impact, Confidence, Effort scores
• Normalize across different scale systems
• Apply team capacity adjustments
• Generate confidence-adjusted rankings

ICE Scoring

• Impact, Confidence, Ease calculations
• Comparative scoring across features
• Quick prioritization for growth experiments
• Sensitivity analysis

MoSCoW Categorization

• Must-have, Should-have, Could-have, Won't-have classification
• Constraint-based categorization rules
• Dependency-aware sorting
• Release planning integration

Weighted Scoring

• Custom prioritization frameworks
• Multiple criteria weighting
• Stakeholder preference integration
• Dynamic weight adjustment

Score Analysis

• Normalize scores across data sources
• Generate priority rankings with intervals
• Identify score clustering and outliers
• Track prioritization changes over time

Prerequisites

Input Data Format

{
  "items": [
    {
      "id": "FEAT-001",
      "name": "Feature name",
      "scores": {
        "reach": 5000,
        "impact": 2,
        "confidence": 0.8,
        "effort": 3
      },
      "metadata": {
        "theme": "growth",
        "requestedBy": "sales"
      }
    }
  ],
  "config": {
    "framework": "rice",
    "effortUnit": "person_weeks",
    "teamCapacity": 20
  }
}

Usage Patterns

RICE Score Calculation

## RICE Formula

RICE Score = (Reach * Impact * Confidence) / Effort

### Scale Definitions

**Reach**: Number of users/customers affected per quarter
- Estimate conservatively
- Use data when available

**Impact**: Expected effect on users
| Score | Meaning |
|-------|---------|
| 3 | Massive impact |
| 2 | High impact |
| 1 | Medium impact |
| 0.5 | Low impact |
| 0.25 | Minimal impact |

**Confidence**: How certain are we?
| Score | Meaning |
|-------|---------|
| 1.0 | High confidence - solid data |
| 0.8 | Medium confidence - some data |
| 0.5 | Low confidence - educated guess |

**Effort**: Person-months or person-weeks
- Include all work: design, dev, QA, launch
- Round up for unknowns

RICE Calculation Example

# RICE Score Calculator

def calculate_rice(reach, impact, confidence, effort):
    """
    Calculate RICE score for prioritization.

    Args:
        reach: Users affected per quarter
        impact: Impact score (0.25, 0.5, 1, 2, or 3)
        confidence: Confidence level (0.5, 0.8, or 1.0)
        effort: Person-weeks of effort

    Returns:
        RICE score
    """
    if effort <= 0:
        raise ValueError("Effort must be positive")

    rice_score = (reach * impact * confidence) / effort
    return rice_score

# Example features
features = [
    {"name": "Search improvements", "reach": 10000, "impact": 2, "confidence": 0.8, "effort": 4},
    {"name": "Export to PDF", "reach": 2000, "impact": 1, "confidence": 1.0, "effort": 2},
    {"name": "AI suggestions", "reach": 5000, "impact": 3, "confidence": 0.5, "effort": 8},
]

# Calculate and rank
for feature in features:
    feature["rice_score"] = calculate_rice(
        feature["reach"],
        feature["impact"],
        feature["confidence"],
        feature["effort"]
    )

ranked = sorted(features, key=lambda x: x["rice_score"], reverse=True)

ICE Score Calculation

## ICE Formula

ICE Score = Impact * Confidence * Ease

### Scale Definitions (1-10 for each)

**Impact**: How much will this move the metric?
- 10: Massive improvement
- 5: Moderate improvement
- 1: Minimal improvement

**Confidence**: How sure are we it will work?
- 10: Very confident (tested/proven)
- 5: Somewhat confident (similar worked)
- 1: Pure hypothesis

**Ease**: How easy to implement?
- 10: Trivial (hours)
- 5: Moderate (days)
- 1: Complex (weeks+)

ICE Calculation Example

def calculate_ice(impact, confidence, ease):
    """
    Calculate ICE score for growth prioritization.

    Args:
        impact: 1-10 impact on target metric
        confidence: 1-10 confidence level
        ease: 1-10 ease of implementation

    Returns:
        ICE score (1-1000)
    """
    return impact * confidence * ease

# Example experiments
experiments = [
    {"name": "New CTA color", "impact": 3, "confidence": 5, "ease": 10},
    {"name": "Simplified checkout", "impact": 8, "confidence": 7, "ease": 4},
    {"name": "Social proof", "impact": 5, "confidence": 8, "ease": 7},
]

for exp in experiments:
    exp["ice_score"] = calculate_ice(exp["impact"], exp["confidence"], exp["ease"])

ranked = sorted(experiments, key=lambda x: x["ice_score"], reverse=True)

MoSCoW Classification

## MoSCoW Framework

### Must Have (M)
- Non-negotiable for launch
- Failure without it is unacceptable
- Core to the value proposition

### Should Have (S)
- Important but not critical
- Workarounds exist
- Next priority after Must

### Could Have (C)
- Nice to have
- Would enhance but not required
- Do if time permits

### Won't Have (W)
- Explicitly out of scope
- Deferred to future
- Agreed not to do now

## Classification Rules

def classify_moscow(item, constraints): """ Classify item into MoSCoW category.

Args: item: Feature/requirement constraints: Release constraints

Returns: MoSCoW category """ # Must Have criteria if item.is_regulatory or item.blocks_launch: return "M"

# Should Have criteria if item.impact_score >= 0.7 and item.fits_budget: return "S"

# Could Have criteria if item.impact_score >= 0.4: return "C"

# Won't Have return "W"

Weighted Scoring Framework

## Custom Weighted Scoring

### Define Criteria
| Criterion | Weight | Scale |
|-----------|--------|-------|
| Strategic Alignment | 25% | 1-5 |
| Revenue Impact | 20% | 1-5 |
| Customer Demand | 20% | 1-5 |
| Technical Feasibility | 15% | 1-5 |
| Competitive Pressure | 10% | 1-5 |
| Risk Level (inverse) | 10% | 1-5 |

### Calculation

def weighted_score(item, criteria_weights): """ Calculate weighted prioritization score.

Args: item: Dict with scores for each criterion criteria_weights: Dict with weights (must sum to 1.0)

Returns: Weighted score """ total = 0 for criterion, weight in criteria_weights.items(): score = item.get(criterion, 0) total += score * weight return total

Integration with Babysitter SDK

Task Definition Example

const prioritizationTask = defineTask({
  name: 'feature-prioritization',
  description: 'Calculate prioritization scores for features',

  inputs: {
    features: { type: 'array', required: true },
    framework: { type: 'string', default: 'rice' },
    customWeights: { type: 'object', default: null },
    teamCapacity: { type: 'number', default: null }
  },

  outputs: {
    rankedFeatures: { type: 'array' },
    scoreDistribution: { type: 'object' },
    recommendations: { type: 'array' }
  },

  async run(inputs, taskCtx) {
    return {
      kind: 'skill',
      title: `Calculate ${inputs.framework.toUpperCase()} scores`,
      skill: {
        name: 'prioritization-calculator',
        context: {
          operation: 'calculate_scores',
          features: inputs.features,
          framework: inputs.framework,
          customWeights: inputs.customWeights,
          teamCapacity: inputs.teamCapacity
        }
      },
      io: {
        inputJsonPath: `tasks/${taskCtx.effectId}/input.json`,
        outputJsonPath: `tasks/${taskCtx.effectId}/result