Skip to main content
skill CX Codex

implement · pwguler — Claude Code skill: what it does, how to install

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.

MIT 1,000 installs ★ 10 updated 2026-10-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pwguler/skills --skill implement -a claude-code
Open on GitHub

What implement 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.

What it helps with

  • 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 for the agent

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

How to install implement

1Skills CLI (Vercel)

npx skills add pwguler/skills --skill implement -a claude-code

2Manually: 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 to install implement in Claude Code?

Run npx skills add pwguler/skills --skill implement -a claude-code. The skill file will be placed in ~/.claude/skills/implement/SKILL.md.

What does implement do?

It guides coding through strict test-first iterations. The workflow takes one acceptance criterion at a time, checks interface behavior, and commits on verified gates.

What is required for implement to run?

A settled plan or finalized spec without unresolved decisions, along with companion skills drill and verify for fast-path planning and gating.

Source text

SKILL.md · MIT
---
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.
- Write no production code before its failing test exists. The one exception is wiring whose only effect is inside a host that the tests cannot drive. Examples are a plugin entry point or a framework registration. Its proof is an end-to-end run through `verify`, never a regex or a string match over source code.
- Before the first slice that adds a module or an exported type, settle its shape with [shape first](references/shape-first.md). The sketch is one commit of `not implemented` stubs that have no behavior. So these stubs come before the failing tests that fill them.
- Before the first test of a slice, list the ways that the slice can fail. Test the likely ones and the costly ones: lost data, money, access, or a broken caller contract. Name the other ones in the commit message. Size the tests to the change. A one-line fix gets one regression test, not new test infrastructure.
- Inside a slice, run only the tests that exercise the slice, never the whole suite. The gate of the slice waits for step 7, and `verify` decides its size. Inside a phase that the spec declares, the gate follows [outcome-oriented execution](references/outcome-oriented-execution.md). A series of similar edits follows [sequence verifiable units](references/sequence-verifiable-units.md).
- Check each test with two imagined edits. When the behavior breaks, the test must fail. When only the internals change, the test must still pass. Read [test behavior, not implementation](references/test-behavior-not-implementation.md) when an assertion checks a mock, a call, or an error message. Read it also when an assertion does not plainly compare the subject's output with a literal value. A grep or a string check over source code proves nothing about behavior. A slice is not done until its tests failed on the behavior under test.
- Keep every diff to its slice. Each changed line belongs to the slice, or it removes dead code from a file that the slice changes.
- Before you add anything, ask four questions in this order. Does it need to exist? Does the standard library or the platform do it? Does a dependency that is already present do it? Can one line do it? Before you add a file, a layer, a dependency, or a parameter, read [laziness protocol](references/laziness-protocol.md) and [subtract before you add](references/subtract-before-you-add.md). Add a wrapper, a layer, or a piece of state only when it passes the test in [minimize reader load](references/minimize-reader-load.md). Ask the four questions about test code too. Extend the existing fake, fixture, or helper before you write a new one, as part of the slice.
- Build a tool for mechanical work, and let the tool do the work. Mechanical work is a series of edits, a migration, generated files, or an analysis of data. Read [build the lever](references/build-the-lever.md) before the first edit by hand.
- Define the data shape first when the logic of a slice holds state or branches on a shape. Do the same when the slice creates a type that later slices share. Read [model the domain](references/model-the-domain.md) and [foundational thinking](references/foundational-thinking.md) before you write that logic.
- Keep the code type-safe: use no cast or other way around the type checker. Read [type-system discipline](references/type-system-discipline.md) when you design a type or a signature.
- Validate data at the I/O boundaries, and trust it inside. Configuration is input. Validate it where the code builds it, and refuse a bad value there, not at its first use. Read [boundary discipline](references/boundary-discipline.md) when you write validation, error handling, an adapter, or configuration code. Use no silent fallback that hides a failure.
- Give every call across the network a timeout. Give an idempotency key to each write that a caller can retry. Read [make operations idempotent](references/make-operations-idempotent.md) for a command, startup step, scheduler, or loop that writes state and can run twice.
- When two operations access the same data, run them one at a time. Or claim the data before the `await`: mark it in progress. Then, after the `await`, check again every condition that you read before it. A second check alone lets a charge or a send run twice. Read [separate before serializing shared state](references/separate-before-serializing-shared-state.md) when two actors can write the same file, key, or data.
- Change the state of a component only through its own operations. Never give a caller a reference that lets the caller change the state. Never give a reference to state that can change while the caller holds it. Read [minimize reader load](references/minimize-reader-load.md) before you expose the state of a component.
- Delete what your change made unused. Read [migrate callers, then delete legacy APIs](references/migrate-callers-then-delete-legacy-apis.md) before you write a new API to replace one that still has callers. In the files that the slice changes, also delete dead code before you add to them. Dead code is functions, imports, and parameters that no caller uses, and branches that no caller reaches. It is also stale flags, and validators that repeat a check that a boundary already did. It is also comments that repeat the code or excuse a workaround. Keep dead code that a non-goal puts out of scope. Flag dead code in other files, but do not remove it.
- Write no comment that repeats the code or explains a workaround. Fix the workaround at its cause, or hold the constraint in a type, a lint rule, or a test. Keep a comment only for what the code cannot say. An example is behavior outside the control of the project: a browser quirk, a vendor bug, or a protocol requirement.
- A slice that builds UI takes its typography, color, and spacing from the `DESIGN.md` of the project, when one exists.
- Write the commit message of each slice as one line in the convention of the repository. Read the recent `git log` to find the convention. When there is none, use the imperative in lowercase. Name the criterion by what it says, never by its spec id. Give the reason, not only the change. Stage the specific files, never `git add .`.
- Send a bug or an unexpected failure in a slice to the `debug` skill. Do not hide symptoms with a patch.
- Never guess a decision for the user that you find in a slice. Stop, name it, and let the user answer. A decision is for the user when it changes an acceptance criterion, a non-goal, or a public interface. It is also for the user when it needs the authority of the user or cannot be undone. Settle every other decision that a run can answer by running it, as [never block on the human](references/never-block-on-the-human.md) says.
- Stop the loop after three failed attempts on the same slice. Report to the user the criterion, what you tried, and the last error.
- When the last slice is committed, read the `verify` skill and follow it. Do this before you say that the work is done. For a UI, a public interface, a name, or a doc, also read the `rubric` skill and follow it. The maker never judges its own taste.

