Skip to content
Skills Library
AI & agents · Automation

implement-spec

/implement-spec

Orchestrate implementation of spec-workflow tasks. Use when user says "implement the spec", "execute spec tasks", "run the spec workflow", "implement spec-name tasks", or needs to coordinate agent execution for spec-workflow documents.

Repository
ai-toolkit ↗
Licence
MIT
Last repository change
23.10.2026

Assessment and security

84/ 100Class: good
Format9 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 23.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Orchestrate implementation of spec-workflow tasks. Use when user says "implement the spec", "execute spec tasks", "run the spec workflow", "implement spec-name tasks", or needs to coordinate agent execution for spec-workflow documents.

Triggers from the description

implement the specexecute spec tasksrun the spec workflowimplement spec-name tasks
Original author description

Orchestrate implementation of spec-workflow tasks. Use when user says "implement the spec", "execute spec tasks", "run the spec workflow", "implement spec-name tasks", or needs to coordinate agent execution for spec-workflow documents.

How it works

  1. When to Activate
  2. Inputs
  3. Quick Process
  4. Orchestration Strategy
  5. Output Format
  6. Examples
  7. Delegation
Original SKILL.md headings · 116 lines, 593 words
SKILL.md preview
---
description: Orchestrate implementation of spec-workflow tasks. Use when user says "implement the spec", "execute spec tasks", "run the spec workflow", "implement spec-name tasks", or needs to coordinate agent execution for spec-workflow documents.
allowed-tools: Read(*), Task(subagent_type:agent-orchestrator-agent), Task(subagent_type:*), mcp__spec-workflow__manage-tasks(*), mcp__spec-workflow__get-spec-context(*)
---

# 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.

Versions

RepositoryScoreLicence
This page · Uniswap/ai-toolkit84MIT
cravingmaker/skills100MIT
FRogora98/spec-driven100MIT
OutlineDriven/outline-driven-development100Apache-2.0
gosuda/dalcom-skills95Apache-2.0
dzhng/skills90MIT
dzhng/jevgrep90MIT
dzhng/skills90MIT
aomni-com/open-duet90MIT

Database snapshot: 13.11.2026 · package version bfa2a78017f7 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95workflow-execute
    Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking. Triggers on "workflow-execute".
  • 91create-tasks
    Generate Claude Code native Tasks from an existing spec. Use when user says "create tasks", "generate tasks from spec", "spec to tasks", "task generation", or wants to decompose a spec into implementation tasks.
  • 95Implementation
    Execute implementation tasks from task documents following TDD workflow, phase-by-phase execution, and real-time progress tracking. USE WHEN implement, execute tasks, run tasks, start implementation, build feature, execute implementation, code the feature.
  • 90implement
    Implement one phase of a feature from its AI-SPEC. Use when the user asks to implement, build or code a feature phase that already has an AI-SPEC in docs/features/<Feature>/.
  • 90implement-spec-with-codex
    Run [implement-spec](../implement-spec/SKILL.md) with Codex doing the implementation passes while you orchestrate, integrate, and review. Use when the user asks to implement a spec with Codex, or to run implement-spec with Codex as the implementer.
  • 100flow-next-spec-completion-review
    Spec completion review - verifies all spec tasks implement the spec requirements. Triggers on /flow-next:spec-completion-review.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.