/incremental-feature-build

Incremental Feature Build Command

Systematic approach for building complex features incrementally, preventing premature completion and ensuring comprehensive functionality through structured feature tracking.

Instructions

Build a feature incrementally using the structured approach for: **$ARGUMENTS**

This command implements best practices for long-running agent tasks, preventing the tendency to one-shot applications or prematurely consider projects complete.

> **Note:** `$ARGUMENTS` is automatically replaced with the text following the command invocation. > Example: `/dev:incremental-feature-build user authentication system` sets `$ARGUMENTS` to "user authentication system"

---

Phase 1: Feature Requirements Expansion

1.1 Create Feature Tracking Directory

# Create tracking directory with error handling
mkdir -p .feature-tracking || { echo "ERROR: Cannot create .feature-tracking directory. Check permissions."; exit 1; }

If directory creation fails, verify:

• You have write permissions in the current directory
• Sufficient disk space is available
• No file named `.feature-tracking` already exists

1.2 Generate Comprehensive Feature List

Analyze the user's request and expand it into a comprehensive list of granular features. Each feature should be a discrete, testable unit of functionality.

**Create file: `.feature-tracking/features.json`**

{
  "project": "$ARGUMENTS",
  "created": "YYYY-MM-DD",
  "version": "1.0.0",
  "summary": {
    "total": 0,
    "passing": 0,
    "failing": 0
  },
  "features": []
}

1.3 Feature Schema

Each feature MUST follow this exact JSON schema:

{
  "id": "FEAT-001",
  "category": "functional|ui|integration|performance|security|accessibility",
  "priority": "critical|high|medium|low",
  "description": "Clear, actionable description of the feature",
  "steps": [
    "Step 1: Specific action to verify",
    "Step 2: Expected behavior check",
    "Step 3: Edge case validation"
  ],
  "dependencies": ["FEAT-000"],
  "passes": false,
  "implementedAt": null,
  "commitHash": null
}

> **Note:** This command uses a simple boolean `passes` field since features are implemented sequentially. > The parallel command (`/dev:parallel-feature-build`) uses a multi-state `status` field to track > concurrent work: `pending`, `in_progress`, `passed`, `blocked`.

1.4 Feature Categories

Generate features across ALL relevant categories:

| Category | Description | Examples | |----------|-------------|----------| | `functional` | Core business logic | User can submit form, data saves correctly | | `ui` | User interface elements | Button displays, modal opens, responsive layout | | `integration` | System connections | API calls work, database syncs, auth flows | | `performance` | Speed and efficiency | Page loads under 3s, lazy loading works | | `security` | Protection measures | Input sanitized, auth required, CSRF protection | | `accessibility` | Inclusive design | Screen reader support, keyboard navigation |

1.5 Feature Generation Guidelines

When expanding the user's request:

1. **Use Hierarchical Organization**: Group features into epics/modules for manageability

• Small projects: 10-30 features
• Medium projects: 30-60 features
• Large projects: 60-100 features (consider using `/dev:parallel-feature-build` instead)

2. **Be Specific**: Each feature should be independently verifiable 3. **Include Edge Cases**: Error states, empty states, boundary conditions 4. **Cover All Paths**: Happy path AND unhappy paths 5. **Think Like a User**: What would they expect at each step?

**Feature Grouping Example:**

{
  "epics": [
    {
      "id": "EPIC-01",
      "name": "User Authentication",
      "features": ["FEAT-001", "FEAT-002", "FEAT-003"]
    }
  ]
}

---

Phase 2: Initialize Progress Tracking

2.1 Create Progress File

**Create file: `.feature-tracking/PROGRESS.md`**

# Feature Implementation Progress

## Project: $ARGUMENTS
## Started: YYYY-MM-DD

---

## Current Status

- **Features Total**: X
- **Implemented**: 0
- **Remaining**: X

---

## Session Log

### Session 1 - YYYY-MM-DD

**Focus**: Initial setup and first features

**Completed**:
- (none yet)

**Notes**:
- (session notes here)

**Commit**: (hash when committed)

---

## Implementation Order

Based on dependencies, implement in this order:

1. [ ] FEAT-001 - Description
2. [ ] FEAT-002 - Description
...

---

## Blocked/Issues

(Track any blockers here)

2.2 Git Initialization Check

Ensure git is initialized and create initial tracking commit:

git add .feature-tracking/
git commit -m "feat: initialize feature tracking for $ARGUMENTS

- Created features.json with X features to implement
- All features marked as failing (passes: false)
- Created progress tracking file"

---

Phase 3: Incremental Implementation

CRITICAL RULES

**You MUST follow these rules without exception:**

1. **ONE FEATURE AT A TIME**: Never work on multiple features simultaneously 2. **NO TEST REMOVAL**: It is **UNACCEPTABLE** to remove or edit features from features.json because this could lead to missing or buggy functionality 3. **ONLY CHANGE STATUS**: The only modification allowed to features.json is changing `passes` from `false` to `true` and updating `implementedAt` and `commitHash` 4. **COMMIT AFTER EACH**: Create a git commit after each feature is implemented 5. **CLEAN STATE**: Each commit must leave the codebase in a working state

3.1 Feature Implementation Loop

For each feature, follow this exact workflow:

Step A: Select Next Feature

1. Read `.feature-tracking/features.json` 2. Find the first feature where `passes: false` 3. Check dependencies are satisfied (all dependent features pass) 4. Announce: "Now implementing FEAT-XXX: [description]"

Step B: Implement Feature

1. Write the necessary code 2. Ensure existing functionality still works 3. Test the specific feature manuall