# develop-feature

> Guide feature development with structured investigation, design, and TDD implementation workflow.

- Author: raiich
- Repository: raiich/jumpstarter
- Version: 20260210012101
- Stars: 1
- Forks: 0
- Last Updated: 2026-02-09
- Source: https://github.com/raiich/jumpstarter
- Web: https://mule.run/skillshub/@@raiich/jumpstarter~develop-feature:20260210012101

---

---
name: develop-feature
description: Guide feature development with structured investigation, design, and TDD implementation workflow.
allowed-tools: Read, Grep, Glob, Edit, Write, AskUserQuestion, EnterPlanMode, ExitPlanMode, TaskCreate, TaskUpdate, TaskList, TaskGet
---

# Feature Development Guide

A skill for structuring feature development. Conduct investigation and design in Plan mode, then proceed with TDD implementation after approval.

## Assumptions

- Users may not provide all requirements upfront; clarify unknowns through iterative questions
- Run TDD cycles in small increments

## Output Directory

Under `.local/docs/feature-[name]/`:

- `knowledge-base.md` - Knowledge base
- `design-doc.md` - Design Doc
- `test-cases.md` - Test case design
- `summary.md` - Work summary

## Task Granularity

- 1 task = roughly 1 function, class, or method
- 1 task = roughly 1-5 test cases

## Base Pattern: Create and Review

1. **Claude: Create deliverable**
2. **Claude: Self-review** - Revise as needed
3. **User: Review** - User review always follows self-review
4. **Claude: Revise** - Apply feedback if any

Steps marked "(Base Pattern)" in the flow follow this pattern.

## Flow

### [Investigation & Design Phase] — Plan mode

Enter Plan mode with **EnterPlanMode** to conduct investigation and design. In Plan mode, only reading and searching files is possible; writing is not allowed. Compile design content in the plan file.

#### 1. User: Provide feature development direction

#### 2. Enter Plan mode

**Tool**: EnterPlanMode

#### 3. Codebase investigation

Investigate the existing codebase and documentation, recording knowledge base content in the plan file.

**Tools**: Use Read, Glob, Grep to explore the codebase

**Content to record in the plan file (Knowledge Base):**
```markdown
# Knowledge Base

## Related Existing Features
- Feature A: src/features/a/handler.gd
- Feature B: src/features/b/processor.gd

## Key Architecture Patterns
- Pattern 1: Description

## Reference Documentation
- docs/architecture.md

## Investigation Notes
- Important findings
```

#### 4. Requirements gathering

Leverage the knowledge base to efficiently gather requirements from the user.

**Tool**: AskUserQuestion

Update the knowledge base in the plan file based on gathered requirements.

#### 5. Design Doc creation

Add a Design Doc section to the plan file.

**Content to record in the plan file (Design Doc):**
```markdown
# Design Doc

## Background & Purpose
## Scope
## Technical Approach (rationale, alternatives)
## Design (architecture, processing flow)
## Implementation Details
## Considerations (security, etc.)
```

**Important:**
- Avoid writing long, concrete code
- Include code examples only for critical sections
- Use dummy code to concisely illustrate processing flows when needed
- Prefer mermaid format for diagrams

#### 6. Test case design

Add a test cases section to the plan file.

**Content to record in the plan file (Test Cases):**
```markdown
# Test Case Design

## Test Case 1: [Feature] happy path
- Given: [Preconditions]
- When: [Action performed]
- Then: [Expected result]

## Test Case 2: [Feature] error path
- Given: [Preconditions]
- When: [Action performed]
- Then: [Expected error handling]
```

#### 7. Implementation task list

Add an implementation task list to the plan file. Break down into small units following the task granularity guidelines.

#### 8. Self-review and exit Plan mode

Self-review the entire plan file. If satisfactory, request user approval with ExitPlanMode.

**Tool**: ExitPlanMode

### [Document Creation Phase] — Normal mode

After user approval, save the plan content as document files.

#### 9. Create document files

Save the approved plan content to each file:

- `.local/docs/feature-[name]/knowledge-base.md`
- `.local/docs/feature-[name]/design-doc.md`
- `.local/docs/feature-[name]/test-cases.md`

**Tool**: Write

#### 10. Create TODO list

Create TODOs based on the implementation task list from the plan.

**Tool**: TaskCreate

### [Implementation Phase - Repeat per task]

#### 11. TDD cycle execution

**Tool**: TaskUpdate to set task to in_progress

For each task, perform the following:

**11.1. Write test code (Base Pattern)**
- Implement test code based on the test case design

**11.2. Implement feature (Base Pattern)**
- Implement the feature to make tests pass

**11.3. Run tests and handle failures**

When tests fail:

1. **Implementation bug** -> Fix and re-test
2. **Test design error** -> Review test case design, update test-cases.md
3. **Requirements misunderstanding** -> Review Design Doc, update design-doc.md
4. **Cannot determine** -> Gather input from the user

**11.4. Update knowledge base (when needed)**
- Add new knowledge discovered during implementation

**11.5. Task completion**

**Tool**: TaskUpdate to set completed, TaskList to check next task

**Review granularity**:
- Minor tasks: Batch review acceptable
- Important tasks: Individual review

### [Completion Phase]

#### 12. Organize entire knowledge base

After all tasks are complete, organize knowledge added during the implementation phase.

#### 13. Save work summary

**Content**:
- Overview of implemented features
- Key technical decisions and rationale
- Difficulties encountered and solutions
- Remaining issues and improvements

## Self-Review Criteria

### Plan (Investigation & Design Phase)
- Knowledge base completeness (are related existing features overlooked?)
- Design Doc validity (is the technical approach appropriate?)
- Test case coverage (happy path, error path, edge cases)
- Task breakdown granularity (not too large, not too small?)

### Test Code
- Coverage of the feature
- Edge case consideration
- Error case coverage

### Implementation Code
- No over-engineering
- No security concerns

Adjust criteria based on content. If unclear, gather input from the user.