Implement Spec

Implement Spec

Orchestrate implementation of spec-workflow tasks using intelligent agent coordination, parallel execution, and quality gates.

When to Activate

• User wants to implement spec-workflow tasks
• Spec documents exist in .spec-workflow/specs/
• User asks to "execute the spec" or "implement spec tasks"
• Coordinated multi-agent task execution is needed

Inputs

Parse from request:

• spec-name: Name of the spec to implement from .spec-workflow/specs/
• --task: Specific task ID to implement (optional, defaults to next pending)
• --parallel: Enable parallel execution of independent tasks
• --dry-run: Preview the orchestration plan without executing
• --quality-gates: Enable quality checks between phases (default: true)

Quick Process

1. Load Spec Context: Retrieve requirements, design, and tasks from spec-workflow
2. Task Analysis: Decompose tasks and identify dependencies
3. Agent Selection: Match tasks to specialized agents based on capabilities
4. Execution Orchestration: Coordinate parallel/sequential execution
5. Quality Assurance: Validate outputs and ensure consistency

Orchestration Strategy

Phase 1: Context & Planning

1. Spec Loading:

   • Use mcp__spec-workflow__get-spec-context to load spec documents
   • Use mcp__spec-workflow__manage-tasks to get task status
   • Identify pending tasks and dependencies

2. Dependency Analysis:

   • Map task dependencies from the tasks.md structure
   • Identify parallel execution opportunities
   • Determine critical path for sequential tasks

Phase 2: Agent Orchestration

If agent-orchestrator-agent is available (from development-codebase-tools plugin):

Invoke it with comprehensive context including:

• Loaded specs and pending tasks
• Task dependencies
• Execution strategy (parallel vs sequential)

The orchestrator will:

• Discover all available agents
• Match tasks to agents by capability
• Coordinate specialized agents for each task
• Handle parallel execution groups

Fallback (if agent-orchestrator-agent is not available):

Execute tasks sequentially without orchestration:

1. Process tasks in dependency order from tasks.md
2. For each task, directly invoke the most appropriate available agent
3. Pass task context and previous results to each agent
4. Continue until all tasks are complete or a blocker is encountered

Phase 3: Task Execution

Each list below is a menu of agents that fit that task type, not a team to staff in full. Pick only the ones the task actually needs, and do the work directly rather than spawning an agent when it would finish in a handful of tool calls. Ceiling: at most 4 concurrent agents at any moment - a ceiling, not a quota.

For each task, coordinate:

1. Code Implementation Tasks: code-generator-agent, test-writer-agent, documentation-agent
2. Refactoring Tasks: refactorer-agent, style-enforcer-agent, agent-tester-agent
3. Infrastructure Tasks: infrastructure-agent, cicd-agent
4. Migration Tasks: migration-assistant-agent, agent-tester-agent

Phase 4: Quality Gates

Between task groups, apply the quality checks the changes actually call for:

• Code Quality: style-enforcer-agent, security-analyzer-agent, performance-analyzer-agent
• Test Coverage: agent-tester-agent, test-writer-agent
• Documentation: documentation-agent

Prefer running the project's own test, lint, and typecheck commands over spawning an agent to judge quality - a tool result is evidence, an agent's opinion of code it just read is not.

Output Format

Return structured results, under roughly 400 words:

• Summary: spec name, tasks completed/remaining
• Execution Plan: phases, tasks, agents, execution type
• Results: per-task status, agent used, and the observed result of any test/lint/typecheck run (quote the command output; do not report a score or metric you did not measure)
• Next Steps: remaining tasks, blockers, recommendations

Examples

"Implement the user-authentication spec"
"Execute spec tasks for payment-integration"
"Run the api-refactor spec with parallel execution"
"Implement spec migration-plan --dry-run"

Delegation

Primary: Invokes agent-orchestrator-agent (from development-codebase-tools plugin) with spec context, task dependencies, and execution configuration.

Fallback: If agent-orchestrator-agent is unavailable, executes tasks sequentially using direct agent invocations based on task type.