
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.
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:
If any of those sound familiar from your own agent sessions, the grill-me series is essentially a checklist against all four.
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:
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.
Grilling is just the opening move. The complete idea-to-ship flow assembles the skills along classical engineering phases:
/grill-me or /grill-with-docs: interview until you and the agent share one understanding of the goal./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./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./implement: work from the spec or tickets with TDD, regular typechecking, and full test runs./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.
| Phase | Skill | What it does |
|---|---|---|
| Align | /grill-me | Relentless interview; reach shared understanding |
| Align + docs | /grill-with-docs | Same, plus glossary and ADRs as you go |
| Specify | /to-spec | Conversation → publishable spec, no code snippets |
| Plan work | /to-tickets | Tracer-bullet tickets with explicit blockers |
| Build | /implement | TDD-driven implementation from spec or tickets |
| Verify | /code-review | Standards + spec conformance, parallel reviewers |
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.)
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.
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.
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.