Skip to main content
skill CX Codex

implement · rsmdt — Claude Code skill that runs a spec through a code→eval loop

An implementation orchestrator that reads slice and scenario tasks from the spec tracker, then launches a workflow which builds each slice and retries code→eval until holdout scenarios pass.

MIT ★ 587 updated 2026-10-26

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rsmdt/the-startup
/plugin install start@the-startup
Open on GitHub

What implement does

The implement skill handles execution of a finished specification. It does not write product code itself. Instead it resolves the spec, reads the task graph, discovers service configuration, and launches one dynamic workflow. That workflow owns the loop: build a slice, evaluate it, retry if holdout scenarios fail the threshold.

Every plan phase is a root task with slice children, and each slice carries scenario children as acceptance evidence. The skill reads structure only — ids, dependencies, scenario counts. Slice and scenario bodies stay unread, so nothing leaks across the barrier: the code agent sees only its slice, the eval agent only that slice's scenarios.

Threshold and iteration count come from the plan doc's frontmatter. Defaults are 0.90 and 3. The service starts once before launch, configured, and every eval runs read-only against it. Holdout scripts and screenshots go to an eval directory outside the project, out of the code agents' reach.

The skill refuses to launch if a slice has no scenario child or service configuration is unresolved. It asks for configuration before launching, never mid-run. No spec or no plan means it stops and points to /start:specify.

What it helps with

  • build every slice of each phase from a finished spec
  • run a code→eval loop with automatic retries
  • keep an information barrier between code and eval agents
  • start a service once and evaluate scenarios read-only
  • record per-slice results in the tracker

Example prompts for the agent

  • Implement spec 002
  • Run the build for spec 002 with threshold 0.90 and up to 3 iterations per slice
  • Start the dynamic workflow for spec 002 and show the slice results when it returns

How to install implement

1Plugin marketplace

/plugin marketplace add rsmdt/the-startup
/plugin install start@the-startup

This installs the whole start plugin with all its skills

2Skills CLI (Vercel)

npx skills add rsmdt/the-startup --skill implement -a claude-code

3Manually: put the files in place

~/.claude/skills/implement/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/implement/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about implement

How do I install the implement skill in Claude Code?

Through the marketplace: /plugin marketplace add rsmdt/the-startup, then /plugin install start@the-startup. Or run npx skills add rsmdt/the-startup --skill implement -a claude-code, which puts the skill at ~/.claude/skills/implement/SKILL.md.

What does the implement skill do?

It launches implementation of a completed spec: reads slices and scenarios from the tracker, resolves service configuration, and starts a workflow that builds each slice and runs a code→eval retry loop until holdout scenarios meet the threshold.

What do I need before running it?

A spec with a plan doc whose frontmatter has threshold and max_iterations. Service details should live in project instructions or package.json: startCommand, servicePort, healthPath, requiredEnv. If there are database migrations, migrateCommand must be a binary resolvable by which, not an npx or version-manager shim.

Source text

SKILL.md · MIT
---
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 builds each phase's slices and evaluates the phase through a barriered code→eval retry loop until every slice's 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`). Each plan 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 the frontmatter of the spec's `plan_doc` (`spec.md`; `plan.md` in a legacy spec); the workflow, not you, decides pass/fail and retries.
- Ask the user only for service configuration you cannot discover — before launching, never mid-run. Never ask to confirm what you read from a file.
- 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
- [Service Agent](reference/service-agent.md) — prompt for restarting the service before each evaluation

## 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 the `plan_doc` frontmatter for `threshold` (default 0.90) and `max_iterations` (default 3). If the
spec has no `plan_doc`, 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 **phase** roots (id, `dependsOn`), each phase's **slice** children (id, `dependsOn`,
status), and each slice's count of **scenario** children. Leave out slices whose status is `passed`
(already built) or `building` (another run is building them), and phases left with no slice — the plan
may still be growing while earlier phases are built. Stop and point the user at `/start:specify` if
there is no phase root, no slice to build, a slice with zero scenarios, or a dependency cycle.

### 3. Order into Phases and Groups

Order the phases by their `dependsOn`. Within each phase, topologically sort its slices by `dependsOn`:
slices whose dependencies are all satisfied by earlier groups share one parallel group; a dependency on
a slice of an earlier phase, or 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.

Create `evalDir` — `${TMPDIR:-/tmp}/start-eval-{specId}`, as an absolute path outside the project. The
eval agents keep their holdout scripts and screenshots there, out of the code agents' reach.

### 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 five 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.
Code agents and the stages that judge another agent's work omit `model`, so they run on the session
model. When unsure, omit `model`.

Record the launch: `node ${CLAUDE_PLUGIN_ROOT}/scripts/spec.js {specId} --event '{"kind":"run","state":"started","threshold":<threshold>,"maxIterations":<max_iterations>}'`.

Present a one-line dispatch summary before launching:

```
Implementing spec {specId}: {sliceCount} slices in {phaseCount} phases (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), record one `result` event per slice result
(`{"kind":"result","id":"<sliceId>","result":"<status>","business":<n>,"technical":<n>,"iterations":<n>}`,
leaving out a score the slice never got), then `{"kind":"run","state":"ended"}`, with
`node ${CLAUDE_PLUGIN_ROOT}/scripts/spec.js {specId} --event`.

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.
   An `incomplete-coverage` slice cleared both thresholds: it is built. Record its gaps as known gaps in
   the Ledger part of `spec.md` and do not relaunch it. Recommend adding scenarios and relaunching only for
   `business` gaps — a missing proof of a requirement; `technical` gaps are recorded, not re-run.
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. Only when a slice is not built (`failed`, `stalled`, `blocked-environment`, `harness-abort`), ask how to
   proceed: retry with guidance, add the missing scenarios, skip, or stop. Recorded gaps and `bug` tasks of
   a built slice are not open work: list them without offering a re-run.
