feature-review

athola's avatarfrom athola

Feature review and prioritization with RICE/WSJF/Kano scoring. Creates GitHub issues for suggestions.Triggers: feature review, prioritization, RICE, WSJF, roadmap, backlogUse when: reviewing features or suggesting new featuresDO NOT use when: evaluating single feature scope - use scope-guard.

⭐83stars🔀11forks📁View on GitHub🕐Updated Jan 3, 2026

When & Why to Use This Skill

The Feature Review skill is a comprehensive product management tool designed to automate the evaluation and prioritization of software features. By utilizing industry-standard frameworks such as RICE, WSJF, and Kano scoring, it helps development teams move from subjective guessing to evidence-based decision-making. It analyzes existing codebases and documentation to identify gaps, evaluate tradeoffs, and seamlessly bridge the gap between strategic planning and execution by creating actionable GitHub issues.

Use Cases

  • Strategic Roadmap Planning: Use during sprint or quarterly planning sessions to objectively rank potential features based on reach, impact, and business value against implementation effort.
  • Backlog Grooming & Optimization: Periodically audit the project backlog to identify low-priority 'bloat' or high-value opportunities that align with user needs.
  • Technical Debt & Quality Assessment: Evaluate current features against performance dimensions like latency, scalability, and resource usage to prioritize refactoring tasks.
  • Automated Issue Management: Streamline the transition from brainstorming to development by automatically generating detailed GitHub issues for approved feature suggestions.
namefeature-review
description|
Triggersfeature review, prioritization, RICE, WSJF, roadmap, backlog
Use whenreviewing features or suggesting new features
DO NOT use whenevaluating single feature scope - use scope-guard.
categoryworkflow-methodology
tags[feature-review, prioritization, RICE, WSJF, Kano, roadmap, backlog]
- imbuereview-core
complexityintermediate
estimated_tokens3500

Table of Contents

Feature Review

Review implemented features and suggest new ones using evidence-based prioritization. Create GitHub issues for accepted suggestions.

Philosophy

Feature decisions rely on data. Every feature involves tradeoffs that require evaluation. This skill uses hybrid RICE+WSJF scoring with Kano classification to prioritize work and generates actionable GitHub issues for accepted suggestions.

When to Use

  • Roadmap reviews (sprint planning, quarterly reviews).
  • Retrospective evaluations.
  • Planning new development cycles.

When NOT to Use

  • Emergency bug fixes.
  • Simple documentation updates.
  • Active implementation (use scope-guard).

Quick Start

1. Inventory Current Features

Discover and categorize existing features:

/feature-review --inventory

2. Score and Classify

Evaluate features against the prioritization framework:

/feature-review

3. Generate Suggestions

Review gaps and suggest new features:

/feature-review --suggest

4. Upload to GitHub

Create issues for accepted suggestions:

/feature-review --suggest --create-issues

Workflow

Phase 1: Feature Discovery (feature-review:inventory-complete)

Identify features by analyzing:

  1. Code artifacts: Entry points, public APIs, and configuration surfaces.
  2. Documentation: README lists, CHANGELOG entries, and user docs.
  3. Git history: Recent feature commits and branches.

Output: Feature inventory table.

Phase 2: Classification (feature-review:classified)

Classify each feature along two axes:

Axis 1: Proactive vs Reactive

Type Definition Examples
Proactive Anticipates user needs. Suggestions, prefetching.
Reactive Responds to explicit input. Form handling, click actions.

Axis 2: Static vs Dynamic

Type Update Pattern Storage Model
Static Incremental, versioned. File-based, cached.
Dynamic Continuous, streaming. Database, real-time.

See classification-system.md for details.

Phase 3: Scoring (feature-review:scored)

Apply hybrid RICE+WSJF scoring:

Feature Score = Value Score / Cost Score

Value Score = (Reach + Impact + Business Value + Time Criticality) / 4
Cost Score = (Effort + Risk + Complexity) / 3

Adjusted Score = Feature Score * Confidence

