Feature Implementer

Feature Implementer Skill

Purpose

Execute implementation steps from a plan, manage git worktrees for parallel development, adaptively build and test code, maintain plan progress, and generate comprehensive test plans. Works with any language, framework, or architecture through intelligent adaptation.

When to Use This Skill

Use this skill when:

• Implementation plan is ready (created by implementation-planner)
• Ready to implement one or more steps from the plan
• Need to create git worktrees for parallel development
• Want automatic build/test execution after implementation
• Need to update plan progress systematically
• Want to generate test plans based on implementation changes

Implementation Workflow

Phase 1: Setup and Preparation

1. Read the Implementation Plan

   • Locate plan file (Plan.md, implementation-plan.md, etc.)
   • Identify next step(s) to implement
   • Check dependencies are satisfied
   • Identify if worktree is needed

2. Create Git Worktree (if needed)

   • Use git-workflow-manager skill for worktree creation
   • Follow GitFlow conventions: feature/{name}, fix/{name}, etc.
   • Switch to worktree directory

3. Understand Project Structure

   • Identify project type by reading config files
   • Find build commands (package.json, Makefile, .csproj, etc.)
   • Find test commands
   • Locate where to implement changes

Adaptive Discovery:

- React/Node: Read package.json → scripts.build, scripts.test
- .NET: Find *.csproj → dotnet build, dotnet test
- Python: Look for setup.py, pyproject.toml, Makefile
- Go: Check go.mod → go build, go test
- Rust: Find Cargo.toml → cargo build, cargo test
- Generic: Look for Makefile, build scripts

Phase 2: Implementation

1. Implement the Step

   • Follow the step description from plan
   • Create/modify files as specified
   • Apply design patterns identified in research
   • Follow existing code conventions in the project

2. Document Changes

   • Add comments where complex logic exists
   • Update related documentation if needed
   • Note any deviations from original plan

Key Principle: Trust developer judgment for implementation details. The plan provides "what" and "where", developer provides "how".

Phase 3: Build and Test

1. Build the Project

   • Execute build command discovered in Phase 1
   • Capture build output
   • If build fails: Fix errors, rebuild
   • If build succeeds: Proceed to testing

2. Run Relevant Tests

   • Execute test command discovered in Phase 1
   • Run tests related to changes (unit, integration)
   • Capture test results
   • If tests fail: Fix and re-run
   • If tests pass: Proceed to plan update

Adaptive Testing:

# Examples of adaptive test execution
# JavaScript/TypeScript
npm test

# .NET
dotnet test

# Python
pytest
python -m pytest

# Go
go test ./...

# Rust
cargo test

# Generic
make test
./run-tests.sh

If Build/Test Commands Unknown:

• Search for scripts in project root
• Check CI/CD config files (.github/workflows, .gitlab-ci.yml)
• Ask user: "How do you build/test this project?"

Phase 4: Update Plan Progress

1. Mark Step Complete

   • Update checkbox in plan: - [ ] → - [x]
   • Update phase progress percentage
   • Note any blockers discovered
   • Document any deviations from plan

2. Check Next Steps

   • Identify if more steps can be done now
   • Check if dependencies are satisfied
   • Determine if iteration continues or pauses

Plan Update Example:

## Phase 2: Backend Implementation

- [x] Step 2.1: Create EmailService class ✅
- [x] Step 2.2: Implement SendEmail method ✅
- [ ] Step 2.3: Add email queueing (next)

**Progress:** 2/3 steps complete (67%)

Phase 5: Generate Test Plan

1. Use test-plan-generator Skill

   • Analyze changes made (git diff)
   • Determine types of tests needed
   • Generate test-plan.md with checkboxes
   • Avoid duplicate test coverage

2. Test Plan Contents

   • API tests (if backend changes)
   • E2E tests (if user-facing changes)
   • Unit tests (if complex logic added)
   • Performance tests (if performance-critical)

See test-plan-generator skill for detailed test plan generation.

Handling Different Project Types

React/TypeScript Project

Discovery:

# Files: package.json, tsconfig.json, vite.config.ts
# Build: npm run build
# Test: npm test
# Dev: npm run dev

Implementation Pattern:

• Components in src/components/
• Services in src/services/
• Types in src/types/
• Follow existing naming conventions

.NET Web API Project

Discovery:

# Files: *.csproj, Program.cs, appsettings.json
# Build: dotnet build
# Test: dotnet test
# Run: dotnet run

Implementation Pattern:

• Controllers in Controllers/
• Services in Services/
• Entities in Domain/Entities/
• Follow existing namespace structure

Python Project

Discovery:

# Files: setup.py, pyproject.toml, requirements.txt
# Build: python -m build (if applicable)
# Test: pytest, python -m pytest
# Run: python main.py or module-specific

Implementation Pattern:

• Follow existing module structure
• Use virtual environment
• Respect PEP 8 conventions

Go Project

Discovery:

# Files: go.mod, go.sum
# Build: go build
# Test: go test ./...
# Run: go run main.go

