// Implementation entry point. Use to execute a completed specification. Auto-detects the decomposition tier (Direct, Incremental, or Factory) from spec artifacts and dispatches to the matching execution sub-skill.
Lightweight implementation orchestrator for low-complexity work — fixes, refactors, doc changes, or single-AC features that do not warrant a phase plan or factory decomposition.
Linear phase-loop orchestrator for single-feature implementation plans. Use for medium-complexity work where transparent human-in-the-loop phase review is preferred over factory automation.
Decompose a single-feature specification into a linear, phase-by-phase implementation plan. Use this for medium-complexity work — single feature, one or two components — where transparent human-in-the-loop phase review is preferred over factory automation.
Scaffold, status-check, and manage specification directories. Use when creating a new spec, reading spec status, transitioning between phases, or logging decisions on a spec in .start/specs/.
Create a comprehensive specification from a brief description. Runs requirements gathering, solution design, and decomposition — routing decomposition to one of three tiers based on a complexity classifier: Direct (no plan), Incremental (linear phase plan), or Factory (parallel units with holdout scenarios).
Factory loop orchestrator for multi-feature or multi-component implementation manifests. Use for high-complexity work with parallel-eligible workstreams and holdout-scenario evaluation.
| name | implement |
| description | Implementation entry point. Use to execute a completed specification. Auto-detects the decomposition tier (Direct, Incremental, or Factory) from spec artifacts and dispatches to the matching execution sub-skill. |
| user-invocable | true |
| argument-hint | spec ID to implement (e.g., 002), or file path |
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
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 }
Always:
$ARGUMENTS through unchanged to the sub-skill.plan/ and manifest.md), ask the user which to run.Never:
/start:implement invocation.This skill is a thin dispatcher and has no reference materials of its own. Each sub-skill owns its references, examples, and templates:
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.
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")
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
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.
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.