Scoring Scale: Fibonacci (1, 2, 3, 5, 8, 13).

Thresholds:

  • > 2.5: High priority.
  • 1.5 - 2.5: Medium priority.
  • < 1.5: Low priority.

See scoring-framework.md for the framework.

Phase 4: Tradeoff Analysis (feature-review:tradeoffs-analyzed)

Evaluate each feature across quality dimensions:

Dimension Question Scale
Quality Does it deliver correct results? 1-5
Latency Does it meet timing requirements? 1-5
Token Usage Is it context-efficient? 1-5
Resource Usage Is CPU/memory reasonable? 1-5
Redundancy Does it handle failures gracefully? 1-5
Readability Can others understand it? 1-5
Scalability Will it handle 10x load? 1-5
Integration Does it play well with others? 1-5
API Surface Is it backward compatible? 1-5

See tradeoff-dimensions.md for criteria.

Phase 5: Gap Analysis & Suggestions (feature-review:suggestions-generated)

  1. Identify gaps: Missing Kano basics.
  2. Surface opportunities: High-value, low-effort features.
  3. Flag technical debt: Features with declining scores.
  4. Recommend actions: Build, improve, deprecate, or maintain.

Phase 6: GitHub Integration (feature-review:issues-created)

  1. Generate issue title and body from suggestions.
  2. Apply labels (feature, enhancement, priority/*).
  3. Link to related issues.
  4. Confirm with user before creation.

Configuration

Feature-review uses opinionated defaults but allows customization.

Configuration File

Create .feature-review.yaml in project root:

# .feature-review.yaml
version: 1

# Scoring weights (must sum to 1.0)
weights:
  value:
    reach: 0.25
    impact: 0.30
    business_value: 0.25
    time_criticality: 0.20
  cost:
    effort: 0.40
    risk: 0.30
    complexity: 0.30

# Score thresholds
thresholds:
  high_priority: 2.5
  medium_priority: 1.5

# Tradeoff dimension weights (0.0 to disable)
tradeoffs:
  quality: 1.0
  latency: 1.0
  token_usage: 1.0
  resource_usage: 0.8
  redundancy: 0.5
  readability: 1.0
  scalability: 0.8
  integration: 1.0
  api_surface: 1.0

See configuration.md for options.

Guardrails

These rules apply to all configurations:

  1. Minimum dimensions: Evaluate at least 5 tradeoff dimensions.
  2. Confidence requirement: Review scores below 50% confidence.
  3. Breaking change warning: Require acknowledgment for API surface changes.
  4. Backlog limit: Limit suggestion queue to 25 items.

Required TodoWrite Items

  1. feature-review:inventory-complete
  2. feature-review:classified
  3. feature-review:scored
  4. feature-review:tradeoffs-analyzed
  5. feature-review:suggestions-generated
  6. feature-review:issues-created (if requested)

Integration Points

  • imbue:scope-guard: Provides Worthiness Scores for suggestions.
  • sanctum:do-issue: Prioritizes issues with high scores.
  • superpowers:brainstorming: Evaluates new ideas against existing features.

Output Format

Feature Inventory Table

| Feature | Type | Data | Score | Priority | Status |
|---------|------|------|-------|----------|--------|
| Auth middleware | Reactive | Dynamic | 2.8 | High | Stable |
| Skill loader | Reactive | Static | 2.3 | Medium | Needs improvement |

Suggestion Report

## Feature Suggestions

### High Priority (Score > 2.5)

1. **[Feature Name]** (Score: 2.7)
   - Classification: Proactive/Dynamic
   - Value: High reach
   - Cost: Moderate effort
   - Recommendation: Build in next sprint
  • imbue:scope-guard: Prevent overengineering.
  • imbue:review-core: Structured review methodology.
  • sanctum:pr-review: Code-level feature review.

Reference

Troubleshooting

Common Issues

Command not found Ensure all dependencies are installed and in PATH

Permission errors Check file permissions and run with appropriate privileges

Unexpected behavior Enable verbose logging with --verbose flag