From 3babdf52d1002b7efda0ff59f6bdae2f67e04553 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Wed, 5 Aug 2026 11:49:31 +0100 Subject: [PATCH] docs: rewrite the writing-for-agents page around what people get wrong Co-Authored-By: Claude Opus 5 (1M context) --- .changeset/docs-writing-for-agents-pass.md | 15 +++++ docs/productivity/writing-for-agents.md | 66 +++++++++++++++++----- 2 files changed, 68 insertions(+), 13 deletions(-) create mode 100644 .changeset/docs-writing-for-agents-pass.md diff --git a/.changeset/docs-writing-for-agents-pass.md b/.changeset/docs-writing-for-agents-pass.md new file mode 100644 index 0000000..15553fe --- /dev/null +++ b/.changeset/docs-writing-for-agents-pass.md @@ -0,0 +1,15 @@ +--- +"mattpocock-skills": patch +--- + +Rewrite the `writing-for-agents` docs page around what people actually get wrong. + +The old page was a table of contents for the skill: the two loads, then a bullet per lever. It answered none of the questions the rename and the AMA threads have been generating for months — where `writing-great-skills` went, whether the agent or the human is doing the writing, why you shouldn't just ask Claude to write the skill for you, and how you know when a document is done. + +The rewrite keeps the levers to one compact list and spends the page on the judgement calls instead: + +- **The defining constraint is now stated up front** — the default move is deletion, not explanation, because the reader has already read everything. This is also the answer to "why not let the model write it", so it leads. +- **The scope is stated as a test**, not a list: does an agent read this document and act? Skills, `AGENTS.md`, specs, tickets and runtime prompts all pass it. +- **A "Common questions" section** answers the nine highest-volume ones directly, including the rename, the "streamline" failure where an agent trims for length and cuts behaviour, whether to rewrite documents per model, the skill that only works on the one task it was built from, and the leading-word question from non-native English speakers. +- **"It's working if"** added, led by the sharpest signal: the document gets shorter as it gets better, and duplication is the most reliable sign it was never tested. +- **`Where it fits`** now names `code-review` as the neighbour — standards on code, standards on the prose an agent executes from. diff --git a/docs/productivity/writing-for-agents.md b/docs/productivity/writing-for-agents.md index dda4208..4e5e593 100644 --- a/docs/productivity/writing-for-agents.md +++ b/docs/productivity/writing-for-agents.md @@ -2,31 +2,71 @@ ## What it does -`writing-for-agents` is the reference you write agent-facing documents against — skills, `AGENTS.md` / `CLAUDE.md`, and any doc an agent reaches by a pointer. The packaging differs; the writing does not: the same levers make each one predictable, so the agent takes the same *process* every run rather than producing the same output. +`writing-for-agents` is the reference you write agent-facing documents against — a skill, an `AGENTS.md` / `CLAUDE.md`, a spec, a runtime prompt, any doc an agent reaches by a pointer. The packaging differs; the writing does not: the same levers make each one predictable, so the agent takes the same *process* every run rather than producing the same output. -Formerly `writing-great-skills`. The rename tracks what the reference always was underneath: almost none of it is skill-specific. The universal core — context pointers, the two loads, the information hierarchy, completion criteria, leading words, pruning — applies to any document an agent consumes; the genuinely skill-only mechanics (frontmatter, the model- vs user-invoked choice, router skills) are disclosed to a linked `SKILL-MECHANICS.md` you read only when the document you're writing is a skill. +Its default move is deletion, not explanation. Ask an agent to write instructions for another agent and it spends most of its words explaining what the model already knows — every one of those lines is a **no-op**, paying context and changing no behaviour. This reference is the lens that finds them, which is why it earns its keep at least as often on a document you already have as on a blank file. + +It was called `writing-great-skills` until v1.1. The rename tracks what it always was underneath: almost none of it is skill-specific. The skill-only mechanics — frontmatter, the model- versus user-invoked choice, router skills — are disclosed to a linked `SKILL-MECHANICS.md` you read only when the document in front of you is a skill. ## When to reach for it -The agent reaches for it on its own whenever you're creating or editing a skill, or modifying `AGENTS.md` or `CLAUDE.md` — and you can still type `/writing-for-agents` to pull it up directly. +Type `/writing-for-agents`, or the agent reaches for it on its own when you're creating or editing a skill, or modifying `AGENTS.md` or `CLAUDE.md`. + +Reach for it by hand for everything else an agent has to execute from: docs behind a pointer, specs and tickets, system and AFK prompts. The test is whether an agent reads the document and acts, not who typed it. For working out what a codebase actually contains in the first place, use [grill-with-docs](https://aihero.dev/skills-grill-with-docs) — this reference governs how a document reads, not what it knows. ## The two loads -The concept the whole reference turns on is a pair of budgets every document and pointer spends: +The idea the whole reference turns on is a pair of budgets every document and pointer spends: - **Context load** — the cost of always-loaded material on the agent's window: an `AGENTS.md` line, a skill description, anything sitting in context every turn whether or not it fires. -- **Cognitive load** — the cost on the human: which documents exist and when to reach for each. You are the index. Not a cost to minimise — it's the price of human agency. +- **Cognitive load** — the cost on you: which documents exist, and when to reach for each. You are the index. Not a cost to minimise — it is the price of human agency. -Once you're thinking in these two loads, most authoring decisions — split or don't, inline or disclose, point or push — become the same trade made in different places. +Once you think in these two loads, most authoring decisions — split or don't, inline or disclose, point or push — become the same trade made in different places. -## The other levers +## The levers -- **Context pointers** — the reference held in context that names out-of-context material and encodes when to reach it. A skill description and an `AGENTS.md` line pointing at a doc are the same object; the pointer's *wording*, not its target, decides when and how reliably the agent reaches through it. -- **Information hierarchy** — the ladder from in-file step, to in-file reference, to disclosed reference behind a pointer. **Progressive disclosure** is the move down that ladder so the top stays legible; **co-location** decides what sits beside each piece once placed. -- **Completion criteria** — the clarity and demand of each step's done-condition, and the **legwork** it drives; the defence against **premature completion**. -- **Leading words** — a compact concept already in the model's pretraining (*tight*, *red*, *tracer bullet*) that the agent thinks with while running the document; hunt restatements a single word can retire. -- **Pruning** — single source of truth, relevance, and the no-op test applied sentence by sentence, against **sediment** and **sprawl**. Single source of truth reaches past the document into the environment: a doc restating what's already in `package.json`, a config file, or `--help` output is a **cache** of a lookup that was never expensive, and it's the copy that goes stale. Cache what the agent can't find by looking — the unwritten convention, the reason behind a choice. +- **Context pointers** — the reference held in context that names out-of-context material and encodes when to reach it. A skill description and an `AGENTS.md` line naming a doc are the same object; the pointer's *wording*, not its target, decides how reliably the agent reaches through it. +- **Information hierarchy** — the ladder from in-file step, to in-file reference, to disclosed reference behind a pointer. **Progressive disclosure** is the move down that ladder so the top stays legible. +- **Completion criteria** — the clarity and demand of each step's done-condition, and the **legwork** that demand drives; the defence against **premature completion**. +- **Leading words** — a compact concept already in the model's pretraining (*tight*, *red*, *tracer bullet*) that the agent thinks with while running the document. It anchors twice: execution in the body, invocation in the pointer. +- **Pruning** — single source of truth, relevance, and the no-op test applied sentence by sentence, against **duplication**, **sediment** and **sprawl**. + +## Common questions + +**Where did `/writing-great-skills` go?** +It is this skill, renamed in v1.1. Practitioners were already pointing it at `AGENTS.md`, docs, specs, tickets and runtime prompts long before the name caught up; structure, leading words and pruning turn out to be the craft of any text an agent reads. There is no alias — reinstall under the new name. + +**"Writing for agents" — so the agent does the writing?** +The other way round. You are the author; the agent is the reader. That is the whole difficulty of the genre: you are writing for a reader who has already read everything, so explanation is waste and precision is the entire job. + +**Can't I just ask the agent to write it for me?** +You can, and it will produce something verbose. Left alone the model explains what it already knows, and it will not apply the no-op test or reach for a leading word on its own. Use the reference on the draft — a review pass is where most of its value lands. + +**I asked an agent to trim a document and it cut the functionality.** +Agents told to "streamline" optimise for length, because length is the thing they can see. The no-op test is behavioural, not aesthetic: delete the line and ask whether the agent's behaviour changed. When a sentence fails, delete the whole sentence rather than trim words from it — and settle a disagreement about it by running the document, not by arguing. + +**How do I know when it's done?** +When it works, and you can no longer find duplication, sediment or no-ops. There is no automated eval here; the check is a manual run plus the failure-mode vocabulary as a diagnostic. When a document misbehaves, that vocabulary is also the repair kit — name the failure mode first, then fix that. + +**Should this live in `CLAUDE.md` or somewhere else?** +Ask which load you want to pay. `CLAUDE.md` loads into every session unconditionally; material behind a pointer costs only the pointer's own line until it fires. Anything that applies in one context out of ten is paying context load the nine other times. + +**Do I need to rewrite my documents for each new model?** +Mostly no, and over-fitting to one model is its own trap. Updating for a new model is usually another no-op pass rather than a rewrite. + +**My skill only works on the exact task I built it from.** +The common route — do the work once, then have the agent write it up as a skill — over-indexes on that one run, and the exemplars come out too specific. Keep the run as evidence, then abstract deliberately: strip what belonged to that repo and those files, and write for the class of task. + +**English isn't my first language. Do I lose the leading-word advantage?** +No — finding the word that packs the most behaviour into the fewest tokens is work the reference does for you. It is one of the things it is for. + +## It's working if + +- The document gets shorter as it gets better, and you are surprised how little is left. +- You can point at a leading word and watch it doing work in more than one place. +- Nothing is stated twice, in any form. Duplication is the most reliable sign a document was never tested. +- Reference that only one branch needs sits behind a pointer rather than in the main file. ## Where it fits -This is a reach-for-it-anytime standalone reference — the meta-skill you consult while building the rest of the set, not a step in a chain. When you're unsure which skill or flow fits a task, [ask-matt](https://aihero.dev/skills-ask-matt) routes you over the whole set. +This is a reach-for-it-anytime standalone reference — the meta-skill you consult while building the rest of the set, and the one you point at any document an agent already reads. Its closest neighbour is [code-review](https://aihero.dev/skills-code-review), which holds code to your standards the way this holds the prose an agent executes from. When you're unsure which skill or flow fits a task, [ask-matt](https://aihero.dev/skills-ask-matt) routes you over the whole set.