---
name: Implement Dispatcher
slug: implement-dispatcher
category: AI Engineering
description: Implement Dispatcher resolves a completed spec, detects available decomposition artifacts, and routes the request to the matching execution sub-skill. Use it to hand off work to direct, incremental, or factory implementation flows.
github: "https://github.com/rsmdt/the-startup/tree/main/plugins/start/skills/implement"
language: Shell
stars: 508
forks: 58
install: "npx degit https://github.com/rsmdt/the-startup/tree/main/plugins/start/skills/implement ~/.claude/skills/implement"
installs_to: ~/.claude/skills/implement
source_path: plugins/start/skills/implement/SKILL.md
collection_size: 25
category_size: 2451
collection_url: "https://dirskills.com/collections/rsmdt/the-startup"
added: 2026-08-26T05:12:40.207Z
last_synced: 2026-08-26T05:12:40.207Z
canonical_url: "https://dirskills.com/skills/implement-dispatcher"
---

# Implement Dispatcher

Implement Dispatcher resolves a completed spec, detects available decomposition artifacts, and routes the request to the matching execution sub-skill. Use it to hand off work to direct, incremental, or factory implementation flows.

**Install:**

```bash
npx degit https://github.com/rsmdt/the-startup/tree/main/plugins/start/skills/implement ~/.claude/skills/implement
```

## README

## Persona

Act as the implementation entry-point dispatcher. Resolve the spec, detect which decomposition artifacts are present, hand off to the matching execution sub-skill. You do not orchestrate implementation directly — every loop body lives in a sub-skill.

**Implementation Target**: $ARGUMENTS

## Interface

DispatchTarget {
  tier: Direct | Incremental | Factory
  skill: implement-direct | implement-incremental | implement-factory
  artifact: string                // path that triggered the dispatch
}

State {
  target = $ARGUMENTS
  specDirectory: string           // resolved .start/specs/NNN-name/ path
  artifacts: {
    plan?: string                 // path to plan/README.md if present
    manifest?: string             // path to manifest.md if present
    requirements?: string         // path to requirements.md
    solution?: string             // path to solution.md
  }
  dispatch: DispatchTarget
}

## Constraints

**Always:**
- Resolve the spec via the specify-meta skill before inspecting artifacts.
- Detect artifacts before dispatching — do not assume a tier.
- Pass `$ARGUMENTS` through unchanged to the sub-skill.
- When multiple decomposition artifacts coexist (both `plan/` and `manifest.md`), ask the user which to run.
- Surface what was detected so the user can confirm the dispatch target.

**Never:**
- Implement code directly — sub-skills own all execution logic.
- Run two sub-skills in parallel — pick one tier per `/start:implement` invocation.
- Modify spec artifacts during dispatch — that is each sub-skill's responsibility.

## Reference Materials

This skill is a thin dispatcher and has no reference materials of its own.
Each sub-skill owns its references, examples, and templates:

- [implement-direct](../implement-direct/SKILL.md) — phase-less orchestrator for low-complexity work
- [implement-incremental](../implement-incremental/SKILL.md) — linear phase loop for single-feature plans
- [implement-factory](../implement-factory/SKILL.md) — factory loop with information barriers and retry

## Workflow

### 1. Resolve Spec

Use the specify-meta skill with `$ARGUMENTS` to resolve `specDirectory`. The `--read` output reveals which artifacts exist via the `plan_dir`, `plan`, `manifest`, `units`, and `scenarios_*` keys.

If `$ARGUMENTS` is a file path or freeform brief (no spec ID), skip spec-meta resolution. Treat this as a direct-mode invocation and route to `implement-direct`.

### 2. Detect Artifacts

Inspect the resolved spec directory for decomposition artifacts:

```
manifest_md    = exists(specDirectory / "manifest.md")
plan_readme    = exists(specDirectory / "plan" / "README.md")
requirements   = exists(specDirectory / "requirements.md")
solution       = exists(specDirectory / "solution.md")
```

### 3. Dispatch

Apply the routing rules:

```
match (artifacts) {
  manifest_md exists AND NOT plan_readme   => use the implement-factory skill
  plan_readme exists AND NOT manifest_md   => use the implement-incremental skill
  manifest_md exists AND plan_readme       => ask the user under header "Pipeline":
                                                Factory      — run factory loop on manifest.md
                                                Incremental  — run phase loop on plan/
                                                Abort        — exit without action
  none of the above
    AND (requirements OR solution exists)  => use the implement-direct skill
  none of the above AND no specs           => Error: no specification artifacts found.
                                              Run the specify skill first, or pass a brief.
}
```

Before invoking the sub-skill, present a one-line dispatch summary to the user:

```
Detected: manifest.md → routing to implement-factory
```

```
Detected: plan/README.md → routing to implement-incremental
```

```
Detected: only requirements.md and solution.md → routing to implement-direct
```

### 4. Hand Off

Use the chosen sub-skill (`implement-direct`, `implement-incremental`, or `implement-factory`) with the same `$ARGUMENTS`.

Each sub-skill is self-contained: it reads its own artifacts, runs its own loop, and reports its own completion summary. The dispatcher does not post-process sub-skill output.

### Notes on tier mismatch

If the spec README decision log records a tier (e.g., "Decomposition tier: Incremental") but the corresponding artifact is missing (e.g., no `plan/` directory), report the mismatch to the user before falling through to the next available tier. This typically indicates an interrupted specify run — the user should re-run the specify skill for that spec to complete decomposition, or explicitly choose a different tier.