© pwguler · MIT · pwguler/skills

Similar skills

All skills for Testing and QA →

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 fix-tests NeoLabHQ fix-tests — a skill for Claude Code, Codex, Cursor and other platforms that repairs failing tests after business logic changes or refactoring. It spawns parallel agents per failing file and loops until every test goes green. CX Codex +1 1,300installs skillshare-implement-feature runkids The skillshare-implement-feature skill takes a Go feature from a spec or plain description through TDD and verification. Use it for CLI commands, flags, and internal packages. CX Codex +1 ★ 3,269repo stars base alinaqi base sets strict code limits and a mandatory TDD workflow with atomic task tracking for AI coding agents. CX Codex +1 276installs tdd-orchestrator davila7 tdd-orchestrator is a Claude Code skill that orchestrates test-driven development through red-green-refactor cycles. It coordinates multi-agent testing workflows and verifies test-first compliance. CX Codex +1 51installs improvement tddworks improvement walks the agent through a TDD loop when you are enhancing something that already works. Useful for UX, performance and code-quality tweaks. CX Codex +1 ★ 1,586repo stars tdd sentimony The tdd skill guides behavior changes with tests before implementation, then checks the result through a red-green-refactor loop. Use it for features, fixes, and refactors. CX Codex +1 2,700installs

From the same set15

The whole set →
debug debug is a Claude Code and Cursor skill that traces bug root causes step by step and verifies regression tests. CX Codex +1 1,000installs verify verify — a skill for Claude Code checks claims about completed or fixed work against fresh command output. It runs before a commit or PR, after changes, and before reporting that work is done or tested. CX Codex +1 1,000installs land land is a Claude Code skill that finishes a development branch through merge, PR, keep, or discard. It runs after implementation is complete. CX Codex +1 1,000installs drill A skill for Claude Code interviews the user about a plan or design until its decisions are settled. It runs for new features, unresolved designs, or a request to “drill this.” CX Codex +1 1,000installs rubric rubric — a skill for Claude Code finds defects in changes and judges design, interface, or writing quality. It sets evaluation criteria before asking an independent subagent to inspect the work. CX Codex +1 980installs prototype This Claude Code skill builds visual UI prototypes before implementation begins. It activates for mockup requests and helps settle a look or flow that text cannot resolve. CX Codex +1 978installs tldr tldr — a skill for Claude Code and Codex that reports completed tasks as concise outcomes instead of tool transcripts. Triggers after builds, verification runs, file changes, or catch-up queries. CX Codex +1 977installs recall recall — a Claude Code skill that rebuilds recent project context from agent sessions, the live repository, and project history. Run it before starting or resuming work, with a topic or without one. CX Codex +1 922installs

Project sponsors

Companies that keep this analytics open