Implementation Pattern:

• Follow Go package conventions
• Respect existing structure

Generic/Unknown Project

Discovery Strategy:

1. Look for Makefile → make, make test
2. Look for build scripts → ./build.sh, ./test.sh
3. Check README for build/test instructions
4. Ask user: "How do I build and test this project?"

Using Git Worktrees

When to Use Worktrees

✅ Use worktrees when:

• Implementing multiple features in parallel
• Want to preserve working state in main worktree
• Working with team members on different features
• Need to switch between features frequently

❌ Don't use worktrees when:

• Simple linear development (single feature)
• Quick fixes that take <1 hour
• User doesn't need parallel development

Creating Worktree

Use git-workflow-manager skill:

# Create feature worktree
# git-workflow-manager will handle:
# - Creating ../repo-worktrees/feature/feature-name/
# - Creating branch feature/feature-name
# - Setting up worktree

Refer to git-workflow-manager skill for detailed worktree management.

Iteration Strategy

Single-Step Implementation

Implement one step, build, test, update plan, generate test plan, done.

Use when:

• Steps are independent
• Step is complex and needs full focus
• User wants incremental progress

Batch Implementation

Implement multiple related steps, build once, test once, update plan, generate test plan.

Use when:

• Steps are tightly coupled
• Build time is long
• Steps must work together to be testable

Continuous Iteration (Workflow Mode)

Implement → Build → Test → Update → Next step → Repeat until phase complete.

Use when:

• User wants autonomous completion of a phase
• Steps are clear and dependencies satisfied
• Build/test feedback loop is fast

Adaptive Build and Test Execution

Build Execution Strategy

1. Try Common Commands:

   # Try in order based on project type detected
   npm run build
   dotnet build
   make
   go build
   cargo build
   python -m build
   mvn package
   gradle build
   

2. Parse Build Output:

   • Detect errors vs warnings
   • Identify files with errors
   • Extract error messages
   • Determine if build succeeded

3. Handle Build Failures:

   • Report errors clearly
   • Identify cause if possible
   • Suggest fixes if errors are common patterns
   • Iterate: Fix → Rebuild

Test Execution Strategy

1. Try Common Test Commands:

   npm test
   dotnet test
   pytest
   go test ./...
   cargo test
   make test
   mvn test
   

2. Selective Testing (if possible):

   • Run only tests related to changes
   • Skip slow integration tests during iteration
   • Run full test suite before marking complete

3. Handle Test Failures:

   • Report which tests failed
   • Extract failure messages
   • Determine if failures are related to changes
   • Iterate: Fix → Retest

Plan Update Best Practices

Checkbox Updates

# Before
- [ ] Step 1: Create EmailService

# After
- [x] Step 1: Create EmailService

Progress Tracking

## Phase 2: Backend (67%)

- [x] Step 2.1: Done
- [x] Step 2.2: Done
- [ ] Step 2.3: Next

Notes on Deviations

If implementation differs from plan:

- [x] Step 2.2: Implement SendEmail method
  **Note:** Used Microsoft Graph instead of SMTP as decided during research

Documenting Blockers

If step cannot be completed:

- [ ] Step 3.1: Deploy to staging
  **Blocker:** Staging environment credentials not available
  **Status:** Waiting for DevOps team

Integration with Other Skills

Dependencies

• git-workflow-manager: For worktree creation and management
• test-plan-generator: For generating test plans after implementation

Workflow Position

feature-research → implementation-planner → feature-implementer → test-executor → test-fixer
                                                    ↓
                                            test-plan-generator

Common Implementation Patterns

Pattern 1: Backend API Endpoint

Plan Step: "Create POST /api/forms endpoint"

Implementation:

1. Create controller method
2. Add route attribute
3. Define DTO
4. Add validation
5. Implement business logic
6. Return response
7. Build and test

Pattern 2: Frontend Component

Plan Step: "Create FormBuilder component"

Implementation:

1. Create component file
2. Define props interface
3. Implement component logic
4. Add styling
5. Export component
6. Build and test

Pattern 3: Database Migration

Plan Step: "Add Submission entity to database"

Implementation:

1. Create entity class
2. Add DbSet to context
3. Create migration
4. Review migration SQL
5. Apply migration
6. Verify schema

Tips for Effective Implementation

1. Read Plan Carefully: Understand the step fully before coding
2. Check Dependencies: Ensure prerequisite steps are complete
3. Follow Conventions: Match existing code style and patterns
4. Build Often: Don't wait until end to build
5. Test Incrementally: Test as you go, not just at the end
6. Update Plan Promptly: Mark steps complete immediately
7. Document Deviations: Note any changes from original plan
8. Ask When Uncertain: If build/test commands unknown, ask user
9. Generate Test Plans: Don't forget to create test-plan.md
10. Communicate Progress: Keep plan updated for visibility

Bundled Resources

• references/implementation-checklist.md - Quality checklist for implementations
• references/update-plan-guide.md - Guide for updating plans
• references/common-build-patterns.md - Build/test commands by framework