Matt Pocock Releases Skills 1.3 with /implement-spec, /pr, /retro, and GLOSSARY.md

Matt Pocock released mattpocock/skills v1.3 on October 4, 2026, graduating /implement-spec, pr, and /retro into the Engineering suite. Across more than 292,000 GitHub stars and 24,500 forks, the open-source collection now targets the bottlenecks that emerge after code generation becomes cheap. The release also renames CONTEXT.md to GLOSSARY.md across 11 skills. In the official v1.3 release notes, Pocock focuses on parallel ticket execution, human pull request review speed, and repository environment maintenance.

The Front Half vs. the v1.3 Back Half: User-Invoked and Model-Invoked Skills

Before version 1.3, engineers relied on four core skills to move from an initial idea to working code. First, /grill-with-docs (or /grill-me) conducts a structured planning interview grounded in the repository's existing architecture and domain terminology. Second, /to-spec condenses that alignment conversation into a standalone specification containing user stories and acceptance criteria whenever a fresh session is needed. Third, /to-tickets splits large specifications into vertical tracer bullets (Blocked by dependencies) so each ticket fits inside a clean context window. Fourth, /implement executes a single ticket through red-green-refactor test-driven development (TDD).

Those four steps solved requirement shaping, yet left three operational bottlenecks in the second half of delivery. Engineers still had to dispatch multi-ticket dependency graphs manually one ticket at a time. AI-generated pull request descriptions buried critical migration risks under walls of file-by-file prose. Worse, friction encountered by the coding agent during a session rarely resulted in permanent repository guardrails.

To address those gaps, pull request #1120 graduates three back-half skills and enforces a strict two-tier invocation boundary across all 27 skills:

• User-invoked skills (disable-model-invocation: true): Include /grill-with-docs, /to-spec, /to-tickets, /implement, /implement-spec, and /retro. These skills act as top-level workflow orchestrators initiated explicitly by the developer. A skill may never invoke another user-invoked skill automatically.
• Model-invoked skills: Include grilling, tdd, code-review, domain-modeling, codebase-design, and the newly graduated pr skill. These represent reusable engineering disciplines loaded on demand. Version 1.3 updates internal skill handoffs to state Call the Skill tool with "grilling", removing prose ambiguity and decoupling the collection from Claude Code slash-command syntax.

Breaking Changes in v1.3: CONTEXT.md Becomes GLOSSARY.md

Upgrading to version 1.3.0 or 1.3.1 introduces two breaking repository changes that require immediate action from engineering teams.

First, the domain terminology convention changes from CONTEXT.md to GLOSSARY.md, and CONTEXT-MAP.md becomes GLOSSARY-MAP.md. Originally named after Domain-Driven Design bounded contexts, CONTEXT.md proved too vague in practice. Coding agents frequently failed to load the file when checking domain terms, and developers confused it with general project notes. All 11 domain-aware skills, including domain-modeling, grill-with-docs, tdd, wait-what, and pr, now read and write GLOSSARY.md exclusively. Teams must rename existing files in a single shared commit so updated agents do not create a blank GLOSSARY.md alongside the legacy file.

Second, version 1.3 removes /resolving-merge-conflicts. Current frontier models and agent harnesses resolve in-progress Git merge and rebase conflicts natively without a dedicated skill file.

# 1. Update installed skills and remove the retired merge-conflict directory
npx skills update
rm -rf .agents/skills/resolving-merge-conflicts

# 2. Rename existing domain glossary files in a single atomic commit
git mv CONTEXT.md GLOSSARY.md
git mv CONTEXT-MAP.md GLOSSARY-MAP.md
git commit -m "chore(docs): rename CONTEXT.md to GLOSSARY.md for mattpocock/skills v1.3"

/implement-spec: Task-Graph Frontier Scheduling Across Isolated Git Worktrees

