Before I write the guidance, let me classify the failure — that determines the form, and the form determines whether the guidance helps or backfires.

## Classifying the failure

This is **not** a discipline failure. The controller isn't knowingly skipping a rule under pressure. It's a **wrong-shape output** problem: the controller produces a dispatch prompt, but stuffs it with re-typed exact values that should instead be *referenced* from the brief file the subagent already reads.

Per "Match the Form to the Failure":

- Wrong shape → **positive recipe / contract** stating what the dispatch prompt IS.
- A prohibition ("never re-type exact values", "don't copy magic strings") is the *wrong* form here. Under the competing incentive controllers actually feel — "make the dispatch prompt self-contained so the subagent has everything" — a prohibition reopens negotiation and measurably produces *more* of the unwanted content. There's also a real exemption trap: "don't copy values, except when needed for clarity" scopes badly and dilutes compliance.

There's also a conditional element: the reference only works *if* a brief file exists. So the recipe should key off that observable predicate.

I have **not** written the guidance as deployable yet — per the Iron Law, no skill edit ships without a failing test first. Below is the candidate text and the verification plan that must pass before it goes in.

## (1) Candidate guidance text

> ### Dispatch prompts point to the brief; they don't re-type it
>
> Each task has a brief file containing the exact values the implementer needs — magic strings, version numbers, function signatures, paths, schemas. The subagent reads the brief directly.
>
> **A dispatch prompt is made of three parts, in order:**
> 1. **The task**, in your own words — what to build and why.
> 2. **A pointer to the brief** — name the brief file and tell the subagent to read it for exact values.
> 3. **Judgment the brief can't carry** — sequencing, constraints, what "done" looks like, gotchas.
>
> When an exact value belongs in the prompt, write the pointer instead:
> "Use the function signature in `brief.md`" — never the signature itself.
> "Pin the version specified in `brief.md`" — never the version number itself.
>
> If for a given task there is no brief file, say so explicitly in the prompt and treat that as a gap to fix in the task setup — don't compensate by re-typing values from the spec.

Notes on form:
- It's a **contract** (three named parts, in order), not a "don't copy" list — nothing to negotiate; a prompt either has the shape or it doesn't.
- The value-handling rule is phrased as **"write the pointer instead"** (a positive substitution), with the pointer→value pairing shown by example.
- The brief-missing case is a **conditional on an observable predicate** (brief file exists or not), not an exemption clause bolted onto a prohibition.

## (2) Verification plan before deploying

**Iron Law:** I will not commit this until baseline shows the failure and the guidance fixes it.

**RED — establish baseline (no guidance):**
- Realistic system prompt: the current SDD skill as-is, controller role, a task with a brief file that contains specific values (a function signature, a pinned version, a magic string).
- User message: "Write the dispatch prompt for the implementer for task N."
- No-guidance control, 5+ reps. Confirm controllers actually re-type exact values into prompts. If they don't, there's nothing to fix — stop.
- Record verbatim how/where values get copied.

**Micro-test the wording (cheap, before full scenarios):**
- Same setup + candidate guidance in the system prompt, 5+ reps.
- Read **every** prompt by hand — automated "does it contain the version string" counts will false-positive on the pointer phrasing ("version specified in brief.md") and false-negative on paraphrased values.
- Score each rep: (a) does the prompt point to the brief instead of re-typing values? (b) does it keep the three-part shape? (c) **variance** — do the 5 reps converge on the same shape, or scatter? Scatter = wording not binding, tighten before adding words.

**Head-to-head form check (the key risk):**
- Run a **prohibition-worded variant** ("never re-type exact values from the spec; the subagent reads the brief") against the recipe variant, both vs. control, 5+ reps each.
- Hypothesis to confirm: prohibition ≥ control on re-typing (backfire), recipe < both. If the recipe doesn't beat the prohibition, my form classification is wrong and I revise, not deploy.

**Edge cases to probe:**
- A task with **no brief file** → does the controller flag the gap, or silently re-type from spec? (tests the conditional)
- A value the controller might argue is "too small to reference" → does the recipe hold, or does an implicit nuance clause leak in?

**GREEN/REFACTOR:**
- Recipe wins head-to-head, low variance, edge cases handled → deploy, commit, push.
- New evasion appears (e.g., re-typing under a "for the subagent's convenience" framing) → adjust the recipe's wording, re-test. Do not add a prohibition to patch it.

Only after the recipe variant beats both control and the prohibition variant does this go into the skill.