Writing For Agents

---
name: writing-for-agents
description:
  Writing documents for agents. Use when creating or editing skills, or
  modifying AGENTS.md or CLAUDE.md.
---

# Writing for agents

Reference for writing any document an agent consumes - a skill, an `AGENTS.md` /
`CLAUDE.md`, a doc reached by a pointer. The packaging differs; the writing does
not: the same levers make each one predictable - the agent taking the same
_process_ every run, not producing the same output.

When the document you're writing is a skill, read
[`SKILL-MECHANICS.md`](SKILL-MECHANICS.md) for frontmatter, invocation choice,
and router skills.

## Context pointers

A **context pointer** is a reference held in the agent's context that names
material outside the context and encodes the condition for reaching it. A
skill's description is one. A line in `AGENTS.md` naming a doc is the same
object. The pointer's _wording_, not its target, decides when the agent reaches
the material - and how reliably. A must-have target behind a weakly worded
pointer is a variance bug: sharpen the wording first, and inline the material
only if sharpening fails.

A pointer does two jobs - state what the material is, and list the **branches**
that should trigger reaching it (a branch is a distinct case the document
handles, so different runs take different paths through it). Every word of an
always-loaded pointer costs on every turn, so it earns even harder pruning than
the body:

- **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. Collapse them and keep only distinct branches.
- **Cut identity the body already carries.**

## Load budgets

Every document and pointer you add spends from these budgets:

- **Context load** - the cost of material sitting in the agent's window every
  turn, spending tokens and attention whether it fires.
- **Cognitive load** - the cost on the human: which documents exist and when to
  reach for each. The human is the index. Not a cost to minimise - it is the
  price of human agency; spend it where human judgement matters, remove it where
  it does not.

Material reached only through a pointer escapes context load at the price of the
pointer's own line. Material with no pointer at all rides entirely on cognitive
load.

## Information hierarchy

A document is built from two content types - **steps** (the ordered actions the
agent performs) and **reference** (definitions, rules, facts consulted on
demand). They mix freely. A document can use either type alone or combine them.
The core decision is where each piece sits on 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. Often a legitimately flat
   peer-set (every rule of a review on one rung), which is a sound arrangement.
3. **Disclosed reference** - pushed out into a separate file, reached by a
   context pointer, loaded only when the pointer fires. Spans a sibling file in
   the same folder through fully external reference that lives anywhere and any
   document can point at.

Push too little down and the top bloats. Push too much and you hide material the
agent needs. That tension is the whole decision.

**Progressive disclosure** moves material down the ladder - out of the main file
and behind a pointer - so the top stays legible. Not primarily a token
optimisation: it is how the hierarchy is protected. Branching is the cleanest
disclosure test: inline what every branch needs, and push behind a pointer what
only a subset of branches reaches. When a document has steps, in-file reference
that should be disclosed buries them and turns attending to them into a
coin-flip - a variance and legibility lever.

**Co-location** is the within-file companion: where the ladder decides _how far
down_ a piece sits, co-location decides _what sits beside it_ once there. Keep a
concept's definition, rules, and caveats under one heading instead of scattering
them, so reading one part brings its neighbours with it. A well-co-located
document reads like documentation written for the agent because its material is
grouped. (Distinct from duplication: that repeats one meaning in two places.
Scattering fragments one meaning across multiple locations.)

**Sprawl** is a document that is too long, even when every line is live and
unique. Attention thins across the excess, and every extra line is one more to
keep relevant. Use the ladder to disclose reference behind pointers. Split by
branch or sequence so each path carries only what it needs.

## Steps and completion criteria

Every step ends on a **completion criterion** - the condition that tells the
agent the work is done. Assess its clarity and demand.

- **Clarity** - can the agent tell done from not-done? A vague bound
  ("understanding reached") invites **premature completion**: ending the step
  before it is fully done, attention slipping to _being done_. The visible steps
  still ahead - the **post-completion steps** - supply the pull. The criterion's
  clarity is the resistance. Defend in order: **sharpen the bound first** (local
  and cheap); only if it is irreducibly fuzzy and you observe the rush, hide the
  later steps by splitting the sequence - and hiding only works across a real
  context boundary (a hand-off or a subagent dispatch. An inline call leaves the
  later steps in context and clears nothing).
