Skip to main content
skill CX Codex

feature-dev · secondsky — Claude Code skill: what it does, how to install

The feature-dev skill guides feature work through seven phases, from codebase discovery to review. Use it for multi-file changes and unclear architecture decisions.

MIT 294 installs ★ 250 updated 2026-10-20

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add secondsky/claude-skills --skill feature-dev -a claude-code
Open on GitHub

What feature-dev does

The skill runs a seven-phase feature workflow. It first clarifies the request and examines the existing code, then prepares several architecture approaches for comparison. Three specialized subagents cover the main work: code-explorer traces existing behavior, code-architect prepares implementation plans, and code-reviewer checks the result.

After approval, the skill edits the relevant files with Read, Write, Edit, Bash, and Task. The review phase looks for bugs, project convention issues, and unnecessary complexity. The final phase records the completed work, changed files, and key decisions.

The workflow pauses for explicit approval before implementation and before the architecture choice. It will not start changing files immediately after the slash command.

What it helps with

  • trace relevant paths through an unfamiliar codebase
  • turn vague feature requests into clear requirements
  • compare implementation designs before coding
  • review changed files for bugs and convention issues

Example prompts for the agent

  • Run /feature-dev and ask the agent to guide a new feature from discovery through review.
  • Use /feature-dev Add user authentication with OAuth to plan and build the feature in phases.
  • Start /feature-dev Add rate limiting to API endpoints and ask for architecture options before implementation.

How to install feature-dev

1Skills CLI (Vercel)

npx skills add secondsky/claude-skills --skill feature-dev -a claude-code

2Manually: put the files in place

~/.claude/skills/feature-dev/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/feature-dev/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about feature-dev

How do I install feature-dev in Claude Code?

Run npx skills add secondsky/claude-skills --skill feature-dev -a claude-code, then check ~/.claude/skills/feature-dev/SKILL.md.

What does feature-dev do?

It guides feature development through seven phases, covering requirements, codebase exploration, architecture, implementation, review, and a final summary.

When does feature-dev modify the code?

It waits for explicit approval of the selected architecture before implementation begins. The agent then follows that approved approach.

Source text

SKILL.md · MIT
---
name: feature-dev
description: "Automate 7-phase feature development with specialized agents (code-explorer, code-architect, code-reviewer). Use for multi-file features, architectural decisions, or encountering ambiguous requirements, integration patterns, design approach errors."
license: MIT
allowed-tools: ["Read", "Write", "Edit", "Bash", "Task"]
metadata:
  version: 1.0.0
  author: Sid Bidasaria
  agents:
    - code-explorer
    - code-architect
    - code-reviewer
  keywords:
    - feature development
    - code exploration
    - architecture design
    - code review
    - workflow automation
    - slash command
    - agents
    - discovery phase
    - implementation planning
    - quality review
---
# Feature Development Workflow

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

## Quick Start

Launch the guided feature development workflow:

```bash
/feature-dev Add user authentication with OAuth
```

Or interactively:

```bash
/feature-dev
```

The workflow will guide you through 7 distinct phases automatically.

## Overview

Building features requires more than just writing code. This skill provides a systematic approach that:
- **Understands the codebase** before making changes
- **Asks clarifying questions** to resolve ambiguities
- **Designs thoughtfully** with multiple architecture options
- **Reviews for quality** after implementation

## The 7-Phase Workflow

### Phase 1: Discovery
**Goal**: Understand what needs to be built

- Clarifies unclear feature requests
- Identifies problem, constraints, and requirements
- Summarizes understanding and confirms with user

**Example**:
```
User: /feature-dev Add caching
Agent: 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

- Launches 2-3 `code-explorer` agents in parallel
- Explores similar features, architecture, UI patterns
- Reads all identified files for 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

Key files:
- src/auth/AuthService.ts:45 - Core authentication logic
- src/middleware/authMiddleware.ts:12 - Request authentication
```

### Phase 3: Clarifying Questions
**Goal**: Fill in gaps and resolve all ambiguities

- Reviews codebase findings and feature request
- Identifies underspecified aspects (edge cases, error handling, integration points)
- Presents organized list of questions
- **Waits for answers before proceeding**