When /to-tickets breaks a complex feature into seven or eight tickets with explicit Blocked by edges, running /implement manually turns the human engineer into a sequential for loop. In the official /implement-spec documentation, Pocock outlines three execution loops. Teams can use a manual human loop, a deterministic script loop (like Sandcastle), or the agent loop powered by /implement-spec.

While a tuned deterministic runner remains the most predictable option for mature software factories, /implement-spec provides immediate parallel execution for teams adopting structured multi-agent handoff workflows without custom runner infrastructure.

Reworked prior to graduation in v1.3, /implement-spec targets a single integration branch rather than opening separate pull requests for every ticket. The orchestrator follows an eight-step execution protocol:

1. Verify issue tracker setup: Confirm whether tickets live in GitHub Issues, Linear, or local Markdown files, prompting the user to run /setup-matt-pocock-skills if unconfigured.
2. Parse the task graph and ready frontier: Read all tickets and their blocking edges, rejecting any circular dependency graphs. Unblocked tickets form the initial ready frontier.
3. Dispatch a read-only exploration subagent: When multiple tickets touch unfamiliar modules, an exploration subagent writes shared architectural notes outside the repository so implementers do not repeat discovery queries.
4. Create the integration branch: Cut and push a single integration branch from the default branch to collect all ticket outputs.
5. Launch parallel implementer subagents in isolated Git worktrees: For every ticket in the current frontier, the orchestrator spawns a background implementer subagent with isolation: "worktree". Each implementer verifies that its worktree branches off the integration branch, executes red-green-refactor cycles using tdd, and merges the latest integration branch tip back into its own worktree branch before reporting completion.
6. Advance the frontier via a merger subagent: As implementers finish, a merger subagent fast-forward merges each completed branch into the integration branch and pushes the update. A draft pull request opens only after the first merge, and only if the tracker closes issues via pull requests. Completing upstream tickets unlocks dependent tickets for the next parallel wave.
7. Run whole-branch code-review and remediation: Once every ticket lands on the integration branch, the orchestrator invokes code-review across the combined diff and dispatches a single fixer subagent to resolve findings.
8. Clean up worktrees and close out: Remove temporary Git worktrees and merged local branches, leaving one verified integration branch ready for human review.

Pocock notes two practical trade-offs with this design. First, landing an entire specification on one integration branch produces a large combined diff because the skill avoids GitHub-specific stacked pull requests. Second, Git worktrees isolate file trees during coding but defer semantic collisions to merge time. If two parallel tickets introduce duplicate schema fields under different names, teams still rely on strict repository verification and merge gates plus the final code-review pass to catch the discrepancy.

pr: Bottom-Up Pull Request Reviews with One-Way Doors and Tiered Evidence

Once code generation finishes, human review speed determines how fast changes reach production. Default AI pull request summaries routinely list every modified file without explaining architectural impact or rollback risk. The graduated pr skill runs as a model-invoked template whenever the agent prepares a pull request body. Teams using tools with competing default templates can also pin pr inside AGENTS.md.

The pr skill enforces a strict three-section structure designed to be read bottom-up:

1. Read ## Merge Danger first (at the bottom): The agent must classify the change as a two-way door or a one-way door. Two-way doors revert cleanly via git revert, whereas one-way doors involve destructive database migrations, contract changes, or external emails. It must also state the Blast Radius, ranging from an isolated UI button to every consumer of a core service. Reviewers can skim and merge a narrow two-way door quickly, while dedicating deep line-by-line scrutiny to wide one-way doors.
2. Check ## Evidence second (in the middle): Requiring concrete Before and After proof prevents agents from claiming a change works merely because they read the code. Visual interface changes require S-tier evidence (before-and-after screenshots). Backend changes require A-tier execution evidence. Examples include a failing test log or HTTP 500 response before the patch compared against HTTP 200 OK after the patch.
3. Inspect ## Summary last (at the top): This section adapts Dex Horthy's show-me skill at Humanlayer. It replaces multi-paragraph prose with the smallest visual representation of the change, such as a file-tree diff, pseudocode, call tree, or Mermaid diagram.

