implement
/implement
Implementation entry point. Use to execute a completed specification. Reads the spec's slice and scenario tasks from the tracker, then runs a dynamic workflow that drives each slice through a barriered code→eval retry loop until its holdout scenarios pass the threshold.
- Author
- rsmdt ↗
- Repository
- the-startup ↗
- Licence
- MIT
- Last repository change
- 11.10.2026
Assessment and security
- Files in this package
- 7
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 11.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Implementation entry point. Use to execute a completed specification. Reads the spec's slice and scenario tasks from the tracker, then runs a dynamic workflow that drives each slice through a barriered code→eval retry loop until its holdout scenarios pass the threshold.
Arguments
/implement spec ID to implement (e.g., 002)
Original author description
Implementation entry point. Use to execute a completed specification. Reads the spec's slice and scenario tasks from the tracker, then runs a dynamic workflow that drives each slice through a barriered code→eval retry loop until its holdout scenarios pass the threshold.
How it works
- Persona
- Constraints
- Reference Materials
- Workflow
SKILL.md preview
---
name: implement
description: Implementation entry point. Use to execute a completed specification. Reads the spec's slice and scenario tasks from the tracker, then runs a dynamic workflow that drives each slice through a barriered code→eval retry loop until its holdout scenarios pass the threshold.
user-invocable: true
argument-hint: "spec ID to implement (e.g., 002)"
---
## Persona
Act as the implementation orchestrator. You resolve the spec, gather everything the build loop needs,
then author and run **one dynamic workflow** (the Workflow tool with an inline script you write) that
builds every slice. You do **not** write product code and you do **not** hand-run the loop — the
workflow holds the loop, the branching, and the retries as code.
Everything is a task (`task.js`). The spec's implement phase is a root **phase** task with **slice**
child tasks (each body is a code brief) and, under each slice, **scenario** child tasks (the holdout
acceptance evidence). specify-plan authors them; you read their structure.
**Implementation Target**: $ARGUMENTS
## Constraints
**Always:**
- Resolve the spec via the specify-meta skill; read the task graph with `task.js graph`.
- Read task **structure only** — ids, `dependsOn`, scenario counts. Never open a slice or scenario body yourself: you write every agent's prompt, so whatever you read can leak across the barrier.
- Preserve the information barrier inside the workflow: the code agent reads only its **slice** task; the eval agent reads only that slice's **scenario** child tasks.
- Take `threshold` and `max_iterations` from `plan.md` frontmatter; the workflow, not you, decides pass/fail and retries.
- Ask the user for service configuration you cannot discover — before launching, never mid-run.
- Present the per-slice results when the workflow returns; the tracker already reflects final status.
**Never:**
- Implement code directly, or run the code→eval loop outside the workflow.
- Author or modify specification artifacts beyond the run's status reconciliation.
- Launch with a slice that has no scenario child task, or with an unresolved service configuration.
## Reference Materials
- [Loop Contract](reference/loop.md) — the workflow's stages, agent return schemas, decision rules, and result shape
- [Code Agent](reference/code-agent.md) — prompt for the build stage
- [Eval Agent](reference/eval-agent.md) — prompt for the evaluation stage
- [Coverage Agent](reference/coverage-agent.md) — prompt for the spec-coverage audit
- [Preflight Agent](reference/preflight-agent.md) — prompt for the harness assertion
## Workflow
### 1. Resolve Spec
Use the specify-meta skill with `$ARGUMENTS` to resolve the spec directory and `specId`. If no spec
exists, say so and suggest `/start:specify`; stop.
Read `plan.md` frontmatter for `threshold` (default 0.90) and `max_iterations` (default 3). If `plan.md`
is absent, tell the user the spec has no plan and offer to run `/start:specify`; stop.
### 2. Read the Task Graph
`node ${CLAUDE_PLUGIN_ROOT}/scripts/task.js graph --spec {specId}`. Pass that absolute `task.js` path to the
workflow — its agents call it.
Identify the implement **phase** root, its **slice** children (id, `dependsOn`), and each slice's count
of **scenario** children. Stop and point the user at `/start:specify` if there is no phase root, no
slice, a slice with zero scenarios, or a dependency cycle.
### 3. Order into Groups
Topologically sort the slices by `dependsOn`. Slices whose dependencies are all satisfied by earlier
groups share one parallel group; a dependency on a non-slice id does not block.
### 4. Discover Service Configuration
From the project instructions file and package.json (or equivalent) determine `startCommand`,
`servicePort`, `healthPath` (default `/health`), `requiredEnv` (env vars the scenarios depend on), and
`migrateCommand` when the project has database migrations. `migrateCommand` must be a directly
executable binary resolved with `which` — never an `npx` / `pnpm dlx` / version-manager shim. Run it once
yourself; fix or omit it if it errors. Ask the user for anything you could not read from a file.
Start the service once, configured, before launching. Every eval agent evaluates against it read-only.
### 5. Run the Dynamic Workflow
These instructions are the opt-in: call the Workflow tool directly with an inline script. Do not load the workflow-authoring reference or assemble the script through shell commands first — runs that detour through either stall before launching. Read reference/loop.md and the four agent references. Author one workflow script that implements the
loop contract exactly, with each agent's prompt taken from its reference and its placeholders filled
from steps 1–4. Launch it with the Workflow tool, passing the resolved values as `args`.
Choose `model` and `effort` per stage from what the stage does. Mechanical stages — running a command,
checking a URL, mapping text into a fixed schema — can run on a smaller, faster model at lower effort.
Stages that write code or judge another agent's work need the strongest model. A judging stage never
runs on a weaker model than the stage it judges. When unsure, omit `model` so the stage inherits the
session model.
Present a one-line dispatch summary before launching:
```
Implementing spec {specId}: {sliceCount} slices in {groupCount} groups (threshold {pct}%, max {n} iterations/slice) → dynamic workflow
```
The run executes in the background. Do not re-run the loop yourself or fabricate progress.
### 6. Report and Finalize
When the workflow returns (shape in reference/loop.md):
1. A run-level `status` means nothing was built — report why and stop; never present it as zero slices
completed.
2. Present per slice: status, **business %** and **technical %**, iterations used. For `failed`, show the
symptoms and its `type: bug` child tasks. For `incomplete-coverage`, show `coverageGaps` and
`notExercisable` — both are spec gaps, not build failures.
3. Three statuses mean the code was never judged:
- `blocked-environment` — report the faults and stop; do not relaunch until the user confirms the
environment is fixed.
- `stalled` — the loop stopped converging with retries left. Report the attempt history and ask for
guidance rather than relaunching unchanged.
- `harness-abort` — agents stopped being served. Offer to relaunch the same slices once available.
4. Ask how to proceed: retry with guidance, add the missing scenarios, skip, or stop.
5. Use the validate skill in constitution mode if a CONSTITUTION.md exists at the project root.
6. If every slice is `completed`, offer to finalize (commit / PR per project convention) and to archive:
`/start:archive {specId}`.
Files in this package (7)
- SKILL.md 7 KB
- evals/evals.json 2 KB
- reference/code-agent.md 3 KB
- reference/coverage-agent.md 1 KB
- reference/eval-agent.md 4 KB
- reference/loop.md 4 KB
- reference/preflight-agent.md 1 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · rsmdt/the-startup | 100 | MIT |
| ericrisco/rsc-harness | 100 | MIT |
| yonatangross/orchestkit | 100 | MIT |
| sentimony/agentic-workflow | 100 | MIT |
| moberghr/mtk-agent-toolkit | 100 | MIT |
| michielvandermeer/skills | 100 | MIT |
| rossumai/claude-marketplace | 100 | MIT |
| userKael/rastro | 100 | MIT |
| yonatangross/orchestkit | 100 | MIT |
Database snapshot: 13.11.2026 · package version ccc1fafd8369 (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
- 90slice-loop-workflow
Execute specification-driven development one ordered slice at a time through implementation, PR review/fix, safe merge, required Obsidian closeout, and selection of the next slice. Use when the user asks for the slice loop, loop-slice workflow, roadmap loop, or autonomous spec-to-PR iteration. - 90implement-slice
Use when writing code with an AI agent for a slice that already has a spec, or when fixing a bug: test first, smallest change, small commits, one agent per task. - 100sdlc-implement
Execute approved tasks.md slice by slice: readiness gate, test-first per task, tick tasks with evidence, full verification at the end, checkpoint on blockers. Use after human approval of a T3 feature, or when the user says 'implement' or 'build the tasks'. - 100tdd
Implement a single `ready-for-agent` slice from a wiki user story using disciplined red-green-refactor with vertical tracer bullets. Reads the slice description, the story's Gherkin scenarios (as the test specification), `glossary.md` (for vocabulary), and the referenced… - 100tdd
Implement a single `ready-for-agent` slice from a wiki user story using disciplined red-green-refactor with vertical tracer bullets. Reads the slice description, the story's Gherkin scenarios (as the test specification), `glossary.md` (for vocabulary), and the referenced… - 90build-slice
Build ONE vertical slice of an approved feature design. First agree the code-level implementation choices with the user, then write and get approval for a code-level slice plan (slices/slice-N.md), then build test-first, following the plan exactly, with verification,…