- **Demand** - how much it requires. "Every modified model accounted for" forces
  thorough work where "produce a change list" does not. Demand drives
  **legwork** - the digging the agent does within the work, latent in the
  wording instead of written as its own step - and it is not step-bound: "every
  rule applied" binds a body of flat reference in the same way that "every step
  done" binds a sequence, which is how an all-reference document still carries
  an exhaustiveness bar.

The strongest criteria are both checkable and exhaustive.

## When to split

Splitting one document into two spends one of the two loads, so split only when
the benefit outweighs the added load:

- **By sequence** - split a run of steps where the post-completion steps tempt
  the agent to rush the one in front of it. Keeping them out of view drives more
  legwork on the current task. Beware the reverse: merging sequences exposes
  each step's later steps to what follows, inviting premature completion.
- **By invocation** - skill-specific: see
  [`SKILL-MECHANICS.md`](SKILL-MECHANICS.md).

## Leading words

A **leading word** is a compact concept already living in the model's
pretraining that the agent thinks with while running the document (_lesson_,
_fog of war_, _tracer bullets_). Repeated as a token, never as a sentence, it
accumulates a distributed definition and anchors a whole region of behaviour in
the fewest tokens, by recruiting priors the model already holds. Coining your
own works if you define it clearly, but a made-up word recruits no priors - you
pay in definition tokens what a pretrained word gives free. Reach for an
existing word first.

It anchors twice. In the body, _execution_: the agent reaches for the same
behaviour every time the word appears, and inside flat reference it focuses
attention on a class of thing to look for. In a pointer, _invocation_: when the
same word appears throughout your prompts and project material, the agent links
that shared language to the material and reaches it more reliably.

Hunt for opportunities to refactor with leading words. A triad spelled out at
three sites, a pointer spending a sentence to gesture at one idea - each is a
passage begging to collapse into a single token:

- "fast, deterministic, low-overhead" → _tight_ (a _tight_ loop).
- "a loop you believe in" → _red_ - a fuzzy gate becomes a binary observable
  state (the loop goes _red_ on the bug, or it doesn't).

You win twice: fewer tokens, and a sharper hook for the agent to hang its
thinking on. Assume every document is carrying restatements that leading words
retire - go find them.

**Negation** is the failure mode beside this lever: steering by prohibition
drags the forbidden behaviour into context and makes it _more_ available, not
less. _Don't think of an elephant_, and the elephant is all there is; the
negation is a weak modifier the strongly-activated concept overruns, so the ban
half-reads as an instruction to do the thing. Prompt the **positive** - state
the target behaviour ("write one-line comments") so the banned one is never
spoken. Use a prohibition only as a hard guardrail you cannot phrase positively;
even then, pair it with the positive target so the agent focuses on what to do.

## Pruning

- Keep each meaning in a **single source of truth**: one authoritative place, so
  changing the behaviour is a one-place edit. **Duplication** - the same meaning
  in more than one place - costs maintenance and tokens, and inflates a
  meaning's prominence on the ladder past its real rank. (The accidental inverse
  of a leading word, which repeats a token on purpose, never the meaning.)
- The **environment** is a source of truth too - `package.json` scripts, config
  files, the directory layout, `--help` output - and a document that restates it
  is a **cache**: a copy of a lookup, earning its load only when the lookup is
  expensive. Cache the unwritten conventions and reasons behind choices. Cache
  hidden constraints and gotchas no config confesses. Leave the one-file,
  one-command lookups to the environment, where they cannot go stale.
- Check every line for **relevance**: does it still bear on what the document
  does? A line loses relevance by never bearing on the task (mere exposition, or
  a branch that should be disclosed) or by going stale as the behaviour or world
  it describes changes. Shorter documents are easier to keep relevant. Without a
  pruning discipline the default fate is **sediment**: stale layers that settle
  because adding feels safe and removing feels risky, until you must core down
  through them to find what is still live.
- Hunt **no-ops** sentence by sentence: an instruction the model already obeys
  by default pays load to say nothing. Ask whether it changes behaviour versus
  the default. This test is model-relative. People who assess a no-op
  differently hold different assumptions about the default. Run the document to
  settle the assessment. When a sentence fails, delete the whole sentence
  instead of trimming words from it. The test also grades leading words. A word
  too weak to beat the default (_be thorough_ when the agent is already
  thorough-ish) is a no-op. Replace it with a stronger word such as
  _relentless_.