feature-review

Table of Contents

• [Philosophy](#philosophy)
• [When to Use](#when-to-use)
• [When NOT to Use](#when-not-to-use)
• [Quick Start](#quick-start)
• [1. Inventory Current Features](#1-inventory-current-features)
• [2. Score and Classify](#2-score-and-classify)
• [3. Generate Suggestions](#3-generate-suggestions)

Verification

Run make test-feature-review to verify scoring logic after changes.

• [4. Upload to GitHub](#4-upload-to-github)
• [Workflow](#workflow)
• [Phase 1: Feature Discovery (feature-review:inventory-complete)](#phase-1:-feature-discovery-(feature-review:inventory-complete))
• [Phase 2: Classification (feature-review:classified)](#phase-2:-classification-(feature-review:classified))
• [Phase 3: Scoring (feature-review:scored)](#phase-3:-scoring-(feature-review:scored))
• [Phase 4: Tradeoff Analysis (feature-review:tradeoffs-analyzed)](#phase-4:-tradeoff-analysis-(feature-review:tradeoffs-analyzed))
• [Phase 5: Gap Analysis & Suggestions (feature-review:suggestions-generated)](#phase-5:-gap-analysis-&-suggestions-(feature-review:suggestions-generated))
• [Phase 6: GitHub Integration (feature-review:issues-created)](#phase-6:-github-integration-(feature-review:issues-created))
• [Configuration](#configuration)
• [Configuration File](#configuration-file)
• [Guardrails](#guardrails)
• [Required TodoWrite Items](#required-todowrite-items)
• [Integration Points](#integration-points)
• [Output Format](#output-format)
• [Feature Inventory Table](#feature-inventory-table)
• [Suggestion Report](#suggestion-report)
• [Feature Suggestions](#feature-suggestions)
• [High Priority (Score > 2.5)](#high-priority-(score->-25))
• [Related Skills](#related-skills)
• [Reference](#reference)

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. Research-Enriched Scoring

Use tome plugin to adjust scores with external evidence:

/feature-review --research

5. 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](modules/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](modules/scoring-framework.md) for the framework. See [multi-metric-evaluation-methodology.md](modules/multi-metric-evaluation-methodology.md) when one model is not enough: it covers how to combine RICE, WSJF, and Kano, where each model fits, and how to reconcile conflicting signals.

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](modules/tradeoff-dimensions.md) for criteria.

Phase 4.5: Research Enrichment (feature-review:research-enriched)

Triggered by: --research flag. Requires tome plugin.

Use tome's multi-source research to adjust scoring factors with external evidence. This phase runs between tradeoff analysis and gap analysis.

1. Dispatch research: For each feature, construct

research topics and dispatch tome channels (code-search, discourse, papers, triz) in parallel.

1. Synthesize findings: Merge results across channels

using tome:synthesize.

1. Calculate deltas: Map findings to scoring factor

adjustments using channel-to-factor mapping.

1. Apply deltas: Adjust initial scores by research

deltas, clamp to Fibonacci scale, respect max_delta.

1. Present evidence: Show adjustment table with

evidence sources and rationale.

See [research-enrichment.md](modules/research-enrichment.md) for the full enrichment protocol, delta calculation, and graceful degradation behavior.

Graceful degradation: If tome is not installed, prints a warning and proceeds with initial scores unchanged.

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.

Deferred capture for high-scoring suggestions: After the user confirms which suggestions to act on, any high-scoring suggestion (score > 2.5) that is not acted on should be preserved as a deferred item. Run once per skipped high-scoring suggestion:

python3 scripts/deferred_capture.py \
  --title "<suggestion title>" \
  --source feature-review \
  --context "RICE score: <score>. <description>"

This runs automatically without prompting the user. Suggestions with scores of 2.5 or below do not need to be captured.

Configuration

Feature-review uses opinionated defaults but allows customization.

Configuration File

Create .feature-review.yaml in project root:

# .feature-review.yaml
version: 1.9.3

# Scoring weights (must sum to 1.0)
weights:
  valu