feature-dev-harnessed

feature-dev-harnessed

Feature development with multi-session execution for large features.

A fork of Anthropic's feature-dev plugin that integrates their harness pattern for long-running agents.

The Problem

Anthropic's feature-dev plugin provides a thorough 7-phase workflow for feature development. This works well for features that fit in one context window. For larger features, the exploration and architecture phases (1-4) consume significant context, leaving insufficient room for implementation.

The Solution

This fork keeps phases 1-4 (planning) and 6-7 (review) exactly as Anthropic designed them. It replaces phase 5 (implementation) with a multi-session harness pattern:

• Session 1: Planning - Run phases 1-4, create feature_list.json with work items
• Sessions 2-N: Implementation - Execute one item per session with verification
• Final Session: Review - Run phases 6-7, complete the feature

One command that detects state and does the right thing across multiple sessions.

When to Use This Plugin

Use feature-dev-harnessed for:

• Large features that require 3+ implementation sessions
• Complex features where thorough exploration consumes significant context
• Multi-day features where you'll return across multiple sessions
• Features with many components that benefit from incremental verification

Use regular feature-dev for:

• Features completable in a single session
• Small to medium features with straightforward implementation
• Quick iterations where multi-session overhead isn't worth it

Don't use either for:

• Single-line bug fixes
• Trivial changes
• Urgent hotfixes

Workflow

Planning Session (Phases 1-4)

Phase 1: Discovery

Goal: Understand what needs to be built

You: /feature-dev-harnessed:feature-dev Add CSV export for cost reports
Claude: Let me understand what you need...
        - What data should be included in the CSV?
        - Should users be able to select which columns to export?
        - Any specific formatting requirements?

Phase 2: Codebase Exploration

Goal: Understand relevant existing code and patterns

Launches 2-3 code-explorer agents in parallel to trace through:

• Similar features and their implementation patterns
• Architecture and abstractions in the relevant area
• UI patterns and extension points

Found similar features:
- PDF export (src/export/pdf.py): Uses ReportFormatter base class
- Data filtering (src/reports/filters.py): Column selection pattern

Key files to understand:
- src/export/base.py:23 - ReportFormatter interface
- src/reports/cost_report.py:45 - Cost report data structure
- src/ui/export_button.py:12 - Export button component

Phase 3: Clarifying Questions

Goal: Fill in gaps and resolve ambiguities before designing

Before designing the architecture, I need to clarify:

1. Column selection: Include all columns or let user choose?
2. Formatting: How should currency values be formatted?
3. File naming: Auto-generate filename or prompt user?
4. Large reports: Any pagination or size limits?

Phase 4: Architecture Design

Goal: Design multiple approaches with trade-offs

Launches 2-3 code-architect agents with different focuses:

I've designed 3 approaches:

Approach 1: Minimal Changes
- Add csv_export() method to existing CostReport class
- Reuse PDF export button with format parameter
Pros: Fast, minimal code
Cons: Couples CSV logic to report class

Approach 2: Clean Architecture
- New CsvFormatter implementing ReportFormatter
- Dedicated export service with format registry
Pros: Extensible, testable, follows existing patterns
Cons: More files, more abstraction

Approach 3: Pragmatic Balance
- New CsvFormatter class
- Wire into existing export button component
Pros: Clean separation, minimal refactoring
Cons: Some duplication with PDF formatter

Recommendation: Approach 3 - follows existing patterns without over-engineering.

Which approach would you like to use?

After user approves, creates feature_list.json with session-sized work items.

Implementation Sessions (Phase 5, multi-session)

Each session:

1. Run smoke tests on previously completed items
2. Implement the next pending item
3. Run verification command until it passes
4. Update artifacts and commit

Session 3: Implementation

Smoke tests: 001 PASS, 002 PASS
Working on: 003 - Wire export button to CSV formatter
Verification: python3 -m pytest tests/test_csv_export.py -v

[Implementation happens here]

Verification PASSED
Ready to commit? Proceed?

Review Session (Phases 6-7)

Phase 6: Quality Review

Launches 3 code-reviewer agents to check:

• Simplicity, DRY, elegance
• Bugs and functional correctness
• Project conventions and abstractions

Code Review Results: