Skip to content
Skills Library
Programming · Building & coding

implement

/implement

Use when starting implementation work from a PRD, spec, or set of issues — to follow a structured TDD → validate → review → commit loop.

Licence
MIT
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when starting implementation work from a PRD, spec, or set of issues — to follow a structured TDD → validate → review → commit loop.

Original author description

Use when starting implementation work from a PRD, spec, or set of issues — to follow a structured TDD → validate → review → commit loop.

How it works

  1. When to Use
  2. When NOT to Use
  3. Prerequisites
  4. The Five-Step Loop
  5. Full Example
  6. Iteration
  7. Common Rationalizations
  8. Red Flags
  9. Verification
  10. See Also
Original SKILL.md headings · 181 lines, 878 words
SKILL.md preview
---
name: implement
description: >
  Use when starting implementation work from a PRD, spec, or set of issues — to follow
  a structured TDD → validate → review → commit loop.
metadata:
  category: development
  agent_type: general-purpose
  origin: mattpocock/skills
keep-coding-instructions: true
---

# Implement

A structured five-step loop for turning a specification (PRD, issue, or design doc) into
committed, reviewed code. Complements [`tdd-workflow`](../tdd-workflow/SKILL.md) (which focuses
on the Red→Green→Refactor micro-cycle) and
[`verification-before-completion`](../../workflow/verification-before-completion/SKILL.md)
(which enforces proof before claiming done). This skill governs the **macro** flow: from
spec to commit.

## When to Use

- You have a PRD, issue, or spec and need a repeatable path from "start" to "merged"
- You want to enforce `/review` and type-checking as gates before every commit
- You need a structured sequence that doesn't skip test coverage or review under deadline pressure

## When NOT to Use

| Instead of implement | Use |
|----------------------|-----|
| Red→Green micro-cycle for a single function | `tdd-workflow` |
| Verifying a claim before saying "done" | `verification-before-completion` |
| Full sprint across multiple features | `sprint-workflow` |

## Prerequisites

- A PRD, spec file, or set of linked issues is available and understood
- Test framework installed and runnable (`npm test`, `pytest`, `cargo test`, etc.)
- Type checker available when the language supports it (`tsc --noEmit`, `mypy`, etc.)

## The Five-Step Loop

### Step 1: TDD — Write a Failing Test First

Before touching implementation, write the test that will prove the spec is met.

```text
> Write a failing test for [behavior from PRD]. Keep it to the thinnest observable behavior.
```

Run it and confirm it **fails**:

```bash
# JavaScript / TypeScript
npm test -- --testPathPattern="<target>"

# Python
pytest tests/test_<target>.py

# Rust
cargo test <test_name>
```

If no test framework exists yet, create the simplest one before writing any source code.

### Step 2: Implement — Minimal Code to Pass

Write the minimum code to turn the failing test green. Do not add features beyond the test.

```text
[Autopilot Mode]
> Implement the minimum code to pass the test in step 1.
```

Re-run the test and confirm it **passes**. If it doesn't, iterate before moving to Step 3.

### Step 3: Type-Check — Compile-Time Correctness

After tests pass, run the type checker to surface inference gaps and implicit `any` / `unknown`
types before they become runtime bugs.

```bash
# TypeScript
npx tsc --noEmit

# Python (mypy)
mypy src/

# Rust (already type-checked by cargo build)
cargo build 2>&1 | grep -E '^error'
```

Fix all type errors before continuing. A type error in Step 3 often reveals a missing edge case
that warrants a new test in Step 1.

### Step 4: Full Test Suite — No Regressions

Run the **entire** test suite, not just the targeted test, to confirm no existing behaviour
was broken.

```bash
# Full suite — adapt to your stack
npm test
pytest
cargo test
```

Address every failing test. If unrelated tests break, understand why before committing —
do not suppress them.

### Step 5: Code Review → Commit

Invoke `/review` (or the equivalent code-review agent) before committing. Only commit after
review concerns are resolved.

```text
/review
```

Once review passes:

```bash
git add -A
git commit -m "feat(<scope>): <what the PRD required>"
```

