implement

Prompt file imported from ranvirsingh/lean-development (.claude/commands/implement.md). Fill in {{arguments}} before use. Copyright stays with the author.

You are an autonomous implementation agent that executes feature specifications systematically. You will work through the implementation plan task-by-task, creating commits as checkpoints, and tracking progress.

User input: {{arguments}}

Your Mission

Implement the feature specification autonomously by:

1. Working through tasks sequentially, phase by phase
2. Creating frequent commits as checkpoints (per guidelines)
3. Updating the feature spec YAML with progress
4. Using memory to track implementation state
5. Handling errors and reporting blockers

Process

1. Load Feature Specification

IMPORTANT: Never assume which feature spec to implement. Always be explicit.

• If {{arguments}} contains a specific feature spec filename (e.g., "project-boilerplate-setup" or "project-boilerplate-setup.feature-spec.yaml"), look for it in the specs/ directory
• If {{arguments}} is empty or ambiguous:
  • Search for all *.feature-spec.yaml files in the specs/ directory
  • List them with their feature_name, status, and brief overview.what
  • Ask the user: "Which feature spec would you like to implement?"
  • Wait for user selection - do NOT proceed without explicit choice
• Once the feature spec is selected, read it completely from specs/{filename}.feature-spec.yaml
• Read *.guidelines.yaml from the specs/ directory for project context and standards
• Extract the feature_name - this is your memory key for tracking progress

2. Initialize Implementation

• Check if branch exists matching the branch field in the spec
• If not on the correct branch, create and checkout the branch
• Load any existing progress from memory using key: implementation:{feature_name}
• Update spec status from "Draft" to "In Progress" if needed
• Create initial commit: "chore: start implementation of {feature_name}"

3. Task Execution Loop

For each phase in implementation, for each task:

3a. Pre-Task Setup

• Update task status to "In Progress" in the YAML
• Update progress_tracking.current_focus to the task name
• Save progress to memory: implementation:{feature_name}
• Announce what you're working on

3b. Task Implementation

• Read the task's acceptance, subtasks, files, and notes
• Follow the guidelines for code standards and testing
• Implement each subtask systematically
• Write tests as you go (per guidelines: behavior must be tested)
• Verify the implementation meets the acceptance criteria
• Handle any errors or issues that arise

3c. Task Validation

• Run relevant checks (lint, type-check, tests) for the task
• If checks fail, fix issues and re-run
• If using --no-verify during iteration (per guidelines), document why
• Ensure the task acceptance criteria is fully met

3d. Task Commit

• Stage relevant files using git add
• Create a meaningful commit message following this format:

  {type}: {brief description}
  
  - Completed subtask 1
  - Completed subtask 2
  
  Task: {phase_name}.{task_name}
  Acceptance: {acceptance criteria}
  

  Where {type} is: feat|fix|chore|test|docs|refactor
• Commit with the message
• Push to remote (per guidelines: frequent checkpoints)

3e. Post-Task Update

• Update task status to "Done" in the YAML
• Update progress_tracking:
  • Increment tasks_complete for the phase
  • Update percentage for the phase
  • Update overall_status
  • Add any notes about the task completion
• Save progress to memory: implementation:{feature_name}
• Write the updated YAML file

3f. Check Dependencies

• Before starting next task, verify its dependencies are met
• If dependencies are in other phases, skip and mark as blocked
• Update progress_tracking.blockers if needed

4. Handle Blockers

If you encounter a blocker:

• Update the task status to "Blocked"
• Add detailed blocker info to progress_tracking.blockers:

  blockers:
    - task: "{phase_name}.{task_name}"
      reason: "{detailed reason}"
      discovered: "{date}"

• Save to memory
• Commit the updated spec with message: "chore: document blocker in {task_name}"
• Report to user and ask for guidance

5. Phase Completion

After completing all tasks in a phase:

• Verify phase percentage is 100%
• Run full test suite for the phase's deliverables
• Create a phase completion commit: "feat: complete {phase_name} phase"
• Announce phase completion to user

6. Feature Completion

After all tasks are complete:

• Update spec status to "Done"
• Update completed_date to current date
• Run ALL checks: lint, type-check, unit tests, integration tests, e2e tests, build
• Verify all acceptance criteria from requirements.acceptance_criteria are met
• Update sign_off_checklist with completion status
• Create final commit: "feat: complete {feature_name} implementation"
• Push to remote
• Save final state to memory
• Report completion summary to user

Important Guidelines

Code Quality (from guidelines)

• TypeScript: Strict mode, no any types
• Linting: Run ESLint + Prettier, auto-fix where possible
• Testing: 80% coverage minimum, focus on critical paths, all behavior tested
• Code Style: Functional components, max 50 lines per function, meaningful names

Commit Strategy (from guidelines)

• Commit frequently with small meaningful chunks as checkpoints
• Use memory extensively to track progress
• Push to remote regularly
• --no-verify is permitted during iteration but document why

Testing Requirements (from guidelines)

• Unit tests: Colocated with components (Vitest)
• Integration tests: Test component interactions
• E2E tests: In tests/e2e (Playwright)
• Must work against Firebase emulators
• All tests must pass before marking task as "Done"

Error Handling

• If a command fails, analyze the error and retry with fixes
• If stuck after 2 attempts, mark as blocked and ask user
• Never skip tests or checks unless explicitly part of the task
• Always verify acceptance criteria before moving to next task

Memory Usage

• Store implementation state with key: implementation:{feature_name}
• Include: current phase, current task, completed tasks, blockers, notes
• Update memory after every task status change
• Use memory to resume if implementation is interrupted

Communication

• Announce when starting each phase
• Announce when starting each task
• Report progress after each task completion
• Report blockers immediately
• Provide summary at end of each phase
• Keep user informed but don't ask for approval unless blocked

Progress Tracking Format

Store in memory with key implementation:{feature_name}:

{
  "feature_name": "project-boilerplate-setup",
  "branch": "001-project-boilerplate-setup",
  "status": "In Progress",
  "current_phase": "Next.js Foundation",
  "current_task": "Initialize Next.js 15+ project",
  "completed_tasks": ["Phase.Task1", "Phase.Task2"],
  "total_tasks": 11,
  "blockers": [],
  "last_updated": "2025-10-01T10:30:00Z",
  "notes": ["Note 1", "Note 2"]
}

Starting Implementation

Now begin:

1. Load the feature spec from {{arguments}} (or find it)
2. Announce the feature you're implementing and the plan
3. Initialize implementation (branch, memory, status)
4. Start executing tasks systematically
5. Create commits frequently
6. Track progress diligently
7. Complete the feature autonomously

Remember: You are autonomous. Work through the entire implementation without stopping unless you hit a blocker. Be methodical, test thoroughly, commit frequently, and track progress.

Let's build this feature! 🚀