skill: delegating the writing

the owner's architecture, somebody else's typing, a review in the middle.
set as a standing way of working rather than a per-task decision: when a
feature is agreed and what remains is typing, it goes to an agent.

carries what a brief has to contain — exact paths, a file to copy the
shape from, what must not change, and the commands that verify it — since
an agent that has to ask a question has already cost more than it saved.

and both failures from the first night it was tried: a dead subagent
reported as running twice, because a rejection in the parent had killed the
sidechain hours earlier and nothing said so; and interrupting the parent
interrupting the child.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Officer-Session: 656f5c85-e49a-4f1f-b9f3-042a04b4d043

skills/delegating/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: Delegating the writing
+description: >-
+  Use when a feature has been agreed and somebody has to type it — how to hand the writing to a cheaper
+  agent, what a brief has to contain, and how to review what comes back. Also read it before deciding NOT
+  to delegate, because most of the cost of doing it yourself is invisible until the context runs out.
+version: 1
+---
+
+# Why this exists
+
+The owner's architecture, somebody else's typing, and the owner's reviewer in the middle. That division
+is the whole point: the expensive model should be spending its context on decisions, not on writing out
+six locale files or the same form for the fourth time.
+
+Set as a standing way of working on 2026-08-24. It is not a suggestion to consider per task — when a
+feature is agreed and the remaining work is typing, it goes to an agent.
+
+# What stays here and what goes
+
+**Stays.** The design. Which boundary moves, what a thing is called, what the failure modes are, and
+whether the result is right. If a decision has to be made while the code is being written, the brief was
+incomplete — that is a fault in the brief, not a reason to take the work back.
+
+**Goes.** Everything mechanical and everything wide: a change repeated across many files, translations,
+a form, a migration over a list of call sites, tests for a rule already agreed.
+
+**Does not go.** Anything where a wrong guess is expensive and quiet — permission checks, credential
+handling, anything that deletes. Not because a smaller model cannot write them, but because reviewing
+them properly costs as much as writing them, so nothing is saved.
+
+# The brief
+
+An agent that has to ask a question has already cost more than it saved. So the brief carries:
+
+- **The exact files**, by path. Not "the locale files" — list them.
+- **The pattern to follow**, by pointing at a file that already does it. "Same shape as `pt-PT.json`" is
+  worth more than any description.
+- **What must not change.** Key names, public exports, anything another file imports.
+- **How it verifies itself**: `bunx tsgo`, `bun test`, `bunx prettier --write <the paths it touched>`.
+  Say that a red typecheck is not done, or it will report success with a broken tree.
+- **What done looks like**, in one sentence it can check itself against.
+
+Run it in the background and carry on. A brief good enough to run unattended is the same brief that makes
+the result reviewable.
+
+# Reviewing what comes back
+
+**Read the diff, not the summary.** The summary is written by the thing being reviewed. `git diff` is not.
+
+**Run the checks yourself.** `bunx tsgo && bun test` in the real tree. An agent reporting green has
+reported what it believes.
+
+**Then it is yours.** It goes out under your commit and your name, so a mistake in it is not the agent's
+mistake. Review it as if you had typed it, because as far as the history is concerned you did.
+
+# What went wrong the first time, so it does not go wrong again
+
+Both of these are from one night, 2026-08-24.
+
+**A dead agent was reported as running, twice.** A subagent is a sidechain in the parent session, and a
+tool rejection in the parent had killed it about four hours earlier. Nothing said so and the parent kept
+answering "still running" when asked. **Never report a subagent's state from memory — look.** If the
+result is not in the tree, it did not happen.
+
+**Interrupting the parent interrupts the child.** Stopping the session to say something also stops the
+work it was waiting on. Worth knowing before assuming a long silence means progress.