feature-dev

Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review

Installation

npx claude-plugins install @anthropics/claude-plugins-official/feature-dev

Contents

Folders: agents, commands

Files: README.md

Documentation

A comprehensive, structured workflow for feature development with specialized agents for codebase exploration, architecture design, and quality review.

Overview

The Feature Development Plugin provides a systematic 7-phase approach to building new features. Instead of jumping straight into code, it guides you through understanding the codebase, asking clarifying questions, designing architecture, and ensuring quality—resulting in better-designed features that integrate seamlessly with your existing code.

Philosophy

Building features requires more than just writing code. You need to:

• Understand the codebase before making changes
• Ask questions to clarify ambiguous requirements
• Design thoughtfully before implementing
• Review for quality after building

This plugin embeds these practices into a structured workflow that runs automatically when you use the /feature-dev command.

Command: /feature-dev

Launches a guided feature development workflow with 7 distinct phases.

Usage:

/feature-dev Add user authentication with OAuth

Or simply:

/feature-dev

The command will guide you through the entire process interactively.

The 7-Phase Workflow

Phase 1: Discovery

Goal: Understand what needs to be built

What happens:

• Clarifies the feature request if it’s unclear
• Asks what problem you’re solving
• Identifies constraints and requirements
• Summarizes understanding and confirms with you

Example:

You: /feature-dev Add caching
Claude: Let me understand what you need...
        - What should be cached? (API responses, computed values, etc.)
        - What are your performance requirements?
        - Do you have a preferred caching solution?

Phase 2: Codebase Exploration

Goal: Understand relevant existing code and patterns

What happens:

• Launches 2-3 code-explorer agents in parallel
• Each agent explores different aspects (similar features, architecture, UI patterns)
• Agents return comprehensive analyses with key files to read
• Claude reads all identified files to build deep understanding
• Presents comprehensive summary of findings

Agents launched:

• “Find features similar to [feature] and trace implementation”
• “Map the architecture and abstractions for [area]”
• “Analyze current implementation of [related feature]”

Example output:

Found similar features:
- User authentication (src/auth/): Uses JWT tokens, middleware pattern
- Session management (src/session/): Redis-backed, 24hr expiry
- API security (src/api/middleware/): Rate limiting, CORS

Key files to understand:
- src/auth/AuthService.ts:45 - Core authentication logic
- src/middleware/authMiddleware.ts:12 - Request authentication
- src/config/security.ts:8 - Security configuration

Phase 3: Clarifying Questions

Goal: Fill in gaps and resolve all ambiguities

What happens:

• Reviews codebase findings and feature request
• Identifies underspecified aspects:
  • Edge cases
  • Error handling
  • Integration points
  • Backward compatibility
  • Performance needs
• Presents all questions in an organized list
• Waits for your answers before proceeding

Example:

Before designing the architecture, I need to clarify:

1. OAuth provider: Which OAuth providers? (Google, GitHub, custom?)
2. User data: Store OAuth tokens or just user profile?
3. Existing auth: Replace current auth or add alongside?
4. Sessions: Integrate with existing session management?
5. Error handling: How to handle OAuth failures?

Critical: This phase ensures nothing is ambiguous before design begins.

Phase 4: Architecture Design

Goal: Design multiple implementation approaches

What happens:

• Launches 2-3 code-architect agents with different focuses:
  • Minimal changes: Smallest change, maximum reuse
  • Clean architecture: Maintainability, elegant abstractions
  • Pragmatic balance: Speed + quality
• Reviews all approaches
• Forms opinion on which fits best for this task
• Presents comparison with trade-offs and recommendation
• Asks which approach you prefer

Example output:

I've designed 3 approaches:

Approach 1: Minimal Changes
- Extend existing AuthService with OAuth methods
- Add new OAuth routes to existing auth router
- Minimal refactoring required
Pros: Fast, low risk
Cons: Couples OAuth to existing auth, harder to test

Approach 2: Clean Architecture
- New OAuthService with dedicated interface
- Separate OAuth router and middleware
- Refactor AuthService to use common interface
Pros: Clean separation, testable, maintainable
Cons: More files, more refactoring

Approach 3: Pragmatic Balance
- New OAuthProvider abstraction
- Integrate into existing AuthService
- Minimal refactoring, good boundaries
Pros: Balanced complexity and cleanliness
Cons: Some coupling remains

Recommendation: Approach 3 - gives you clean boundaries without
excessive refactoring, and fits your existing architec



## Source

[View on GitHub](https://github.com/anthropics/claude-plugins-official)