A Formal Language for Writing Agent Instructions: Matt Pocock's Skills v1.2.0

📌 What this release actually ships

📚 The docs, the marketplace, and Codex 0:18

🛑 /wait-what — the Opus emergency brake 2:32

The skill does two things: references ASD-STE100 (simplified technical English — a controlled language standard used in industry) as a leading word for clear declarative sentences, and grounds responses in the ubiquitous language from the project's context — the domain terms already established in /grill-with-docs.

🕸️ /grill-me — the graph beneath the questions 4:02

Previously: one question per turn. The failure mode was the end of a session — you had already resolved the hard things and spent several turns saying "yes, that sounds good" to easy ones. He describes it as "incredibly frustrating and dead slow."

The new design: questions are a graph with dependencies. Some questions require earlier answers before they can be asked. The agent pushes as fast as possible down the "frontier of questions" — the set whose dependencies are already satisfied, asked in rounds.

✍️ /writing-for-agents — the formalism 6:27

The video covers this in ninety seconds. The SKILL.md is 81 lines and 10,966 bytes of what is essentially a formal language for designing instructions an agent will read — and it is worth treating as a document rather than as a summary. What follows is its conceptual structure, with verbatim excerpts.

Context pointers

A pointer names some out-of-context material and encodes the condition for reaching it. Its wording, not its target, decides when the agent reaches the material — and how reliably.

The rules:

• Front-load the leading word — the pointer is where it does its triggering work.
• One trigger per branch. Synonyms that rename a single branch are one branch written twice.
• Cut identity the body already carries.

The two loads

Context load — the cost of always-loaded material on the agent's window. Cognitive load — the cost on the human: which documents exist and when to reach for each.

The information hierarchy

A ladder ranked by how immediately the agent needs the material:

1. In-file step — the primary tier: what the agent does, in order.
2. In-file reference — consulted on demand.
3. Disclosed reference — pushed behind a context pointer, loaded only when the pointer fires.

Progressive disclosure is the move down the ladder — out of the main file and behind a pointer. Co-location is the within-file companion: keep a concept's definition, rules and caveats under one heading so reading one brings its neighbours. Sprawl is the failure mode — a document too long, even when every line is live.

Steps and completion criteria

Every step ends on a completion criterion with two properties:

• Clarity — can the agent tell done from not-done? A vague bound invites premature completion: ending the step before it is done, attention slipping to being done. The visible steps still ahead supply the pull; the criterion's clarity is the resistance.
• Demand — how much it requires. "Every modified model accounted for" forces thorough work where "produce a change list" does not.

Leading words

A compact concept already living in the model's pretraining that the agent thinks with while running the document. Repeated as a token, never as a sentence, it anchors a whole region of behaviour.

His examples are the right kind of concrete: "fast, deterministic, low-overhead" → tight. "a loop you believe in" → red. A fuzzy gate becomes a binary observable state — the loop goes red on the bug, or it does not.

Negation

Steering by prohibition drags the forbidden behaviour into context and makes it more available. The ban half-reads as an instruction to do the thing.

Pruning

• Single source of truth. Duplication costs maintenance and inflates a meaning's prominence past its real rank.
• The environment is a source of truth too — package.json, config files, directory layout. A document that restates it is a cache: earn its load only when the lookup is expensive. Cache the unwritten convention, the reason behind a choice, the gotcha no config confesses.
• Check every line for relevance. The default fate without pruning is sediment: stale layers settling because removing feels risky.
• Hunt no-ops: an instruction the model already obeys by default pays load to say nothing. Test it by running the document.

🧙 /wizard — deterministic provisioning 7:27

The skill generates an interactive bash script that walks a human through steps only they can perform — opening pages, pasting API keys, changing settings. It is deterministic: "nothing's touching an agent here. It's not sending it off to Anthropic or anything."

📋 /to-questionnaire — collaboration outside the agent 8:58

Pulls the decisions from a grilling session into a markdown document you can share with someone who does not use agents — a stakeholder, a partner, a client.

🏦 Reading this from a bank

🔍 Claims checked

💡 Key takeaways

1. The skill nobody called exciting is the one worth reading. /writing-for-agents is a formal language for designing agent instructions — context pointers, information hierarchy, completion criteria, leading words, negation and pruning — and it is directly applicable to every document on this site.
2. "Progressive disclosure" is not a token optimisation — it is how the hierarchy is protected. Material that only some branches reach belongs behind a pointer, or it buries the primary steps and makes attending to them a coin flip.
3. Negation is a failure mode, not a technique. "Don't think of an elephant" — and the elephant is all there is. Prompt the positive target so the banned behaviour is never spoken.
4. The environment is a source of truth. Don't cache in a document what package.json, the directory layout or --help already says. Cache the unwritten convention, the reason, the gotcha.
5. Completion criteria have two levers: clarity and demand. "Every modified model accounted for" forces thorough work; "produce a change list" does not. The visible steps ahead supply the pull; the criterion's clarity is the resistance.
6. Grill Me's dependency graph is a better design than sequential questions, and the mechanism — only ask questions whose dependencies are resolved, in rounds — is the right way to speed up without losing coherence.
7. /wait-what is the right answer to verbosity: ground responses in the ubiquitous language you already defined, not in abstract pleas for simplicity.
8. /wizard makes a deliberate choice against the industry direction: deterministic scripts with no agent at runtime. The agent as documentation tool, not as operator — a legitimate category boundary.
9. /to-questionnaire is a bridge, and the honesty is in the framing: "a skill I hope someday to delete." Agents cannot collaborate with non-agents yet; the bridge is a markdown file.
10. The vendor landscape is converging. A day after Telnyx published 238 agent skills, the largest independent skills library joins the Claude Code marketplace and ships Codex sidecars. The skill format is becoming the distribution mechanism for both capability and process.

🔗 Resources & links

• New Skills! v1.2 brings /wait-what, /writing-for-agents, and fixes /grill-meSource video — Matt Pocock, 11:37, 5 August 2026
• mattpocock/skills204,742 ⭐, MIT. 25 skills across six workflow stages
• /writing-for-agents SKILL.md81 lines, 10,966 bytes — the document this article's §4 is drawn from
• SKILL-MECHANICS.mdCompanion reference for frontmatter, invocation choice and router skills
• AI Hero — Skills documentationThe new docs site, with skill groupings and an AI coding dictionary
• /wizard skillDeterministic bash wizard generation for infrastructure provisioning

🕐 Timestamp index