We've all experienced the initial rush of "vibe coding": you prompt an AI agent with a loose idea, watch it spew 400 lines of code across six files, and feel like you've unlocked superpowers.

Then reality sets in.

Two hours later, you hit a subtle regression. The agent hallucinates an API, refactors a working subsystem without asking, and drifts further from your original intent with every follow-up prompt. You find yourself stuck oscillating between two extremes:

  • YOLO Mode: Blindly accepting every diff until the codebase becomes an untestable house of cards.
  • OH NO Mode: Giving up on the agent and manually rewriting everything line-by-line because guiding it feels like herding cats.

This breakdown isn't a failure of the underlying model—it's a failure of process. Real software engineering has never been about typing code as fast as possible; it’s about domain modeling, clarifying requirements, isolating vertical slices, test-driven development, and rigorous code review.

Enter Matt Pocock's Claude Code skills—an open-source toolkit that replaces unstructured "vibe coding" with disciplined, repeatable engineering workflows.

What Are Agent Skills?

Rather than treating AI agents as magic code generators, agent skills package proven software engineering practices into declarative, invocable workflows.

Think of skills as specialized playbooks. When you invoke a skill like /grill-me, /tdd, or /code-review, you aren't just sending a prompt—you are equipping the agent with a rigorous methodology, boundary constraints, and structured operational steps.

These skills are built around a central insight: the hardest part of building software is making decisions and eliminating ambiguity before writing code.

The 5-Stage Engineering Loop

Matt Pocock's skills are architected around a structured feature development lifecycle:

  ┌──────────────┐      ┌──────────┐      ┌─────────────┐
  │  /grill-me   │ ───> │ /to-spec │ ───> │ /to-tickets │
  └──────────────┘      └──────────┘      └─────────────┘
   (Interactive                           (Tracer bullets
    Design Tree)                           & dependencies)
                                                 │
                                                 ▼
  ┌──────────────┐                        ┌─────────────┐
  │ /code-review │ <───────────────────── │    /tdd     │
  └──────────────┘                        └─────────────┘
  (Standards & Spec)                      (Red-Green-Refactor)

Let’s look at how each phase transforms the AI development experience.

1. The Grilling Phase (/grill-me & /grill-with-docs)

In traditional prompting, you give instructions and hope the agent understands. In Grilling, the dynamic flips: the agent interviews you.

The agent models your feature as a design tree and traverses its decision frontier round by round:

  • Facts are the agent's job: It inspects your filesystem, dependencies, and configuration automatically rather than asking you for details it can discover itself.
  • Decisions are your job: It presents the open questions on the decision frontier, provides clear multiple-choice options with a recommended default, and waits for your confirmation.
  • Documentation on the fly (/grill-with-docs): As decisions crystallize, it records architectural decisions in docs/adr/ (Architecture Decision Records) and updates your domain glossary in CONTEXT.md.

By the time the grilling round finishes, all hidden assumptions, edge cases, and architectural trade-offs have been resolved.

2. Formal Specification (/to-spec)

Once the grilling phase resolves the design tree, /to-spec synthesizes the entire conversation into a concrete, unambiguous specification or Product Requirements Document (PRD).

Crucially, it focuses purely on requirements, behavioral contracts, and domain boundaries—keeping premature implementation details from derailing the design.

3. Vertical Slicing (/to-tickets)

Monolithic prompts often cause AI agents to bite off more than they can chew, hitting token limits or losing context mid-implementation.

/to-tickets decomposes the specification into "tracer-bullet" tickets. Each ticket represents a thin, end-to-end vertical slice of functionality with explicit dependency tracking (e.g., using GitHub's native issue dependencies via the gh CLI). The agent only tackles tickets whose dependencies are completely closed.

4. Verified Execution (/tdd)

When it is time to code, the agent doesn't guess—it follows strict Test-Driven Development:

  1. Red: Write a minimal, failing unit or integration test that asserts the required behavior.
  2. Green: Write the leanest implementation necessary to pass the test.
  3. Refactor: Clean up the implementation while keeping all tests passing.

By anchoring every implementation step in automated verification, hallucinations and silent regressions are caught immediately.

5. Dual-Axis Review (/code-review)

Before work is merged, /code-review spins up parallel review processes evaluating two distinct axes:

  • Standards: Does the new code follow the repo's documented coding standards and refactoring principles (inspired by Martin Fowler's clean architecture)?
  • Spec: Does the implementation faithfully satisfy every requirement outlined in the original issue/spec?

Setting It Up in Your Repo

Getting started is lightweight. You can install the skills via your agent tooling (or clone them into .agents/skills/), then run the initialization command:

/setup-matt-pocock-skills

This interactive setup scaffolds your repository's agent configuration:

  1. Issue Tracker: Connects the skills to GitHub Issues (gh), GitLab (glab), or local .scratch/ markdown files.
  2. Triage Labels: Configures the canonical label vocabulary (needs-triage, ready-for-agent, ready-for-human, wontfix).
  3. Domain Documentation: Establishes CONTEXT.md and docs/adr/ conventions so future agent sessions maintain complete architectural continuity.

The Verdict: Craftsmanship Over Chaos

AI coding agents are only as reliable as the guardrails we give them. Unstructured prompts produce quick prototypes that quickly degrade into unmaintainable legacy code.

By combining interactive grilling, tracer-bullet ticketing, and test-driven development, Matt Pocock's skills demonstrate what the future of AI-assisted engineering actually looks like: not the replacement of software engineering principles, but their ultimate amplification.