**Example**:
```
Before designing, I need to clarify:

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

**Critical**: Ensures nothing is ambiguous before design begins.

### Phase 4: Architecture Design
**Goal**: Design multiple implementation approaches

- Launches 2-3 `code-architect` agents with different focuses:
  - **Minimal changes**: Smallest change, maximum reuse
  - **Clean architecture**: Maintainability, elegant abstractions
  - **Pragmatic balance**: Speed + quality
- Presents comparison with trade-offs and recommendation
- **Asks which approach to use**

**Example output**:
```
Approach 1: Minimal Changes
- Extend existing AuthService with OAuth methods
Pros: Fast, low risk
Cons: Couples OAuth to existing auth

Approach 2: Clean Architecture
- New OAuthService with dedicated interface
Pros: Clean separation, testable
Cons: More files, more refactoring

Approach 3: Pragmatic Balance
- New OAuthProvider abstraction
Pros: Balanced complexity and cleanliness
Cons: Some coupling remains

Recommendation: Approach 3 - clean boundaries without excessive refactoring
```

### Phase 5: Implementation
**Goal**: Build the feature

- **Waits for explicit approval** before starting
- Reads all relevant files from previous phases
- Implements following chosen architecture
- Follows codebase conventions strictly
- Updates todos to track progress

### Phase 6: Quality Review
**Goal**: Ensure code is simple, DRY, elegant, and functionally correct

- Launches 3 `code-reviewer` agents in parallel:
  - **Simplicity/DRY/Elegance**: Code quality
  - **Bugs/Correctness**: Functional correctness
  - **Conventions/Abstractions**: Project standards
- Consolidates findings and identifies high severity issues
- **Asks what to do**: Fix now, fix later, or proceed as-is

**Example output**:
```
High Priority Issues:
1. Missing error handling in OAuth callback (src/auth/oauth.ts:67)
2. Memory leak: OAuth state not cleaned up (src/auth/oauth.ts:89)

Medium Priority:
1. Could simplify token refresh logic (src/auth/oauth.ts:120)

