Implement Feature

Maximum utilization of parallel subagent execution for feature implementation with built-in scope control and reflection.

Quick Start

/implement user authentication
/implement real-time notifications
/implement dashboard analytics

Opus 4.6: Parallel agents leverage native adaptive thinking and 128K output for comprehensive implementations. Token budgets scale dynamically with context window.

STEP 0: Verify User Intent with AskUserQuestion

BEFORE creating tasks or doing ANY work, ask the user to clarify scope:

AskUserQuestion(
  questions=[
    {
      "question": "What scope for this implementation?",
      "header": "Scope",
      "options": [
        {"label": "Full-stack (Recommended)", "description": "Backend + frontend + tests + docs"},
        {"label": "Backend only", "description": "API + database + backend tests"},
        {"label": "Frontend only", "description": "UI components + state + frontend tests"},
        {"label": "Quick prototype", "description": "Minimal working version, skip tests"}
      ],
      "multiSelect": false
    },
    {
      "question": "Any constraints I should know about?",
      "header": "Constraints",
      "options": [
        {"label": "None (Recommended)", "description": "Use best practices and modern patterns"},
        {"label": "Match existing patterns", "description": "Follow existing codebase conventions exactly"},
        {"label": "Minimal dependencies", "description": "Avoid adding new packages"},
        {"label": "Specific tech stack", "description": "I'll specify the technologies to use"}
      ],
      "multiSelect": false
    }
  ]
)

Based on user’s answers, adjust the workflow:

• Full-stack: All 10 phases, all parallel agents
• Backend only: Skip frontend agents (phases 5b, 6b)
• Frontend only: Skip backend agents (phases 5a, 6a)
• Quick prototype: Skip phases 7-10 (scope check, verification, docs, reflection)

STEP 0b: Select Orchestration Mode

Choose Agent Teams (mesh, default when available) or Task tool (star, fallback):

• CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 → Agent Teams (default); not set → Task tool
• When Teams available: complexity < 2.5 → Task tool; >= 2.5 → Agent Teams
• Override: ORCHESTKIT_FORCE_TASK_TOOL=1 → always Task tool

See Orchestration Modes for decision logic, comparison table, and fallback strategy.

Opus 4.6: 128K Output Token Advantage

With 128K output tokens (2x previous 64K), agents can generate complete artifacts in fewer passes:

Guidance for agents: Generate complete, working code in a single pass whenever possible. Don’t split implementations across multiple responses unless the scope genuinely exceeds 128K tokens. Prefer one comprehensive response over multiple incremental ones.

CRITICAL: Task Management is MANDATORY (CC 2.1.16)

BEFORE doing ANYTHING else, create tasks to track progress:

# 1. Create main implementation task IMMEDIATELY
TaskCreate(
  subject="Implement: {feature}",
  description="Full-stack implementation with parallel agents",
  activeForm="Implementing {feature}"
)

# 2. Create subtasks for each phase (10-phase process)
TaskCreate(subject="Research best practices", activeForm="Researching best practices")
TaskCreate(subject="Design architecture", activeForm="Designing architecture")
TaskCreate(subject="Micro-plan each task", activeForm="Creating micro-plans")
TaskCreate(subject="Setup git worktree (optional)", activeForm="Setting up worktree")
TaskCreate(subject="Implement backend", activeForm="Implementing backend")
TaskCreate(subject="Implement frontend", activeForm="Implementing frontend")
TaskCreate(subject="Write tests", activeForm="Writing tests")
TaskCreate(subject="Integration verification", activeForm="Verifying integration")
TaskCreate(subject="Scope creep check", activeForm="Checking for scope creep")
TaskCreate(subject="Post-implementation reflection", activeForm="Reflecting on implementation")

# 3. Update status as you progress
TaskUpdate(taskId="2", status="in_progress")  # When starting
TaskUpdate(taskId="2", status="completed")    # When done

Workflow Overview

Phase 1: Discovery & Planning

1a. Create Task List

Break into small, deliverable, testable tasks:

• Each task completable in one focused session
• Each task MUST include its tests
• Group by domain (frontend, backend, AI, shared)

1b. Research Current Best Practices

