# 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](https://www.aihero.dev/skills-changelog-v13-implement-spec-pr-retro-and-glossary-md), Pocock focuses on parallel ticket execution, human pull request review speed, and repository environment maintenance.

![Official AI Hero v1.3 release announcement showing implement-spec, pr, retro, and GLOSSARY.md](https://s4.tenten.co/learning/content/images/2026/10/landing-page-1-5.png)

#### 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](https://github.com/mattpocock/skills/pull/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.

```bash
# 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](https://www.aihero.dev/skills-implement-spec), 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](https://developer.tenten.co/grok-bot-opus-55-cursor-agent-handoff) without custom runner infrastructure.

![Official AI Hero documentation for the /implement-spec skill showing installation and parallel subagent execution](https://s4.tenten.co/learning/content/images/2026/10/landing-page-2-5.png)

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](https://developer.tenten.co/pstack-verification-agent-merge) 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](https://www.aihero.dev/skills-pr) 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](https://github.com/humanlayer/skills/blob/main/plugins/show-me/skills/show-me/SKILL.md). 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:

![Official GitHub Pull Request #1120 in mattpocock/skills showing the Evidence and Merge Danger sections generated by the pr skill](https://s4.tenten.co/learning/content/images/2026/10/landing-page-3-5.png)

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

```markdown
  ## 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](https://www.aihero.dev/skills-retro) 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)](https://www.aihero.dev/skills-changelog-v13-implement-spec-pr-retro-and-glossary-md)
- [AI Hero: Official /implement-spec Skill Documentation](https://www.aihero.dev/skills-implement-spec)
- [AI Hero: Official /pr Skill Documentation](https://www.aihero.dev/skills-pr)
- [AI Hero: Official /retro Skill Documentation](https://www.aihero.dev/skills-retro)
- [GitHub: mattpocock/skills Official Repository and v1.3.1 Release](https://github.com/mattpocock/skills)
- [GitHub: mattpocock/skills Pull Request #1120 (v1.3 Graduation and Live /pr Output)](https://github.com/mattpocock/skills/pull/1120)
- [GitHub: Humanlayer show-me Visual Summary Skill Definition](https://github.com/humanlayer/skills/blob/main/plugins/show-me/skills/show-me/SKILL.md)
- [Anthropic: Claude Code Skills and Subagents Official Documentation](https://docs.anthropic.com/en/docs/claude-code/skills)

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