5. Use the validate skill in constitution mode if a CONSTITUTION.md exists at the project root.
6. If every slice is `completed`, say so and name the next commands — commit per project convention and
   `/start:archive {specId}` — without asking; git and archiving stay the user's call.

© Rudolf S. · MIT · rsmdt/the-startup

Similar skills

All skills for Agent setup: memory, context, orchestration →

implement by other authors comes first.

implement Matt Pocock Implements work from a specification or tickets, following a test-driven flow and ending with review and a commit. Use it when a coding task needs a defined delivery routine. CX Codex +1 774,700installs implement boshu2 Applies a requested code change and checks it with the repository’s own commands. It activates for bug fixes, changes, or new implementation work. CX Codex +1 1,500installs implement Garrick Aden-Buie (@gadenbuie) implement coordinates the rollout of a plan file by splitting work across parallel subagents. It checks git branch status and monitors progress. CX Codex +1 572installs implement hyperb1iss This skill for Claude Code guides coding, feature work, bug fixes, and refactoring. It activates on requests to start implementation or change a project. CX Codex +1 577installs implement sentimony The implement Claude Code skill works through plan tasks in sequence and records its progress. It runs to resume interrupted work or handle small edits without a plan. CX Codex +1 1,900installs om-auto-implement-spec open-mercato om-auto-implement-spec turns an existing spec into a code-reviewed, UI-verified, ready PR. You pass a spec reference — a path, name, issue, or spec-PR number — and get back a finished pull request. CX Codex +1 4,300installs ns-spec-driven nextstage-brasil ns-spec-driven is a Claude Code skill that drives feature delivery through formal specifications. It triggers on medium or large tasks, multi-day work, or when resuming a version from docs/versions/. CX Codex +1 208installs spec-driven habib0x spec-driven turns a feature idea into requirements, design and tasks, then lets the agent build them. CX Codex ★ 1,596repo stars specclaw chan4lk specclaw runs a change through propose, plan, build, verify and pr. Leaves a short paper trail inside your repo. ★ 14repo stars tlc-implement Tech Leads Club - github.com/tech-leads-club tlc-implement takes an approved plan or small ticket and turns it into working code by freezing checks, building, and running an independent Verifier before declaring done. CX Codex +1 ★ 7,191repo stars agent-task-splitter WenyuChiou agent-task-splitter is a Claude Code skill that plans work for multiple subagents or delegated executors. It assigns roles, file boundaries, and checks before they start. CX Codex +1 ★ 34repo stars

From the same set50

The whole set →
the-chief the-chief — a subagent that scores task complexity, maps dependencies, and routes work to maximize parallel execution. Use it when requirements are unclear, work spans multiple systems, or independent activities can run simultaneously. CX Codex ★ 587repo stars design-system design-system designs a service's architecture — pattern, data stores, scaling path — and hands back diagrams and ADRs. Useful when you're deciding whether to split a monolith. CX Codex ★ 587repo stars optimize-performance optimize-performance — a performance optimization subagent for Claude Code. Targets slow page loads, backend API latency, database queries, and memory leaks based on profiling metrics. CX Codex ★ 587repo stars archive Turns a finished specification into a compact file in .start/archive/ and removes its working folder. Run it after implementation to clear completed work from .start/specs/. CX Codex +1 ★ 587repo stars debug debug diagnoses software failures using a scientific method, strict hypothesis tracking, and root cause verification. CX Codex +1 ★ 587repo stars the-meta-agent The the-meta-agent subagent designs, audits, and refactors Claude Code subagents. Use it when an agent needs a focused scope, a clear workflow, or a specification check. CX Codex ★ 587repo stars improve improve finds modules with bloated interfaces and proposes refactors that turn them into deep ones — testable and easy for an agent to navigate. CX Codex +1 ★ 587repo stars specify-solution The specify-solution skill for Claude Code drafts and validates technical solution designs in spec.md based on product requirements. CX Codex +1 ★ 587repo stars

Project sponsors

Companies that keep this analytics open