# PARALLEL - Web searches (launch all in ONE message)
WebSearch("React 19 best practices 2026")
WebSearch("FastAPI async patterns 2026")
WebSearch("TypeScript 5.x strict mode 2026")

1c. Context7 Documentation

# PARALLEL - Library docs (launch all in ONE message)
mcp__context7__query_docs(libraryId="/vercel/next.js", query="app router")
mcp__context7__query_docs(libraryId="/tiangolo/fastapi", query="dependencies")

Phase 2: Micro-Planning Per Task

Goal: Create detailed mini-plans for each task BEFORE implementation.

For each task, create scope boundaries, file list, and acceptance criteria.

See Micro-Planning Guide for template.

Phase 3: Git Worktree Isolation (Optional)

Goal: Isolate feature work in a dedicated worktree for large features (5+ files).

See Worktree Workflow for setup and cleanup commands.

Phase 4: Parallel Architecture Design (5 Agents)

Launch ALL 5 agents in ONE Task message with run_in_background: true:

Launch all 5 agents with run_in_background=True. Each agent returns a SUMMARY line.

In Agent Teams mode, form a persistent team with teammates messaging each other. See Agent Teams Phases for spawn templates.

Phase 5: Parallel Implementation (5 Agents)

With 128K output tokens, each agent produces complete artifacts in a single pass — no need to split backend into API + DB or frontend into components + state.

In Agent Teams mode, teammates transition from architecture to implementation with real-time contract messaging. See Agent Teams Phases for messaging patterns and worktree setup.

Phase 6: Integration & Validation (4 Agents)

In Agent Teams mode, code-reviewer already has cumulative context. See Agent Teams Phases for integration and Team Teardown for shutdown + worktree merge.

Phase 7: Scope Creep Detection

Goal: Compare implementation against original scope (0-10 score).

Launch workflow-architect to compare planned vs actual files/features.

See Scope Creep Detection for agent prompt.

Phase 8: E2E Verification

If UI changes, verify with agent-browser:

agent-browser open http://localhost:5173
agent-browser wait --load networkidle
agent-browser snapshot -i
agent-browser screenshot /tmp/feature.png
agent-browser close

Phase 9: Documentation

Save implementation decisions to mem0 for future reference:

python3 ${CLAUDE_PLUGIN_ROOT}/src/skills/mem0-memory/scripts/crud/add-memory.py \
  --text "Implementation decisions..." \
  --user-id "project-decisions" \
  --metadata '{"scope":"project-decisions","category":"implementation"}'

Phase 10: Post-Implementation Reflection

Goal: Capture lessons learned while context is fresh.

Launch workflow-architect to evaluate:

• What went well / what to improve
• Estimation accuracy (actual vs planned)
• Reusable patterns to extract
• Technical debt created
• Knowledge gaps discovered

Store lessons in memory for future implementations.

Continuous Feedback Loop (NEW)

Throughout implementation, maintain a feedback loop:

After Each Task Completion

# Quick checkpoint after each task
print(f"""
TASK CHECKPOINT: {task_name}
- Completed: {what_was_done}
- Tests: {pass/fail}
- Time: {actual} vs {estimated}
- Blockers: {any issues}
- Scope changes: {any deviations}
""")

# Update task status
TaskUpdate(taskId=task_id, status="completed")

Feedback Triggers

CC 2.1.30+ Enhancements

Task metrics, tool usage guidance, and session resume hints. See CC Enhancements for details.

Summary

Total Parallel Agents: 14 across 3 phases (was 17 with 64K output)

Tools Used:

• context7 MCP (library documentation)
• mem0 MCP (decision persistence)
• agent-browser CLI (E2E verification)

Key Principles:

• Tests are NOT optional
• Parallel when independent (use run_in_background: true)
• CC 2.1.6 auto-loads skills from agent frontmatter
• Evidence-based completion
• Micro-plan before implementing
• Detect and address scope creep
• Reflect and capture lessons learned

Related Skills

• explore: Explore codebase before implementing
• verify: Verify implementations work correctly
• worktree-coordination: Git worktree management patterns

References

• Agent Phases
• Agent Teams Phases
• Orchestration Modes
• CC Enhancements
• Agent Teams Full-Stack Pipeline
• Team Worktree Setup
• Micro-Planning Guide
• Scope Creep Detection
• Worktree Workflow