Feature Prioritization skill for Claude Code

#!/usr/bin/env python3
"""Score and rank backlog items with RICE or ICE, plus a rank-stability check.

Usage:
  python3 prioritize.py items.csv [--method rice|ice] [--top 5] [--noise 0.3]
                        [--runs 5000] [--seed 7]

RICE columns (header required): item,reach,impact,confidence,effort
  reach      : people/accounts affected per period (e.g. per quarter)
  impact     : 0.25 minimal, 0.5 low, 1 medium, 2 high, 3 massive
  confidence : 0-1 or 0-100 (percent); 0.5 = low, 0.8 = medium, 1.0 = high
  effort     : person-months (or any consistent unit) > 0
ICE columns: item,impact,confidence,ease   (each 1-10)

Prints the ranked table, warnings about suspicious inputs, and how often each
item lands in the top N when every input is jittered by +/- noise (uniform,
multiplicative). Items whose top-N share is between 20% and 80% are "unstable":
their rank depends on guesses, so validate those inputs before deciding.
Standard library only. Exits 1 on bad input.
"""
from __future__ import annotations

import argparse
import csv
import random
import sys

RICE_IMPACT = {0.25, 0.5, 1.0, 2.0, 3.0}


def fail(msg: str) -> None:
    print(f"error: {msg}", file=sys.stderr)
    sys.exit(1)


def load(path: str, method: str | None) -> tuple[str, list[dict], list[str]]:
    warnings: list[str] = []
    try:
        fh = open(path, newline="", encoding="utf-8-sig")
    except OSError as exc:
        fail(str(exc))
    with fh:
        reader = csv.DictReader(fh)
        cols = {c.strip().lower() for c in (reader.fieldnames or [])}
        if method is None:
            method = "rice" if "reach" in cols else "ice"
        need = {"rice": {"item", "reach", "impact", "confidence", "effort"},
                "ice": {"item", "impact", "confidence", "ease"}}[method]
        if not need <= cols:
            fail(f"{method.upper()} needs columns {sorted(need)}; got {sorted(cols)}")
        rows = []
        for line, raw in enumerate(reader, start=2):
            row = {k.strip().lower(): (v or "").strip() for k, v in raw.items() if k}
            if not row.get("item"):
                continue
            try:
                vals = {k: float(row[k]) for k in need - {"item"}}
            except ValueError:
                fail(f"line {line} ({row['item']}): non-numeric value")
            name = row["item"]
            if method == "rice":
                if vals["confidence"] > 1:
                    vals["confidence"] /= 100.0
                if not 0 < vals["confidence"] <= 1:
                    fail(f"line {line} ({name}): confidence must be in (0, 1] or (0, 100]")
                if vals["effort"] <= 0:
                    fail(f"line {line} ({name}): effort must be > 0")
                if vals["reach"] < 0:
                    fail(f"line {line} ({name}): reach must be >= 0")
                if vals["impact"] not in RICE_IMPACT:
                    warnings.append(f"{name}: impact {vals['impact']:g} is off the 0.25/0.5/1/2/3 scale")
                if vals["effort"] < 0.25:
                    warnings.append(f"{name}: effort {vals['effort']:g} is tiny; tiny denominators inflate scores")
            else:
                for k in ("impact", "confidence", "ease"):
                    if not 1 <= vals[k] <= 10:
                        fail(f"line {line} ({name}): {k} must be 1-10")
            rows.append({"item": name, **vals})
    if not rows:
        fail("no items found")
    if method == "rice":
        high = sum(1 for r in rows if r["confidence"] >= 1.0)
        if len(rows) >= 4 and high / len(rows) > 0.5:
            warnings.append(f"{high}/{len(rows)} items claim 100% confidence; that is rarely honest")
        big = sum(1 for r in rows if r["impact"] >= 2)
        if len(rows) >= 4 and big / len(rows) > 0.5:
            warnings.append(f"{big}/{len(rows)} items rated high or massive impact; recalibrate against a reference item")
    return method, rows, warnings


def score(method: str, r: dict) -> float:
    if method == "rice":
        return r["reach"] * r["impact"] * r["confidence"] / r["effort"]
    return r["impact"] * r["confidence"] * r["ease"]


def stability(method: str, rows: list[dict], top: int, noise: float, runs: int, seed: int) -> dict[str, float]:
    rng = random.Random(seed)
    keys = [k for k in rows[0] if k != "item"]
    hits = {r["item"]: 0 for r in rows}
    for _ in range(runs):
        scored = []
        for r in rows:
            j = {k: r[k] * rng.uniform(1 - noise, 1 + noise) for k in keys}
            scored.append((score(method, j), r["item"]))
        scored.sort(reverse=True)
        for _, name in scored[:top]:
            hits[name] += 1
    return {k: v / runs for k, v in hits.items()}


def main() -> None:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("csv")
    ap.add_argument("--method", choices=["rice", "ice"])
    ap.add_argument("--top", type=int, default=5, help="size of the 'make the cut' set (default 5)")
    ap.add_argument("--noise", type=float, default=0.3, help="+/- fractional jitter per input (default 0.3)")
    ap.add_argument("--runs", type=int, default=5000)
    ap.add_argument("--seed", type=int, default=7)
    a = ap.parse_args()
    if not 0 <= a.noise < 1:
        fail("--noise must be in [0, 1)")

    method, rows, warnings = load(a.csv, a.method)
    top = max(1, min(a.top, len(rows)))
    for r in rows:
        r["score"] = score(method, r)
    rows.sort(key=lambda r: r["score"], reverse=True)
    share = stability(method, rows, top, a.noise, a.runs, a.seed)

    width = max(len(r["item"]) for r in rows)
    if method == "rice":
        print(f"{'#':>2}  {'item':<{width}}  {'reach':>8} {'impact':>6} {'conf':>5} {'effort':>6}  {'RICE':>9}  top{top}")
    else:
        print(f"{'#':>2}  {'item':<{width}}  {'impact':>6} {'conf':>5} {'ease':>5}  {'ICE':>6}  top{top}")
    for i, r in enumerate(rows, 1):
        s = share[r["item"]]
        flag = "  unstable" if 0.2 <= s <= 0.8 else ""
        if method == "rice":
            print(f"{i:>2}  {r['item']:<{width}}  {r['reach']:>8g} {r['impact']:>6g} {r['confidence']:>5.0%} "
                  f"{r['effort']:>6g}  {r['score']:>9,.0f}  {s:>4.0%}{flag}")
        else:
            print(f"{i:>2}  {r['item']:<{width}}  {r['impact']:>6g} {r['confidence']:>5g} {r['ease']:>5g}  "
                  f"{r['score']:>6.0f}  {s:>4.0%}{flag}")
    unstable = [r["item"] for r in rows if 0.2 <= share[r["item"]] <= 0.8]
    print(f"\nStability: inputs jittered +/-{a.noise:.0%} over {a.runs} runs; 'top{top}' = share of runs in the top {top}.")
    if unstable:
        print("Unstable near the cut line (validate their inputs first): " + ", ".join(unstable))
    else:
        print("Ranking around the cut line is stable at this noise level.")
    for w in warnings:
        print(f"warning: {w}")


if __name__ == "__main__":
    main()