This task asks me to write guidance and a verification plan. But the Iron Law applies: **NO SKILL WITHOUT A FAILING TEST FIRST** — and this applies to edits to existing skills too. So before I give you guidance text, let me flag what's wrong with the framing and do this properly.

## First: classify the failure

"Plans are bloated" is a **wrong-shaped output** problem, not a discipline problem. The agent isn't skipping a rule under pressure — it's producing output with the wrong shape (too long). Per *Match the Form to the Failure*, this means:

- **Right form:** a positive recipe/contract stating what a plan IS — its parts, in order.
- **Wrong form:** prohibitions like "don't be verbose," "never restate the spec," "keep it short." These measurably backfire — under a competing incentive (be thorough/clear), agents negotiate with "don't X" and produce *more* of the unwanted content.

A naive "add a max length / stop being verbose" instruction is exactly the wrong-form trap. So I won't write that.

## Second: I can't hand you final text yet — I haven't seen the baseline fail

I don't know *why* the plans are 20k characters. Bloat has different causes that need different fixes:

- Restating the spec/context verbatim?
- Narrating reasoning inline?
- Over-explaining each step?
- Including code that belongs in the implementation, not the plan?
- Genuinely large scope (in which case length is correct and the complaint is wrong)?

Writing guidance before reading actual bloated plans = writing production code before the test. The fix depends entirely on what the baseline does.

## What I'd actually produce

**(1) Guidance text — DRAFT, contingent on baseline findings**

I'll show the *form* I'd use (a contract/recipe), with placeholder slots to fill once I've seen the failure:

```markdown
## What a plan contains

A plan is a sequence of tasks. Each task is:

- **Goal** — one sentence: what is true when this task is done.
- **Files** — the specific files touched.
- **Steps** — numbered, imperative. One line each. No rationale.
- **Verification** — the command or check that proves the task done.

Reference the spec/brief by link; do not restate it.
Put code in the implementation, not the plan — name the change, don't write it.
```

Note this is structural and positive (REQUIRED slots), with conditionals on observable predicates ("reference the spec by link") rather than "don't restate." The exact slots get tuned to whatever the baseline actually over-produces. I am **not** treating this draft as deployable.

**(2) Verification plan (this is the real deliverable right now)**

**RED — baseline, before writing anything final:**
1. Collect 5+ real 20k-char plans teammates flagged.
2. Categorize where the characters go (restated spec? inline narration? code? scope?). This tells me the actual failure mode.
3. Micro-test: system prompt = current writing-plans skill, user message = a realistic planning task. 5+ reps, no-guidance control. Confirm plans actually come out bloated *and* identify the dominant bloat source. If the control isn't bloated, there's nothing to fix.

**GREEN — write minimal guidance addressing the observed bloat:**
4. Tune the contract's slots to suppress the specific bloat source found in RED.
5. Re-run the same micro-test with the new guidance. 5+ reps. Read every output manually.
6. Check **variance**: when the contract binds, reps converge on the same shape. Five different lengths/structures = wording isn't binding yet.

**REFACTOR:**
7. Head-to-head: recipe form vs. a prohibition form ("keep plans short, don't restate spec") vs. control. Confirm the recipe wins and the prohibition doesn't backfire — don't assume it.
8. Verify plans are now appropriately scoped, **not** that they hit an arbitrary character count. Guard against the opposite failure: dropping verification steps or file lists to save length.
9. Deploy only after micro-tests converge; commit + push.

## Bottom line

I won't hand you finished guidance, because that would be writing the skill before watching it fail. Give me access to the flagged plans (or let me generate baselines), and I'll run RED first. The deliverable you can have *now* is the form decision (recipe, not prohibition) and the verification plan above.