Can AI Coding Run Wild? Matt Pocock’s 21 Skills Enforce Engineering Discipline for Agents

What Problem Does the Project Solve?

The author starts by listing four recurring engineering pain points that also appear when using AI agents: agents produce unwanted code, they are overly verbose and fill the context window, there is no reliable feedback loop to verify generated code, and over time the codebase entropy increases (messy naming, duplicated code, tighter coupling). These issues are not new to the AI era; they have existed for decades in software engineering. Matt Pocock’s approach is to translate proven engineering disciplines into agent‑executable skills.

Core Architecture: Two‑Layer Invocation

Every SKILL.md file contains a front‑matter field disable-model-invocation that determines who can trigger the skill. Two categories exist:

User‑invoked : true – can only be triggered manually by the user via /skill-name, incurs zero context load.

Model‑invoked : omitted – can be triggered by either the user or the model, but its description consumes a round of context.

The two‑layer design balances trade‑offs: making all skills model‑invoked would bloat the prompt, while making all skills user‑invoked would force the user to remember all 21 skill names. High‑frequency decisions stay user‑invoked; context‑heavy, model‑driven actions become model‑invoked. An iron rule is that a user‑invoked skill must never call another user‑invoked skill, which explains the existence of the ask-matt router that indexes user‑invoked skills.

Main Workflow: From Idea to Ship

The ask-matt skill is the entry point that stitches all skills into a “metro map”. The workflow proceeds in three stages:

Requirement clarification : Starts with grill-with-docs (when a codebase exists) or grill-me (no codebase). Both invoke the model‑invoked primitive grilling, whose rule is “Interview me relentlessly about every aspect of this plan until we reach a shared understanding.”

Planning and ticketing : After clarification, if the work exceeds a single session, to-spec creates a specification, then to-tickets breaks it into executable tickets. Version v1.1.0 renamed to-prd, to-issues, and to-plan into the unified to-tickets concept.

Implementation under discipline : The implement skill (15 lines) orchestrates a disciplined implementation using tdd, regular type‑checking, full‑suite testing at the end, and a final code-review step.

Ticket Types and the Wayfinder Skill

Four ticket categories are defined: Research (AFK), Prototype (HITL), Grilling (HITL), and Task (AFK or HITL). A hard rule—“never resolve more than one ticket per session”—enforces context management. The newly added wayfinder skill handles large, ambiguous projects where the path is not visible; it introduces concepts such as Destination, Map, Fog of War, and Frontier to make the unknown explicit. Unlike to-tickets, which assumes a clear requirement, wayfinder focuses on planning rather than delivery.

Parallel Code Review

In v1.1.0 the code-review skill runs two parallel sub‑agents: one checks adherence to repository‑documented coding standards (including Martin Fowler’s 12 code smells), and the other verifies that the implementation matches the originating issue/PRD/spec. The standards axis uses Fowler’s smell baseline, while the spec axis ensures fidelity to the specification.

Meta‑Design of Skills

The writing-great-skills skill treats a skill itself as an engineering artifact. It defines concepts such as Context Load, Cognitive Load, Progressive Disclosure, Leading Word, No‑op, Negation, and Negative Space. Leading words like _tight_, _red_, _fog of war_, and _tracer bullet_ anchor entire behavior clusters in the model’s pre‑training. v1.1.0 also adds two failure modes—Negation (the model does the opposite of a “don’t do X” instruction) and Negative Space (omitted content is filled by the model’s priors).

Versioning and Positioning

Changes are tracked with changesets in .changeset/*.md and aggregated into CHANGELOG.md, treating each skill as a versioned, maintainable software package. The README positions the library against GSD, BMAD, and Spec‑Kit, emphasizing that it does not take over the process, remains small, composable, and works across agents (Claude Code, Codex, etc.).

Installation

npx skills@latest add mattpocock/skills

After installation, the user must select setup-matt-pocock-skills, which detects the repository state, configures the issue tracker, and writes agent definitions to docs/agents/*.md.

Conclusion

The core of the library is engineering discipline rather than novel AI tricks. It provides a concrete, versioned set of skills that let developers collaborate with agents in a controlled, feedback‑driven manner, making the “how to work with agents” problem explicit.