What would you like to do?
```

### Phase 7: Summary
**Goal**: Document what was accomplished

- Marks all todos complete
- Summarizes what was built, key decisions, files modified
- Suggests next steps

## Specialized Agents

### code-explorer
**Purpose**: Deeply analyzes existing codebase features by tracing execution paths

**Focus**:
- Entry points and call chains
- Data flow and transformations
- Architecture layers and patterns
- Implementation details

**Output**:
- Entry points with file:line references
- Step-by-step execution flow
- Key components and responsibilities
- Essential files to read

**Triggered**: Automatically in Phase 2, or manually

### code-architect
**Purpose**: Designs feature architectures and implementation blueprints

**Focus**:
- Codebase pattern analysis
- Architecture decisions
- Component design
- Implementation roadmap

**Output**:
- Patterns and conventions found
- Architecture decision with rationale
- Complete component design
- Implementation map with build sequence

**Triggered**: Automatically in Phase 4, or manually

### code-reviewer
**Purpose**: Reviews code for bugs, quality issues, and project conventions

**Focus**:
- Project guideline compliance (CLAUDE.md)
- Bug detection
- Code quality issues
- Confidence-based filtering (≥80% confidence only)

**Output**:
- Critical issues (confidence 75-100)
- Important issues (confidence 50-74)
- Specific fixes with file:line references

**Triggered**: Automatically in Phase 6, or manually

## Usage Patterns

### Full workflow (recommended for new features)
```bash
/feature-dev Add rate limiting to API endpoints
```

### Manual agent invocation

**Explore a feature**:
```
"Launch code-explorer to trace how authentication works"
```

**Design architecture**:
```
"Launch code-architect to design the caching layer"
```

**Review code**:
```
"Launch code-reviewer to check my recent changes"
```

## When to Use

**Use for**:
- New features that touch multiple files
- Features requiring architectural decisions
- Complex integrations with existing code
- Features where requirements are somewhat unclear

**Don't use for**:
- Single-line bug fixes
- Trivial changes
- Well-defined simple tasks
- Urgent hotfixes

## Best Practices

1. **Use the full workflow for complex features**: The 7 phases ensure thorough planning
2. **Answer clarifying questions thoughtfully**: Phase 3 prevents future confusion
3. **Choose architecture deliberately**: Phase 4 gives options for a reason
4. **Don't skip code review**: Phase 6 catches issues before production
5. **Read the suggested files**: Phase 2 identifies key files—read them for context

## Common Issues

### Agents take too long
**Cause**: Normal for large codebases
**Solution**: Agents run in parallel when possible. Thoroughness pays off in better understanding.

### Too many clarifying questions
**Cause**: Feature request too vague
**Solution**: Be more specific in initial request. Provide context about constraints upfront.

### Architecture options overwhelming
**Cause**: Multiple valid approaches presented
**Solution**: Trust the recommendation (based on codebase analysis). Pick pragmatic option when in doubt.

## Requirements

- Claude Code installed
- Git repository (for code review)
- Existing codebase (workflow learns from existing patterns)

## Tips

- **Be specific in feature request**: More detail = fewer clarifying questions
- **Trust the process**: Each phase builds on the previous one
- **Review agent outputs**: Agents provide valuable codebase insights
- **Don't skip phases**: Each phase serves a purpose
- **Use for learning**: Exploration phase teaches you about your own codebase

## Verification Checklist

After using the workflow:

- [ ] All 7 phases completed successfully
- [ ] Clarifying questions answered in Phase 3
- [ ] Architecture approach selected in Phase 4
- [ ] Implementation approved before Phase 5 started
- [ ] Code review findings addressed in Phase 6
- [ ] Summary generated with next steps in Phase 7
- [ ] Feature works as expected
- [ ] Code follows project conventions

## References

For detailed workflow documentation, see `README.md`

For agent specifications, see:
- `agents/code-explorer.md`
- `agents/code-architect.md`
- `agents/code-reviewer.md`

For slash command implementation, see `commands/feature-dev.md`

© Sid Bidasaria · MIT · secondsky/claude-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

feature-dev by other authors comes first.

feature-dev notedit feature-dev walks the agent through eight phases: codebase exploration, clarifying questions, architecture options, implementation, tests and review. CX Codex +1 552installs generic-feature-developer travisjneuman generic-feature-developer walks a feature from reading the codebase to picking patterns, shipping small commits and checking edge cases before you close it. CX Codex +1 142installs devkit.feature-development Giuseppe Trisciuoglio devkit.feature-development — a slash command that carries a new feature through seven phases: code exploration, questions, architecture, implementation, review. Handy when you start from scratch. CX Codex +1 ★ 372repo stars review-pr OrchestKit review-pr is a Claude Code skill that reviews a pull request, branch, or diff range with parallel agents. It returns an approve or request-changes verdict before a merge. CX Codex +1 217installs feature-development Seth Hobson feature-development runs a feature through requirements, architecture and implementation step by step, pausing for your approval and keeping state in .feature-dev/. CX Codex +1 ★ 42,780repo stars feature aeonfun The feature skill builds repository enhancements and opens PRs. Choose a sweep across watched repos, one external target, or a dormant project. CX Codex +1 ★ 797repo stars explore OrchestKit explore spawns 3–5 agents in parallel to map code structure, trace data flows, identify architecture patterns, and assess code health. Useful for quickly understanding an unfamiliar repo or discovering how a large system is designed. CX Codex +1 224installs

From the same set138

The whole set →
cloudflare-workers-migration cloudflare-workers-migration — a skill for porting applications to Cloudflare Workers from AWS Lambda, Vercel, Express and Node.js. Adapts handlers, middleware and environment variables to Web APIs. CX Codex +1 316installs tanstack-query This skill guides Claude Code through TanStack Query v5 for fetching, caching, mutations, and v4 migration issues in React projects. CX Codex +1 314installs zustand-state-management zustand-state-management guides agent setup of Zustand v5 stores for React 18+ and TypeScript 5+. Fixes Next.js hydration mismatches and prevents selector re-render loops. CX Codex +1 301installs nextjs Skill for Next.js 16 and React 19.2 with App Router, Server Components, Server Actions, and caching patterns. Handles migration from version 15, async params errors, and Partial Prerendering setup. CX Codex +1 299installs cloudflare-nextjs The cloudflare-nextjs skill guides Next.js deployments to Cloudflare Workers with OpenNext. Use it to migrate a project or troubleshoot Workers-specific configuration and runtime issues. CX Codex +1 267installs cloudflare-turnstile cloudflare-turnstile is a Claude Code skill for adding Turnstile and checking tokens on the server. It activates for bot protection work, widget errors, and CSP or token validation failures. CX Codex +1 261installs base-ui-react base-ui-react is a Claude Code skill for building MUI Base UI interfaces, configuring accessible components and popup positioning, and migrating from Radix UI. CX Codex +1 259installs auto-animate Shows how to wire up @formkit/auto-animate in React for lists, accordions and toasts. Animations with zero config, 3.28 KB gzipped. CX Codex +1 257installs

Project sponsors

Companies that keep this analytics open