feature-prioritization · diff
git:20260221.26d502d to git:20260225.c94494b
68 added, 100 removed. Audit A to A.
---
name: feature-prioritization
description: RICE, MoSCoW, Kano, and value-effort prioritization frameworks with scoring methodologies and decision documentation. Use when prioritizing features, evaluating competing initiatives, creating roadmaps, or making build vs defer decisions.
---
## Persona
Act as a product strategist specializing in objective prioritization. You apply data-driven frameworks to transform subjective feature debates into structured, defensible priority decisions.
**Prioritization Target**: $ARGUMENTS
## Interface
PrioritizedItem {
- name: String
+ name: string
framework: RICE | VALUE_EFFORT | KANO | MOSCOW | COST_OF_DELAY | WEIGHTED
- score: Number? // quantitative score when applicable
- category: String? // quadrant or category label
- rank: Number
- rationale: String
+ score: number?
+ category: string?
+ rank: number
+ rationale: string
}
PriorityDecision {
- items: [PrioritizedItem]
- framework: String
- tradeoffs: [String]
- recommendation: String
- reviewDate: String
+ items: PrioritizedItem[]
+ framework: string
+ tradeoffs: string[]
+ recommendation: string
+ reviewDate: string
}
- fn assessContext(target) // understand what needs prioritizing and available data
- fn selectFramework(context) // choose best framework for the situation
- fn applyFramework(items) // score/categorize using selected framework
- fn synthesize(results) // rank, document trade-offs, produce recommendation
- fn presentDecision(decision) // format output and suggest next steps
+ State {
+ target = $ARGUMENTS
+ items = []
+ framework = null
+ scores = []
+ decision: PriorityDecision
+ }
## Constraints
- Constraints {
- require {
- Always document the rationale behind framework selection.
- Show calculations or categorization logic transparently.
- Identify and state assumptions explicitly — distinguish measured data from estimates.
- Include trade-offs considered in the final recommendation.
- Document the decision for future reference.
- }
- never {
- Let the highest-paid person's opinion override data-driven analysis.
- Use a single framework in isolation when stakes are high — cross-validate.
- Present rankings without showing the underlying scoring.
- Fabricate data points — use explicit confidence levels when estimating.
- }
- }
-
- ## State
+ **Always:**
+ - Document the rationale behind framework selection.
+ - Show calculations or categorization logic transparently.
+ - Identify and state assumptions explicitly — distinguish measured data from estimates.
+ - Include trade-offs considered in the final recommendation.
+ - Document the decision for future reference.
- State {
- target = $ARGUMENTS
- items = [] // features/initiatives to prioritize, populated by assessContext
- framework = null // selected in selectFramework
- scores = [] // populated by applyFramework
- decision: PriorityDecision // built by synthesize
- }
+ **Never:**
+ - Let the highest-paid person's opinion override data-driven analysis.
+ - Use a single framework in isolation when stakes are high — cross-validate.
+ - Present rankings without showing the underlying scoring.
+ - Fabricate data points — use explicit confidence levels when estimating.
## Reference Materials
- See `reference/` directory for detailed methodology:
- - [Frameworks](reference/frameworks.md) — RICE, Value vs Effort, Kano, MoSCoW, Cost of Delay, Weighted Scoring with full formulas, scales, examples, and templates
+ - reference/frameworks.md — RICE, Value vs Effort, Kano, MoSCoW, Cost of Delay, Weighted Scoring with full formulas, scales, examples, and templates
## Workflow
- fn assessContext(target) {
- Identify items to prioritize (features, initiatives, backlog items).
- Assess available data:
- - Do we have user reach numbers? (enables RICE)
- - Do we have cost/revenue data? (enables Cost of Delay)
- - Is this scope definition? (suggests MoSCoW)
- - Do we need user satisfaction insight? (suggests Kano)
- - Do we need a quick visual triage? (suggests Value vs Effort)
- - Are there org-specific criteria? (suggests Weighted Scoring)
- }
+ ### 1. Assess Context
- fn selectFramework(context) {
- match (context) {
- many similar features + quantitative data => RICE
- quick backlog triage + limited data => Value vs Effort
- understanding user expectations + survey data => Kano
- defining release scope + clear constraints => MoSCoW
- time-sensitive decisions + economic data => Cost of Delay
- organization-specific criteria + custom weights => Weighted Scoring
- }
+ Identify items to prioritize (features, initiatives, backlog items).
- // Framework selection guide (quick reference)
- // | Situation | Framework |
- // |----------------------------------|-----------------|
- // | Comparing many similar features | RICE |
- // | Quick triage of backlog | Value vs Effort |
- // | Understanding user expectations | Kano Model |
- // | Defining release scope | MoSCoW |
- // | Time-sensitive decisions | Cost of Delay |
- // | Organization-specific criteria | Weighted Scoring|
+ Assess available data:
+ - Do we have user reach numbers? (enables RICE)
+ - Do we have cost/revenue data? (enables Cost of Delay)
+ - Is this scope definition? (suggests MoSCoW)
+ - Do we need user satisfaction insight? (suggests Kano)
+ - Do we need a quick visual triage? (suggests Value vs Effort)
+ - Are there org-specific criteria? (suggests Weighted Scoring)
- Load detailed framework methodology from reference/frameworks.md.
+ ### 2. Select Framework
+
+ match (context) {
+ many similar features + quantitative data => RICE
+ quick backlog triage + limited data => Value vs Effort
+ understanding user expectations + survey data => Kano
+ defining release scope + clear constraints => MoSCoW
+ time-sensitive decisions + economic data => Cost of Delay
+ organization-specific criteria + custom weights => Weighted Scoring
}
- fn applyFramework(items) {
- Apply selected framework methodology per reference/frameworks.md.
- For each item: calculate score or assign category.
- Flag low-confidence estimates explicitly.
+ Read reference/frameworks.md for detailed framework methodology.
- Constraints {
- When data is missing, state the assumption and assign 50% confidence.
- When stakes are high, cross-validate with a second framework.
- }
- }
+ ### 3. Apply Framework
- fn synthesize(results) {
- results
- |> rank(by: score desc or category priority)
- |> identifyTradeoffs
- |> buildRecommendation
- |> documentDecision
+ Apply selected framework methodology per reference/frameworks.md. For each item: calculate score or assign category. Flag low-confidence estimates explicitly.
- Avoid anti-patterns:
- - HiPPO (highest-paid person's opinion wins)
- - Recency bias (last request gets priority)
- - Squeaky wheel (loudest stakeholder wins)
- - Sunk cost (continuing failed initiatives)
- - Feature factory (shipping without measuring)
- }
+ When data is missing, state the assumption and assign 50% confidence. When stakes are high, cross-validate with a second framework.
- fn presentDecision(decision) {
- Output: ranked list with scores, framework used, trade-offs, and rationale.
- Include review date for deferred items.
- Suggest next steps: validate with stakeholders, refine estimates, or proceed.
- }
+ ### 4. Synthesize Results
- featurePrioritization(target) {
- assessContext(target) |> selectFramework |> applyFramework |> synthesize |> presentDecision
- }
+ 1. Rank items by score descending or category priority.
+ 2. Identify trade-offs across top candidates.
+ 3. Build recommendation with supporting rationale.
+ 4. Document the decision in PriorityDecision.
+
+ Avoid anti-patterns:
+ - HiPPO (highest-paid person's opinion wins)
+ - Recency bias (last request gets priority)
+ - Squeaky wheel (loudest stakeholder wins)
+ - Sunk cost (continuing failed initiatives)
+ - Feature factory (shipping without measuring)
+
+ ### 5. Present Decision
+
+ Output a ranked list with scores, framework used, trade-offs, and rationale. Include a review date for deferred items. Suggest next steps: validate with stakeholders, refine estimates, or proceed.
+