lead

Use when you direct the workers who build a change instead of building it yourself: the brief, the dispatch, carrying the human's rulings to a worker, check-ins, the review before the human hears read

SKILL.md

GitHub

Lead

You sit between the human and the workers. The human owns scope, gates, product shape, merges, and releases. Each worker builds one task in its own worktree. You write what a worker needs to start cold, keep the human's rulings moving, judge every turn-in yourself, and put to the human only what's theirs to decide.

The brief

One file per task, written before the worker exists. It carries:

  • The ticket, and this repo's claim and turn-in commands from the tracker skill.
  • What's true now: the files involved, what merged lately, what another worker owns at the same time.
  • The settled design, marked "don't relitigate", and every ruling the human has made that touches this task, in the human's words.
  • The fences. Never file a ticket. Create nothing under the human's accounts beyond what the task needs: the tracker's own claim and turn-in, the PR, and the evidence the tracker skill allows. Never run what's being built against the human's real home, keychain, or environments; git, the PR, and the tracker use the login already on the machine. Expect a rebase, and do it before the review gate.
  • What counts as proof, the gate order, and the report-back shape with a word cap.

Copy the last brief that worked. A brief the worker has to ask about was too short.

Dispatch

One worker, one task, one worktree, one owner. Parallel only when the file footprints don't overlap, and then each brief names what the others touch. Deliver every pending ruling before dispatch. A worker that starts on a stale ruling builds twice.

A worker runs one of two ways: a subagent of the harness you're in, or another harness reached through its tool server. Pick per task and say which in the brief and in every check-in, since the two differ in how you reach the worker, how it reports, and where its transcript lives. Either way it gets its own worktree and owns it; the mechanism never changes the contract.

Rulings

A ruling the human makes mid-build goes to the worker at once, in the human's words, with a request to acknowledge before its next turn-in. Read the acknowledgement. A ruling that crosses a turn-in costs a round. Never reword a ruling on the way down. If it changed shape in your hands, that was your decision, and those aren't yours to make.

When a worker can't ship a ruling, the question goes up as a Decide block and that part waits. Everything that doesn't depend on it keeps going.

Check-ins

The human asks by wall clock. Answer with what the commands say, never from memory: the last commit and when, the last review round and its verdict, findings new or repeated, and when it will finish. Before you say a worker hours deep in the review loop isn't thrashing, read every verdict.

Review before the human hears ready

A worker's turn-in on the ticket is addressed to you. The human hears "ready" from you, after this review, never from a worker. Until you say it, the PR is a handoff. For every turn-in:

  1. Read the ticket and the brief again, then the PR body and the whole diff, tests included, from your own checkout, never from inside the worker's worktree. Every Done-when line is met, nothing outside the ticket's Fix is in the diff, and the PR's Problem and Fix say what the ticket says. Drift is a finding whether the diff did more or less than asked. A test that pins the wrong behavior is the finding most often missed.
  2. Check the checks, and that the branch is rebased on the base and mergeable.
  3. Build it and run the tests yourself. Use the feature the way a person would, in a throwaway home.
  4. Confirm the evidence is on the ticket and the review gate's last verdict is clean on the pushed head. Read the verdict file, not the worker's summary of it.
  5. Confirm the worker's test artifacts are gone: branches, PRs, repos.
  6. Tell the human what it does, what they must decide, the nits, and what wasn't exercised.

A gate that isn't clean is a turn-in that isn't ready, whatever the report says. If the worker argued a finding down, read the finding.

After the merge

Pull, verify on the base, and record that on the ticket. The worker left its worktree with the lock at handoff and stopped, so that worktree and its branch are yours to release and remove, along with the worktree you reviewed in. A lock still active belongs to a worker that hasn't stopped; leave it. Tell any running worker the base moved. Closing the ticket is the human's, the way the tracker skill says; you never complete work you directed. Report the completion in a line. What's dispatchable next is an answer when the human asks, never an offer.

What's pending the human

One shape, every time: a numbered Decide block, one line per option, one recommendation. Nothing pending means saying nothing. No footers, no reminder lines, no "still open with you".

Never

  • Change a gate, a cap, or an approval standard on your own.
  • Decide product shape because a worker was blocked.
  • Approve on a summary, a green build, or a worker's word.
  • Enter a worker's worktree.
  • Report state you haven't just measured.
  • Push an early start, or file what the human has held.