Skills mattpocock skills Engineering workflow

implement-spec

Use it when:: A spec has been split into tickets, and you want all of them built in parallel.
It does:: Puts a subagent on every ticket that's ready, each in its own git worktree, and merges their work as they finish.
You get:: The whole spec on one integration branch, code-reviewed, with the tickets closed or a pull request ready for review.
Unlike implement:: That skill has one agent build one piece in your session; this runs many agents over every ticket of a spec.
Needs:: Subagents, and an issue tracker configured with setup-matt-pocock-skills, the author's one-time repo setup.
Runs:: Only when you invoke it; the agent won't start it on its own.

Skill 16 of 24 in the Engineering workflow bundle, after implement and before tdd.

Only works inside its bundle: Works a spec and its tickets from to-spec and to-tickets on the configured tracker, has each subagent load tdd, and ends with code-review. Install Engineering workflow instead.

TL;DR

It starts from a spec and its tickets, such as the same author's to-spec and to-tickets skills write. It reads the tickets as a graph: a ticket can start once the tickets blocking it are done, so at any moment some set of them is ready. An optional exploration subagent first saves notes outside the repo for the others to read. Then it creates an integration branch, the one branch everything merges into. Each ready ticket gets a subagent in the background, in its own worktree and branch, building test-first. When one finishes, another subagent merges its work into the integration branch, and any tickets that unblocks are started. Messages between agents stay short and point to the spec, tickets, notes and commits instead of repeating them. Once every ticket is done, the branch gets a code review and one subagent fixes everything it raises. It ends by marking the draft pull request ready, if there is one, or closing the tickets the way your tracker does, then removes the worktrees.

Summarizes the skill at 5beb35b. Its SKILL.md has changed by 16 words since.

npx skills add https://github.com/mattpocock/skills --skill implement-spec

skills.sh page Source on GitHub All skills from mattpocock/skills

Total Downloads: 346,807 on skills.sh, Nov 9, 2026
Repo stars: 318,714 mattpocock/skills
First seen: Aug 21, 2026 on skills.sh

Weekly Downloads

27.8K

+6% over the 8 weeks to Nov 9

Weekly values

Week to	Installs
Sep 21	26,320
Sep 28	23,474
Oct 5	29,844
Oct 12	42,312
Oct 19	35,044
Oct 26	31,172
Nov 2	30,324
Nov 9	27,825

Category	category:engineering category:software-engineering Test-first work, implementation from specs, git hygiene and scope control. Everything for building software: planning, coding, debugging, design, frameworks, cloud, agents and skills.
Type	type:workflow A multi-step process the agent follows: interview, debug, run a TDD loop, review.
Effect	effect:remote Its own steps change something outside your machine: post, send, deploy, provision, file issues, drive a website, or upload data to a service.
Needs	needs:issue-tracker needs:subagents Reads or writes an issue tracker, GitHub Issues by default. Relies on the agent being able to spawn subagents.
Publisher	by:community Everyone else. Unverified vendor claims default to community.
Topics	implementation multi-agent issue-tracking

SKILL.md

From mattpocock/skills at a496f55. Checked daily, last changed Oct 30, 2026.

Frontmatter

name: implement-spec
description: "Implement the result of /to-spec and /to-tickets in code."
disable-model-invocation: true

You have been provided a spec. This spec should have tickets associated with it, describing how to implement the spec.

The issue tracker should have been provided to you. If not, tell the user to run /setup-matt-pocock-skills.

The goal is the entire spec implemented on a single integration branch, with every ticket resolved the way the issue tracker closes work.

The tickets are not a list of steps. They are a task graph with blocking relationships between them. This means there is always a frontier of tickets which are ready to be grabbed.

Start every subagent with a fresh context window.

Communication to and from subagents should be sparse. Communicate primarily through context pointers: to the spec, tickets, research notes, and previous commits. Don't duplicate information already available via pointers.

Implementer subagents should be run in the background where possible for maximum concurrency.

Steps

Read the spec and tickets to understand the task graph.
(optional) Use an exploration subagent to conduct any exploration required by the tickets - relevant codebase files or external documentation. Ensure the exploration subagent can save files - it should save its markdown notes in a directory outside the repo, accessible by all future subagents. This lets implementer subagents focus on implementation rather than exploration.
Create the integration branch. If the issue tracker closes work through PRs, or the user asks for one, open a draft PR after the first merge in step 5 (a branch with no commits ahead of main can't open one), marked as closing the spec and tickets.
Use a fresh implementer subagent for each ticket, each in its own worktree on its own branch. Each implementer subagent:
- confirms its worktree is based on the integration branch before starting, and resets onto it if not;
- calls the Skill tool with tdd to build the ticket;
- merges the integration branch tip into its own branch before reporting done
Once an implementer subagent completes, merge its work to the integration branch with a merger subagent.
If this changes the frontier of available tickets, kick off more implementer subagents to work on the new tickets. This allows for maximum concurrency.
Once all tickets are complete, call the Skill tool with code-review on the integration branch. Fix all issues raised by the code review in a single fresh implementer subagent.
If a draft PR exists, mark it ready for review. Otherwise, resolve each ticket the way the issue tracker closes work, and report the integration branch.
Clean up all implementer subagent worktrees.