skills-library/skills/lean/prioritization.md

# Skill: Lean - Prioritization

## Description
Apply lean prioritization frameworks to make decisions about what to build next. Uses WSJF, MoSCoW, and effort/impact matrices.

## Input
- **items**: List of items to prioritize (required)
- **framework**: wsjf|moscow|effort_impact|rice (optional, default: wsjf)
- **constraints**: Time, budget, capacity limits (optional)
- **weights**: Custom weights for scoring factors (optional)

## Prioritization Frameworks

### 1. WSJF (Weighted Shortest Job First)
**Best for:** Sprint planning, feature prioritization

```
Priority = (User Value + Time Criticality + Risk Reduction) / Job Size

Higher score = Do first
```

**Scoring Matrix:**
| Factor | 1-3 | 4-6 | 7-9 | 10 |
|--------|-----|-----|-----|-----|
| User Value | Few users | Some users | Most users | All users |
| Time Criticality | No deadline | Quarter | Month | This sprint |
| Risk Reduction | Minor | Moderate | Significant | Critical |
| Job Size (effort) | < 2 hours | 1-2 days | 3-5 days | > 1 week |

**Example:**
```json
{
  "item": "Add password reset",
  "user_value": 8,
  "time_criticality": 7,
  "risk_reduction": 6,
  "job_size": 5,
  "wsjf_score": 4.2
}
// Score = (8 + 7 + 6) / 5 = 4.2
```

### 2. MoSCoW Method
**Best for:** Release planning, MVP definition

| Category | Description | Guidance |
|----------|-------------|----------|
| **M**ust Have | Non-negotiable, core functionality | Release blocked without |
| **S**hould Have | Important but not critical | Include if time permits |
| **C**ould Have | Nice to have | Descope first if needed |
| **W**on't Have | Out of scope for this release | Document for future |

**Distribution Rule:**
- Must: 60% of effort
- Should: 20% of effort
- Could: 20% of effort
- Won't: 0% (explicitly excluded)

### 3. Effort/Impact Matrix
**Best for:** Quick prioritization, team discussions

```
            High Impact
                 │
    Quick Wins   │   Major Projects
    (Do Now)     │   (Plan Carefully)
─────────────────┼─────────────────────
    Fill-Ins     │   Thankless Tasks
    (If Time)    │   (Avoid/Delegate)
                 │
            Low Impact

Low Effort ─────────────── High Effort
```

**Quadrant Actions:**
1. **Quick Wins** (High Impact, Low Effort): Do immediately
2. **Major Projects** (High Impact, High Effort): Schedule, break down
3. **Fill-Ins** (Low Impact, Low Effort): Do when free
4. **Thankless Tasks** (Low Impact, High Effort): Eliminate or defer

### 4. RICE Framework
**Best for:** Product decisions with reach data

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

Reach: Users affected per quarter
Impact: 0.25 (minimal) to 3 (massive)
Confidence: 0-100%
Effort: Person-months
```

## Scheduling & Parallelization

### Dependency Resolution
```json
{
  "item_id": "BLI-050",
  "depends_on": ["BLI-048", "BLI-049"],
  "blocks": ["BLI-053", "BLI-054"],
  "parallel_with": ["BLI-051", "BLI-052"],
  "scheduling": {
    "earliest_start": "After BLI-048 & BLI-049 complete",
    "can_parallelize": true,
    "parallelization_candidates": ["BLI-051", "BLI-052"]
  }
}
```

### Parallelization Rules
```javascript
function canParallelize(itemA, itemB) {
  // No shared dependencies
  const sharedDeps = itemA.depends_on.filter(d =>
    itemB.depends_on.includes(d)
  );
  if (sharedDeps.length > 0) return false;

  // Different agents
  if (itemA.assigned_agent === itemB.assigned_agent) return false;

  // No blocking relationship
  if (itemA.blocks.includes(itemB.id)) return false;
  if (itemB.blocks.includes(itemA.id)) return false;

  return true;
}
```

### Optimal Schedule Generation
```json
{
  "schedule": {
    "week_1": {
      "parallel_tracks": [
        { "agent": "frontend", "items": ["BLI-050", "BLI-051"] },
        { "agent": "backend", "items": ["BLI-048", "BLI-049"] }
      ],
      "capacity_used": "85%"
    },
    "week_2": {
      "parallel_tracks": [
        { "agent": "frontend", "items": ["BLI-053"] },
        { "agent": "backend", "items": ["BLI-052"] },
        { "agent": "tester", "items": ["BLI-050-test", "BLI-051-test"] }
      ],
      "capacity_used": "90%"
    }
  },
  "critical_path": ["BLI-048", "BLI-050", "BLI-053"],
  "total_duration": "2 weeks",
  "parallelization_savings": "40%"
}
```

## Output Format
```json
{
  "status": "success",
  "framework": "wsjf",
  "prioritized_items": [
    {
      "rank": 1,
      "id": "BLI-043",
      "title": "User authentication",
      "score": 7.33,
      "category": "must_have",
      "quadrant": "quick_win"
    },
    {
      "rank": 2,
      "id": "BLI-050",
      "title": "Password reset",
      "score": 5.67,
      "category": "must_have",
      "quadrant": "major_project"
    }
  ],
  "schedule": {
    "sprint_1": ["BLI-043", "BLI-045"],
    "sprint_2": ["BLI-050", "BLI-047"],
    "backlog": ["BLI-055", "BLI-060"]
  },
  "parallelization": {
    "recommended_groups": [
      ["BLI-043", "BLI-044"],
      ["BLI-050", "BLI-051"]
    ],
    "time_savings": "35%"
  },
  "recommendations": [
    "BLI-050 has effort 9 - consider splitting",
    "BLI-043 and BLI-044 can run in parallel",
    "Remove BLI-060 - low impact, high effort"
  ],
  "next_step": "Commit to sprint with /sprint plan"
}
```

## Decision Matrix Template
```
┌─────────────────────────────────────────────────────────────────┐
│ PRIORITIZATION DECISION                                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Items Evaluated: 25                                            │
│  Framework: WSJF + Effort/Impact                                │
│                                                                 │
│  ┌───────────────────────────────────────────────────────┐     │
│  │ MUST DO (Score > 6)        │ SHOULD DO (Score 4-6)   │     │
│  │ • User auth (7.33)         │ • Dark mode (5.20)      │     │
│  │ • Password reset (6.67)    │ • Notifications (4.80)  │     │
│  │ • Profile page (6.40)      │ • Search (4.50)         │     │
│  ├───────────────────────────────────────────────────────┤     │
│  │ COULD DO (Score 2-4)       │ WON'T DO (Score < 2)    │     │
│  │ • Export CSV (3.50)        │ • Social login (1.80)   │     │
│  │ • Keyboard shortcuts (2.90)│ • Mobile app (1.20)     │     │
│  └───────────────────────────────────────────────────────┘     │
│                                                                 │
│  Recommended: Focus on MUST DO items for next 2 sprints        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘
```

## Quality Gates
- [ ] All items have consistent scoring
- [ ] Dependencies documented
- [ ] Parallelization opportunities identified
- [ ] Schedule accounts for capacity
- [ ] Clear decision rationale
- [ ] Stakeholder alignment

## Token Budget
- Max input: 1000 tokens
- Max output: 1500 tokens

## Model
- Recommended: sonnet (decision reasoning)

## Philosophy
> "If everything is important, nothing is."

**Keep it simple:**
- Prioritize ruthlessly
- Say no to low-impact work
- Parallelize aggressively
- Ship the most valuable thing first