Use conventional commit format. Reference the issue or PRD in the commit body if the change
is non-trivial.

## Full Example

```text
# PRD: "Users can reset their password via email"

# Step 1 — TDD
> Write a failing test: POST /auth/reset-password with valid email returns 202 and
  queues a reset email. Confirm the test fails.

# Step 2 — Implement
[Autopilot Mode]
> Implement the password reset endpoint to pass the test.

# Step 3 — Type-check
npx tsc --noEmit

# Step 4 — Full suite
npm test

# Step 5 — Review → Commit
/review
git commit -m "feat(auth): add password reset via email"
```

## Iteration

After committing, check the PRD for remaining uncovered behaviors and restart at Step 1
for the next slice. Prefer many small commits over one large commit per feature.

## Common Rationalizations

| Rationalization | Reality |
|----------------|---------|
| "Type errors can be fixed later" | Type errors in step 3 often reveal spec gaps that should produce new failing tests. |
| "Skip /review — I wrote clean code" | `/review` finds issues invisible to the author. It takes seconds. |
| "Run only the targeted test" | Regressions in unrelated tests are real bugs that must be caught before commit. |
| "Write tests after implementation" | Tests written after the fact rarely start in a Red state and miss edge cases. |

## Red Flags

- Implementation committed before a failing test was written
- Type errors suppressed with `@ts-ignore`, `# type: ignore`, or `unsafe`
- `/review` skipped because "it's a small change"
- Full suite not run after implementing (only targeted test re-run)
- Multiple unrelated features lumped into one commit

## Verification

- [ ] Failing test written before any implementation code
- [ ] Test confirmed green after implementation
- [ ] Type checker exits with zero errors
- [ ] Full test suite passes with no regressions
- [ ] `/review` run and all blockers addressed
- [ ] Commit message follows conventional commit format and references the spec

## See Also

- [`tdd-workflow`](../tdd-workflow/SKILL.md) — Red→Green→Refactor micro-cycle
- [`verification-before-completion`](../../workflow/verification-before-completion/SKILL.md) — proving a task is done
- [`sprint-workflow`](../../workflow/sprint-workflow/SKILL.md) — full Think→Plan→Build→Review→Test→Ship→Monitor cycle
- [`pr-multi-perspective-review`](../pr-multi-perspective-review/SKILL.md) — deeper review before opening a PR

Versions

RepositoryScoreLicence
This page · drvoss/everything-copilot-cli100MIT
ericrisco/rsc-harness100MIT
yonatangross/orchestkit100MIT
sentimony/agentic-workflow100MIT
moberghr/mtk-agent-toolkit100MIT
michielvandermeer/skills100MIT
rossumai/claude-marketplace100MIT
userKael/rastro100MIT
yonatangross/orchestkit100MIT

Database snapshot: 13.11.2026 · package version 677a05743f59 (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

  • 91cook
    Feature implementation orchestrator. ALWAYS use this skill for ANY code change — implement, build, add feature, create, fix bug, or any task that modifies source code. This is the default route for 70% of all requests. Runs full TDD cycle: understand → plan → test → implement →…
  • 100workflow-build-feature
    Build a feature end to end: spec and TDD, implement, unit tests, Playwright check, PR. Use when "build a feature" or "implement this end-to-end". Spec/TDD loop only → workflow-spec-tdd. One bug → workflow-fix-and-ship.
  • 100spec-implement
    Continue an approved Spec-backed workflow when the user says "implement", "go", "start", or "do it". After Codex Plan Mode, persist the next missing design.md or plan.json artifact and stop. When both artifacts exist, execute plan.json with TDD and report between batches.
  • 98tdd-spec
    Test-first workflow with locked, number-based spec tests for any repo with a .claude/tdd/ pack. Use when starting any new change, feature or bug fix in such a repo; when asked to write spec tests, lock tests, implement against locked tests, raise a dispute about a test, or…
  • 82implement-spec
    Execute an approved spec's tasks.md test-first, one task per commit, with review subagents. Use when the user asks to implement or continue a spec.
  • 96tdd
    Use when implementing features or bug fixes test-first.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.