Catalog
mattpocock/implement-spec

mattpocock

implement-spec

Implement the result of /to-spec and /to-tickets in code.

NewUpdated Oct 30, 2026

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

  1. Read the spec and tickets to understand the task graph.

  2. (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.

  3. 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.

  4. 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
  5. Once an implementer subagent completes, merge its work to the integration branch with a merger subagent.

  6. If this changes the frontier of available tickets, kick off more implementer subagents to work on the new tickets. This allows for maximum concurrency.

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

  8. 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.

  9. Clean up all implementer subagent worktrees.

Files2
2 files · 1.2 KB

Select a file to preview

Overall Score

72/100

Grade

B

Good

Grades are signals, not a certification. Always review a skill yourself before use.

Safety

80

Quality

68

Clarity

77

Completeness

60

Summary

This skill orchestrates the implementation of a specification through a task graph of tickets, using multiple subagents working in parallel on separate git branches/worktrees. It coordinates exploration, implementation, code review, and integration by treating tickets as a directed graph with blocking relationships, ensuring maximum concurrency while maintaining code quality through structured merges and review cycles.

Detected Capabilities

git operations (branch, merge, worktree)subagent spawning and coordinationfile reading (spec, tickets, exploration notes)skill invocation (tdd, code-review)issue tracker interactionPR management (draft, ready for review)

Trigger Keywords

Phrases that agents use to match this skill to user intent.

implement feature from specparallel ticket developmentspec to code workflowmulti-agent feature branchorchestrate subagent work

Risk Signals

INFO

Multiple subagents spawned with access to shared repository state

Steps 2-6
INFO

Git merge operations performed without explicit conflict handling guidance

Steps 5, 9
INFO

Assumes issue tracker integration is pre-configured

Steps 1-3, 8
WARNING

Worktree cleanup occurs at the end, but no error handling if subagents fail

Step 9
WARNING

No explicit instruction on how to handle merge conflicts or failed subagent runs

Steps 4-6

Use Cases

  • Implement a spec split into multiple concurrent tickets
  • Coordinate multi-agent work on a feature branch
  • Manage ticket-based development with blocking dependencies
  • Orchestrate parallel implementation with periodic code review
  • Merge and integrate work from multiple subagents systematically

Quality Notes

  • Clear task graph and frontier concept explains parallelization strategy well
  • Sparse communication principle via context pointers is well-articulated and reduces token waste
  • Step-by-step orchestration is logical and easy to follow
  • Good guidance on using exploration subagent separately to unblock implementers
  • Missing: explicit error handling strategy when a subagent fails or merge conflicts occur
  • Missing: guidance on how to detect when the frontier of tickets changes
  • Missing: instructions for handling incomplete or partially-completed tickets
  • Missing: definition of what 'confirms its worktree is based on the integration branch' means in practice (git log check? merge base?)
  • Assumes user has already run `/setup-matt-pocock-skills` — no fallback if they haven't
  • Good: explicit mention of draft PR workflow and when to mark ready
Model: claude-haiku-4-5-20251001Analyzed: Oct 30, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Version History

  1. v1.1

    Content updated

    ✦ AIRequires fresh context window for each implementer subagent spawned per ticket or code-review phase.

    2026-10-30

    LATEST
  2. v1.0

    2026-09-30

    View This VersionInitial version

Use mattpocock/implement-spec in your dev environment

Command Palette

Search for a command to run...