Matt Pocock generated the official v1.3 graduation pull request (mattpocock/skills#1120) using the pr skill itself:

Below is a production example of the pr template applied to a payment webhook migration:

  ## Summary

  Migrate checkout state transitions from boolean flags to an explicit status enum with idempotent webhook locking.

    src/modules/checkout/
    ├── webhook-handler.ts       # + Add idempotency key lock and transition guard
    ├── schema.sql               # ! Replace is_paid boolean column with payment_status enum
    └── __tests__/
        └── webhook.spec.ts      # + Cover duplicate webhook deliveries and out-of-order events

  ## Evidence

  - Before: Sending duplicate webhook payloads with the same event_id triggered a unique constraint error (HTTP 500); pnpm test failed (1 failed).
  - After: Duplicate deliveries return HTTP 200 OK without double-deducting inventory; all 14 assertions in pnpm test and pnpm typecheck pass.

  ## Merge Danger

  Door: one-way door (drops the legacy is_paid column during migration; rolling back application code requires a forward schema restore).
  Blast Radius: checkout module and billing reporting queries (all readers updated to query payment_status).

/retro: Turning Mechanical Rules into Deterministic Checks So AGENTS.md Shrinks

Coding agents rarely complain when a repository is poorly configured. An agent may guess the wrong import path three times or run a broken test script. It absorbs that friction silently and finishes the task at the cost of wasted tokens and latency.

The user-invoked /retro skill inspects the real session transcript after feature delivery (or after /diagnosing-bugs resolves a defect in v1.3.1) to fix the agent's environment rather than the application code. It audits seven repository dimensions ordered by severity:

1. Navigation: Applies John Ousterhout's deep-module principles from A Philosophy of Software Design to spot hidden coupling and missing navigation pointers.
2. Automated checks: Verifies that linting, typechecking, and test scripts run reliably inside pre-commit hooks and CI pipelines. A repository without automated guardrails is flagged immediately as a top-priority finding.
3. Coding standards triage: Splits observed style or architectural mistakes into two strict categories. Mechanical violations must become deterministic checks—a custom ESLint/Biome rule, a type constraint, or a pre-commit hook—because a check fails the build whereas a sentence in a Markdown file does not. Only genuine judgement calls belong in CODING_STANDARDS.md, which is read by the low-context-pressure code-review subagent rather than the high-context-pressure implementation agent.
4. Global AGENTS.md hygiene: Keeps AGENTS.md and CLAUDE.md minimal, restricted to repository navigation pointers and core commands.
5. Tool economy: Replaces token-heavy CLI outputs with concise wrapper scripts.
6. No-op removal: Deletes steering instructions such as "write clean, maintainable code" that do not alter model behavior.
7. Information access: Pipes dev-server logs to readable files via tee so agents can inspect runtime errors directly.

Pocock advises strongly against automating /retro. An unattended retrospective loop latches onto single-session false positives and pollutes the repository with brittle rules. Running /retro human-in-the-loop lets engineers approve high-leverage deterministic checks while keeping AGENTS.md shorter over time.

Avoiding the Heavy-Pipeline Trap: Route by Context Window Budget

The most common mistake among developers adopting mattpocock/skills is treating /grill-with-docs -> /to-spec -> /to-tickets -> /implement-spec as a mandatory sequence for every task. Running specification generation and multi-worktree orchestration for a small bug fix or a single endpoint change burns tokens and adds unnecessary subagent coordination overhead.

Engineers should select one of three execution paths based on remaining context capacity after requirement alignment:

• Path A: Single-Session Fast Path: When /grill-with-docs finishes with 60% or more of the context window free and the change fits in one module, skip /to-spec and /to-tickets. Run /implement directly in the same conversation, let pr format the pull request, and run /retro if the agent hit environment friction.
• Path B: Cross-Session Spec Handoff: When repository exploration during /grill-with-docs consumes most of the context window, run /to-spec to persist the agreed design. Clear the session (/clear) and run /implement in a fresh context window.
• Path C: Parallel Task-Graph Execution: Reserve /to-spec -> /to-tickets -> /implement-spec for large features that decompose into multiple independent tracer bullets or expand-contract migrations across parallel worktrees.

Skill Name	Trigger Type	Invocation Mode	Primary Input and Output	Isolation and Verification	Ideal Engineering Scenario
/implement	User-invoked	Manual /implement command	Aligned chat context or single ticket -> verified commit	Single branch running tdd and code-review	Small-to-medium changes when context remains ample after /grill-with-docs
/implement-spec	User-invoked	Manual /implement-spec command	Spec + Blocked by ticket graph -> single integration branch	Parallel Git worktree implementers + fast-forward merger subagent	Multi-ticket specs with parallel frontiers requiring background execution
pr	Model-invoked	Loaded automatically on PR creation or via Skill tool	Diff, spec, and test logs -> 3-part PR description	Bottom-up Merge Danger (door + blast radius) and tiered Evidence	Every pull request awaiting human review and merge triage
/retro	User-invoked	Manual /retro with human approval	Session transcript -> lint rules, hooks, and CODING_STANDARDS.md	7-category audit converting mechanical rules into deterministic checks	Post-session cleanup when the agent hit friction or after /diagnosing-bugs

Frequently Asked Questions

What happens if a repository updates to mattpocock/skills v1.3 without renaming CONTEXT.md?

All 11 domain-aware skills in v1.3, including grill-with-docs, domain-modeling, tdd, and pr, look exclusively for GLOSSARY.md and GLOSSARY-MAP.md. If an existing CONTEXT.md is not renamed with git mv, the agent will create a new, empty GLOSSARY.md beside the old file and ignore prior domain definitions.

How does /implement-spec differ from running /implement inside an external shell loop?

An external deterministic script loop invokes /implement sequentially one ticket at a time in fresh processes, offering maximum predictability once configured. By contrast, /implement-spec uses an orchestrator agent to parse Blocked by dependencies dynamically. It launches parallel background subagents in isolated Git worktrees across the unblocked frontier and merges them into one integration branch.

Why should reviewers read pull requests generated by pr from the bottom up?

Reading Merge Danger at the bottom first tells the reviewer within seconds whether the change is a reversible two-way door or an irreversible one-way door, alongside its blast radius. If the change is a low-risk two-way door with a narrow blast radius, verifying the Evidence block directly above it is sufficient to approve and merge without reading lengthy background prose.

Should rules discovered during /retro go into AGENTS.md or CODING_STANDARDS.md?

Neither is the first choice. Mechanical rules that can be checked programmatically belong in deterministic linters, type checks, or pre-commit hooks that fail the build automatically. Only nuanced architectural judgement calls belong in CODING_STANDARDS.md for the code-review subagent, keeping AGENTS.md restricted to concise navigation pointers.

Authority Sources

• AI Hero: Skills v1.3 Release Notes (/implement-spec, /pr, /retro, and GLOSSARY.md)
• AI Hero: Official /implement-spec Skill Documentation
• AI Hero: Official /pr Skill Documentation
• AI Hero: Official /retro Skill Documentation
• GitHub: mattpocock/skills Official Repository and v1.3.1 Release
• GitHub: mattpocock/skills Pull Request #1120 (v1.3 Graduation and Live /pr Output)
• GitHub: Humanlayer show-me Visual Summary Skill Definition
• Anthropic: Claude Code Skills and Subagents Official Documentation

Author Insight

When 80% of daily pull requests touch a single service, teams gain the most leverage in mattpocock/skills v1.3 by pairing /grill-with-docs -> /implement with the pr template and weekly /retro audits. Reserve /implement-spec for specifications that genuinely split into four or more tickets with independent parallel frontiers, where worktree concurrency outweighs merge-time coordination overhead.