Article

Stop Vibe Coding: Matt Pocock's Grill-Me Agent Skills for Disciplined AI Development

Stop Vibe Coding: Matt Pocock's Grill-Me Agent Skills for Disciplined AI Development

There's a problem developers are quietly admitting about AI coding agents: they're fast, but the code gets worse. A recent walkthrough on the Chinese developer forum LINUX DO lays out a disciplined alternative that's gaining traction among solo developers — Matt Pocock's open-source Agent Skills series, built around a single idea: before your agent writes a single line of code, make it interview you relentlessly ("grill you") until you both genuinely understand what you're building.

The pitch is simple. Instead of one giant prompt or a heavyweight framework, you get a small, composable toolchain that turns "build this for me" into a pipeline: grill → spec → tickets → implement → review. Here's what it is, how it works, and why developers on both sides of the Pacific are paying attention.

The problem: fast agents, worse codebases

Pocock's central claim — repeated in his AI Engineer workshop and quoted across the community — is that coding agents like Claude Code and Codex ship code faster than any human ever has, but without careful guidance they make codebases worse. And the worse the codebase, the worse the AI performs. It's a vicious circle: bad code is now the most expensive kind of code.

He identifies four failure modes, each with a named countermeasure in the skill set:

  1. The agent didn't do what you want. A communication gap between you and the agent. Fixed with a grilling session — detailed questions before any action.
  2. The agent is way too verbose. Your project lacks a shared domain language, so the agent guesses. Fixed by establishing a glossary the agent can decode.
  3. The code doesn't work. No real feedback loops — the agent can't verify its own changes. Fixed with static types, tests, and red-green-refactor discipline.
  4. We built a ball of mud. AI-accelerated coding compounds complexity without design investment. Fixed with daily architecture work and domain modeling.

If any of those sound familiar from your own agent sessions, the grill-me series is essentially a checklist against all four.

The key move: grill-me before a line is written

The signature skill is /grill-me, and its definition is strikingly short: interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies one by one.

The mechanics are what make it work rather than annoy:

  • One question at a time. The agent never dumps a batch of questions on you — that's bewildering. It asks, waits, and only continues when you answer.
  • Every question ships with a recommendation. The agent proposes its own answer, so you're reacting to a concrete proposal instead of staring at a blank prompt.
  • The agent reads before it asks. When a question can be answered by exploring the codebase, it goes and explores rather than bothering you. You make the decisions; the agent does the legwork.

This is the alignment phase, and it is deliberately human-in-the-loop — you can't skip it. Interestingly, the spec document that comes next is treated as a summary artifact, not the source of truth. Pocock says he doesn't even re-read the generated PRD, because the shared understanding was built during the grilling. A variant skill, /grill-with-docs, performs the same interrogation while writing down a glossary and architecture decision records (ADRs) as decisions crystallize — the paper trail is a side effect, not the point.

The full pipeline: five skills, one flow

Grilling is just the opening move. The complete idea-to-ship flow assembles the skills along classical engineering phases:

  1. Grill — /grill-me or /grill-with-docs: interview until you and the agent share one understanding of the goal.
  2. Spec — /to-spec: synthesize the conversation into a self-contained specification and publish it to the issue tracker. The spec deliberately contains no file paths or code snippets — those go stale fastest.
  3. Tickets — /to-tickets: slice the spec into "tracer-bullet" tickets — vertical slices through every layer (schema, API, UI, tests), each sized to fit a single fresh context window, each declaring which tickets block it.
  4. Implement — /implement: work from the spec or tickets with TDD, regular typechecking, and full test runs.
  5. Review — /code-review: check the changes on two axes — conformance to the repo's standards and conformance to the original spec — using parallel subagents so they don't pollute each other's context.

A setup skill, /setup-matt-pocock-skills, runs once per repository to configure the issue tracker (GitHub, Linear, or plain Markdown files), triage labels, and documentation layout.

PhaseSkillWhat it does
Align/grill-meRelentless interview; reach shared understanding
Align + docs/grill-with-docsSame, plus glossary and ADRs as you go
Specify/to-specConversation → publishable spec, no code snippets
Plan work/to-ticketsTracer-bullet tickets with explicit blockers
Build/implementTDD-driven implementation from spec or tickets
Verify/code-reviewStandards + spec conformance, parallel reviewers

Two concepts that make it actually work

Two supporting ideas explain why the pipeline holds together where simpler "write a spec, then code" flows fall apart.

The smart zone. Regardless of how large context windows get, there's an effective zone of around 100K tokens where the agent reasons well. Tasks sized beyond that degrade. The pipeline respects this everywhere: tickets are sized to fit a single fresh context window, and the review step spins up parallel subagents rather than cramming everything into one mega-session. Prefer clearing context over compacting it.

Tracer bullets and "work the frontier." Instead of asking an agent to build a complete feature in one shot, you ask for the smallest possible end-to-end slice first — a tracer bullet through schema, API, UI, and tests. The execution rule is simple: work the frontier, i.e., pick any ticket whose blockers are all done. This forces feedback loops early and exposes wrong assumptions before they compound. (The one exception: wide mechanical refactors aren't sliced but sequenced as expand–contract operations.)

Try it yourself

Installation is a single command. After picking which skills you want, run the setup skill once per repository:

npx skills@latest add mattpocock/skills

Then, inside your agent session (Claude Code, Codex, or any Agent Skills-compatible agent):

/setup-matt-pocock-skills
/grill-me

One caveat, stressed both by Pocock and the LINUX DO thread: these skills don't auto-trigger. Nothing will grill you unless you ask. The workflow only works if you learn it and invoke it proactively. Skills are discipline you choose, not magic the agent applies on its own.

Why Chinese developers are adopting it

The forum walkthrough that surfaced this series contrasts grill-me with Superpowers, a heavier skill framework the author found counterproductive on large projects and wasteful on small ones. For solo developers and small teams, the lightweight grill-me pipeline fit better — a verdict worth noting from a community famous for squeezing maximum value out of its tooling. Discipline scaled to the team, not imposed by a framework.

There's a cultural echo, too. A parallel thread on the same forum asked how developers recover the ability to think in the AI era, and one reply half-joked that you could "use grill-me to burn hundreds of millions of tokens a day, training yourself on AI data." Beneath the joke is a real observation: grilling forces the human to think clearly about their own design before the agent starts. The skills don't just align the agent — they align you.

The takeaway

If you take one idea from this workflow, let it be this: the spec is not the source of truth — the shared understanding is. The grill-me series is a practical, open-source way to enforce that, and it composes with whichever agent you use.

For English readers, the full skill list lives in the mattpocock/skills repository, installable via skills.sh. And if the broader shift behind all this interests you — why developers are moving their subscriptions to the strongest coding agents in the first place — the forum's verdict on the Claude Pro switch and their community-run pelican benchmark tests make good companion reads.

Keep reading
Why Chinese Developers Are Quietly Switching From ChatGPT to Claude Pro
Read next →