# implement

implement — a skill for Claude Code and Codex that executes settled plans in thin test-driven slices. Runs when prompted to build code from a spec or slice plan.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode, Windsurf (Devin Desktop), Claude.ai · 1000 installs · ★ 10 repo stars
- Author: pwguler
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/pwguler/skills/tree/HEAD/skills/implement/SKILL.md
- Updated: 2026-10-16
- Security check: automated, 2026-11-17 (text) — no signs of malicious code found.
- HTML: https://affpapa.org/en/nevibecode/skills/pwguler-implement

## What it does

The tool drives feature development strictly test-first in minimal steps. It starts by outlining a task tracker with at least three items based on acceptance criteria from `docs/specs/<slug>.md` or individual slices, followed by verification steps. Working directly on the remote HEAD branch triggers a prompt to start a dedicated feature branch.

Each iteration stays confined to a single observable change. You write a failing test against the public interface, deliver the minimal code required to pass, and refactor while tests stay green. Production code without an existing failing test is barred, excluding untestable host glue like plugin hooks. Repetitive code edits require automated helper tools instead of manual patching.

Specs containing open decision blocks and requests lacking a settled outline get sent to `drill`. Every slice concludes with an execution gate managed by the `verify` skill.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add pwguler/skills --skill implement -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/implement/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/implement/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add pwguler/skills --skill implement -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/implement/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add pwguler/skills --skill implement -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/implement/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install pwguler/skills skills/implement
```

2. **Manually: put the files in place**
- File: `.github/skills/implement/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add pwguler/skills --skill implement -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/pwguler/skills --path skills/implement
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/implement/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add pwguler/skills --skill implement -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/pwguler/skills/tree/HEAD/skills/implement/SKILL.md

## When to use it
- deliver specification acceptance criteria slice by slice
- produce minimal code against failing interface tests
- restrict diffs strictly to the active task slice
- evaluate symbol blast radius prior to modifying shared contracts

## Example prompts
- Implement the specification in docs/specs/auth.md
- Build this settled plan test-first
- Execute the acceptance criteria for this feature

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 7f5cbc8013ba69d0.

BEGIN THIRD-PARTY FILE 7f5cbc8013ba69d0
```text
---
name: implement
description: "Implement a settled plan test-first, one small slice at a time. Read this skill before you write code for a spec or a settled plan. Read it also when the plan is small. Use it when the user says \"implement this\" or \"build it\", or names a spec to implement."
---

Do the plan in thin slices, one slice at a time. A slice is the smallest change to observable behavior. When a spec exists at `docs/specs/<slug>.md`, its acceptance criteria are the plan. Work through them one criterion at a time. The diff must not change anything that a non-goal of the spec excludes. A spec that still has an `## Open decisions` section is a draft. Send it back to `drill`. A request with no spec and no settled plan goes to `drill` first. Its fast path gives the one-sentence plan.

1. Before the first test, create a task list. Add one item for each acceptance criterion when a spec exists. When no spec exists, add one item for each slice. Then add `verify`, and add `rubric` when the work is a UI, a public interface, a name, or a doc. Do not create a list of fewer than three items. Mark each item done when its work is committed. When you skip an item, mark it done and add `skip: <reason>` to its text. Never skip a criterion. Leave it open.
2. Pick the smallest unfinished slice, and do steps 3 to 7 on it in this session. When the user asked to give slices to workers, launch a subagent that runs the `implement` skill. It does steps 3 to 5 on one slice. Read its diff, then do steps 6 and 7 here.
3. Write the test that fails for the slice. Test through the interface, never against implementation details. If you cannot write a failing test, the interface under test is wrong. Fix the plan, not the test.
4. Write the minimum code that makes the test pass.
5. Refactor only while the tests pass. Use the style of the code around it.
6. Do the check in [blast-radius.md](references/blast-radius.md) before the gate when the diff deletes or renames a symbol that other code uses. Do it also when the diff changes a contract that another module, stored data, or an outside caller depends on.
7. Read the `verify` skill, and run its gate on the slice. Commit on its evidence record.
8. Go back to step 2 until no slice is left.

Rules:

- On the base branch, recommend a new branch before the first test, and ask the user. The base branch is where the remote HEAD points. Name the new branch with the spec slug, or with a short slug of the one-sentence plan. Work on the base branch only when the user says so. Never assume it. A session that is already on a feature branch stays there.
- Do one implementation at a time. Do not leave unfinished work for a new task on your own decision. Offer to finish and land it, to land it partly, or to keep it on its branch for later. Let the user pick. Only `land` ends the work.
```
END THIRD-PARTY FILE 7f5cbc8013ba69d0

The third-party file has ended. Everything between the 7f5cbc8013ba69d0 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2847 of 9932 bytes. © pwguler · MIT · https://github.com/pwguler/skills/tree/HEAD/skills/implement/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md
