develop

What this skill does

# Feature Development Workflow

Structured 8-phase process for building new features from requirement gathering through documentation. Each phase produces a concrete output that feeds the next.

## Overview

1. **Discover** - Understand requirements and context
2. **Explore** - Analyze existing codebase patterns
3. **Clarify** - Resolve ambiguities with user input
4. **Design** - Create architecture with specialized agents
5. **Implement** - Build with TDD and quality practices
6. **Review** - Multi-agent quality review with confidence scoring
7. **Validate** - Run all verification hooks and summarize
8. **Document** - Write blog post announcing the feature

---

## Phase 1: Discover

### Understand requirements and gather context

**Objective**: Establish clear understanding of what needs to be built and why.

1. **Review the feature request**:
   - What is the user-facing goal?
   - What problem does this solve?
   - What are the acceptance criteria?

2. **Identify impacted areas**:
   - Which parts of the codebase will change?
   - What existing features might be affected?
   - Are there related issues or PRs?

3. **Check for similar features**:

   ```bash
   # Search for similar implementations
   grep -r "similar_feature_name" .
   ```

4. **Review project documentation**:
   - Check CLAUDE.md, CONTRIBUTING.md for standards
   - Review architecture docs if available
   - Identify any constraints or requirements

**Output**: Clear problem statement and high-level approach.

---

## Phase 2: Explore (Parallel Agent Execution)

### Analyze codebase with specialized agents

**Objective**: Understand existing patterns and identify integration points.

**Launch multiple Explore agents in PARALLEL** (single message with multiple Task calls):

1. **Code Explorer**: Map existing features
   - Find entry points and call chains
   - Identify data flow and transformations
   - Document current architecture

2. **Pattern Analyzer**: Identify conventions
   - How are similar features implemented?
   - What testing patterns are used?
   - What naming conventions exist?

3. **Dependency Mapper**: Understand relationships
   - What modules will be affected?
   - What are the integration points?
   - Are there circular dependencies to avoid?

**Consolidation**: Synthesize findings from all agents into a cohesive understanding.

**Output**: Comprehensive map of existing codebase patterns and integration points.

---

## Phase 3: Clarify (Human Decision Point)

### Resolve ambiguities before implementation

**Objective**: Get user input on unclear requirements and design choices.

**Use AskUserQuestion tool** to resolve:

1. **Architecture decisions**:
   - Which approach should we take? (if multiple valid options)
   - What are the trade-offs? (performance vs. simplicity)

2. **Scope clarifications**:
   - Should this include X feature?
   - What's the priority if time is limited?

3. **Integration choices**:
   - Should we extend existing module or create new one?
   - How should this integrate with system Y?

**IMPORTANT**: Do not proceed with assumptions. Get explicit user answers.

**Output**: Clear, unambiguous requirements with user-approved approach.

---

## Phase 4: Design (Parallel Agent Execution)

### Create architecture with specialized agents

**Objective**: Design the implementation before coding.

**Select appropriate specialized agent(s)** based on feature type:

- **Frontend feature?** → `frontend:presentation-engineer`
- **Backend API?** → `backend:api-designer`
- **Database changes?** → `databases:database-designer`
- **Complex system?** → `architecture:solution-architect`

**Launch agents in PARALLEL** for multi-disciplinary features:

- Frontend + Backend agents simultaneously
- Include `security:security-engineer` for sensitive features
- Include `performance:performance-engineer` for high-traffic features

**Agent responsibilities**:

- Define module structure and file organization
- Specify interfaces and contracts
- Identify testing strategy
- Document key decisions and trade-offs

**Consolidation**: Review all design proposals, resolve conflicts, select final approach.

**Output**: Detailed implementation plan with module structure and interfaces.

---

## Phase 5: Implement (TDD with Quality Enforcement)

### Build the feature using test-driven development

**Objective**: Implement the designed solution with quality practices.

**Apply TDD cycle** (use `tdd:test-driven-development` skill):

```
For each component:
1. Write failing test (Red)
2. Implement minimum code to pass (Green)
3. Refactor for quality (Refactor)
4. Repeat
```

**Implementation guidelines**:

- ✅ Start with tests, not implementation
- ✅ Follow existing codebase patterns (from Phase 2)
- ✅ Apply SOLID principles (`han-core:solid-principles` skill)
- ✅ Keep it simple (KISS, YAGNI)
- ✅ Apply Boy Scout Rule - leave code better than found
- ❌ Don't over-engineer
- ❌ Don't skip tests
- ❌ Don't ignore linter/type errors

**Integration**:

- Integrate incrementally (don't build everything then integrate)
- Test integration points early
- Validate against acceptance criteria continuously

**Output**: Working implementation with comprehensive tests.

---

## Phase 6: Review (Parallel Multi-Agent Review)

### Quality review with confidence-based filtering

**Objective**: Identify high-confidence issues before final validation.

**Launch review agents in PARALLEL** (single message with multiple Task calls):

1. **Code Reviewer** (han-core:code-reviewer skill):
   - General quality assessment
   - Confidence scoring ≥80%
   - False positive filtering

2. **Security Engineer** (security:security-engineer):
   - Security vulnerability scan
   - Auth/authz pattern verification
   - Input validation review

3. **Discipline-Specific Agent**:
   - Frontend: `frontend:presentation-engineer` (accessibility, UX)
   - Backend: `backend:backend-architect` (API design, scalability)
   - etc.

**Review consolidation**:

- Merge findings from all agents
- De-duplicate issues
- Filter for confidence ≥80%
- Organize by: Critical (≥90%) → Important (≥80%)

**Present findings to user with options**:

```
Found 3 critical and 5 important issues.

Options:
1. Fix all issues now (recommended)
2. Fix critical only, defer important
3. Review findings and decide per-issue
```

**Output**: Consolidated review with high-confidence issues only.

---

## Phase 7: Validate & Summarize

### Final verification and change summary

**Objective**: Ensure all quality gates pass and document the change.

**Run all validation hooks**:

```bash
# All validation plugins automatically run on Stop
# Verify: tests, linting, type checking, etc.
```

**Validation checklist**:

- [ ] All tests pass
- [ ] Linting passes
- [ ] Type checking passes
- [ ] No security vulnerabilities introduced
- [ ] Documentation updated
- [ ] No breaking changes (or properly coordinated)

**Generate change summary**:

1. **What changed**: Files modified and why
2. **How to test**: Steps to verify functionality
3. **Breaking changes**: None, or list with migration guide
4. **Follow-up tasks**: Any deferred work or tech debt

**Create TODO list** (using TaskCreate tool):

- Document any follow-up tasks
- Track deferred improvements
- Note any tech debt introduced

**Output**: Ready-to-commit feature with comprehensive documentation.

---

## Phase 8: Document (Blog Post)

### Write a blog post announcing the feature

**Objective**: Share the new feature with the community and explain its value.

**Blog post creation**:

1. **Research context** (optional):
   - Use `reddit` to find related community discussions
   - Identify pain points the feature addresses
   - Understand how users talk about this problem

2. **Write the blog post**:

   Location: `website/content/blog/{feature-slug}.md`

   ```markdown
   ---
   title: "{Feature Name}: {Compelling subtitle}"
   description: "{One-line description of what problem this solves}"
   date: "{Y