dispatching
/dispatching
Dispatch discipline for work that can run in parallel. Use when several pieces of work could run at once, when work needs an isolated workspace to run in, when writing the brief a dispatched agent will run on, or when dispatched work reports back and has to be accepted.
- Author
- gregoryho ↗
- Repository
- arcforge ↗
- Licence
- MIT
- Last repository change
- 26.10.2026
Assessment and security
- Files in this package
- 3
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Dispatch discipline for work that can run in parallel. Use when several pieces of work could run at once, when work needs an isolated workspace to run in, when writing the brief a dispatched agent will run on, or when dispatched work reports back and has to be accepted.
Original author description
Dispatch discipline for work that can run in parallel. Use when several pieces of work could run at once, when work needs an isolated workspace to run in, when writing the brief a dispatched agent will run on, or when dispatched work reports back and has to be accepted.
How it works
- Step 1 — Prove the pieces are independent
- Step 2 — Give every writer its own worktree
- Step 3 — Write the dispatch card
- Step 4 — Accept on evidence, never on the report
- Step 5 — Merge back
- Choosing the substrate
- What stays in this session
- Red flags
SKILL.md preview
--- name: dispatching description: Dispatch discipline for work that can run in parallel. Use when several pieces of work could run at once, when work needs an isolated workspace to run in, when writing the brief a dispatched agent will run on, or when dispatched work reports back and has to be accepted. --- # Dispatching Parallel work fails in four places, in order: the split was wrong, the workspaces overlapped, the brief was incomplete, or the report was believed. Each step below closes one of them. Splitting work you could have done yourself in one pass costs more than it saves. Dispatch when the pieces genuinely do not need each other, or when one of them needs a fresh context to be judged honestly. ## Step 1 — Prove the pieces are independent Independent means all three: no shared dependency, no shared file, and each piece understandable without reading the others. Two failures in the same module, or a fix that might turn out to fix the others too, are one piece — dispatch them as one. Write the split down before dispatching: which piece owns which files. A piece whose file list you cannot state is not scoped yet. - [ ] Done when every piece has a file list and no file appears on two lists. Do not pre-negotiate conflicts beyond that list. Predicting which lines will collide is guesswork that costs more than resolving the collision later. ## Step 2 — Give every writer its own worktree Two agents writing into one checkout will overwrite each other's edits and stage each other's files. Isolation is not a precaution here, it is the precondition: if the pieces write, each gets its own worktree. ```bash arcforge worktree add <name> [--branch <b>] [--from <ref>] [--setup] --json arcforge worktree list --json arcforge worktree remove <name> [--force] ``` Read the `path` field out of the JSON. The location is derived by the engine, so a path you construct, remember, or guess will be the wrong one and everything downstream that looks for the worktree will miss it. `--setup` runs the project's installer inside the new tree; `list` annotates each entry by kind, and `cd` to a `path` is how you enter one — there is no switch command. Already inside a worktree? Work there. Never nest a worktree inside a worktree. A path the user names explicitly overrides all of this — honor it with raw git. - [ ] Done when each dispatched writer has a worktree path read from CLI JSON. Read-only pieces — research, review, investigation — need no worktree; they can share the checkout because they do not write to it. ## Step 3 — Write the dispatch card A dispatched agent starts with an empty context and its own working directory. It cannot see your reasoning, your open files, or what you meant. Everything it needs goes in the card, in text: | Slot | What breaks without it | |---|---| | Task, one piece only | The agent widens scope to whatever looks related | | Absolute paths, not names | A relative path resolves against the agent's cwd, not yours | | Constraints | Refactors outside scope arrive as surprise diffs | | Acceptance criteria, verbatim | The agent decides for itself what done means | | Return format | Reports arrive in four shapes and cannot be compared | | Authority to finish | The agent stops mid-task waiting for a go-ahead you never send | Paste the text, never a file path to the text. Dispatch the whole batch in one message so the pieces actually run concurrently rather than in sequence. The wording of the authority grant, the return format, and how to word a retry after a rejection are in `references/dispatch-card.md` — open it when writing the first card of a batch or when a dispatched agent stalls waiting for permission. - [ ] Done when every card names its files absolutely and states its acceptance criteria. ## Step 4 — Accept on evidence, never on the report A completion report is a claim. It is written by the agent whose work is under judgment, from the context that produced the work, and it is wrong in the specific way that matters: it describes what the agent intended. Check the claim against the tree — read the changed files, run the project's own checks, diff the branch. A green suite is not compliance either: it only proves the tests that exist pass, and the criterion nobody wrote a test for fails silently under a green run. For anything larger than a single fix, hand acceptance to a fresh-context agent rather than doing it inline. Your memory of the dispatch is exactly what makes an inline check unreliable — you already believe roughly what was built, and the check turns into confirming that belief. Two checks, dispatched separately: does the delivered code satisfy every criterion, and does the suite pass from an empty context. Both pass, accept. Either fails, reject. Never overrule a rejection by reasoning about it. Either produce the evidence that the finding is wrong, or send the rejection back. `references/acceptance.md` has the two check prompts, what a rejection has to contain to be actionable, and how to tell a bad delivery from a bad criterion. - [ ] Done when every accepted piece has file-level or command-output evidence, produced by someone other than its author. ## Step 5 — Merge back Merge accepted pieces onto one branch, one at a time, running the project's checks after each. A conflict at this point means Step 1 was wrong — resolve it, and fix the split before the next batch rather than resolving the same collision again. That branch is the deliverable. Do not promote it to the default branch and do not revert failed pieces on your own; both are the user's call. Remove each accepted piece's worktree with `arcforge worktree remove <name>`, keep the worktrees of failed ones so they can still be inspected, and run the removal from the main checkout — a process cannot delete the directory it is standing in. `/finishing` takes the branch from here. - [ ] Done when the branch carries every accepted piece, the checks are green, and only failed pieces still have worktrees. ## Choosing the substrate | Situation | Substrate | |---|---| | Independent pieces, you drive them yourself | Subagents, one per piece, one batch | | Larger streams of work, you stay present to answer questions | Agent teammates, one per stream, lead session coordinates | | You are leaving and nobody will answer questions | An unattended loop — see the `looping` skill | | One piece of work with a list to work through | No dispatch — see the `executing` skill | The line between the middle two is **attendance, not risk**: risky work with you watching is still teammates; safe work with you gone is still a loop. Cap a team at five and queue the rest; past that, coordinating costs more than the parallelism returns. Create the team before dispatching into it, dispatch the batch in parallel, and if some spawns fail, retry only those, sequentially — that failure is a startup race, not a limit on team size. Manual parallelism — "open five windows and switch between them" — is what this skill exists to replace. Offering it as the answer hands the coordination back to the user. ## What stays in this session A dispatched agent's processes die when that agent finishes. Anything long-running — a benchmark, a full suite, a measurement run, a watcher — belongs in the session that stays alive, no matter how appealing it is to hand off the waiting. Dispatch the work that produces a result; keep the work that produces it *over time*. ## Red flags | About to | Instead | |---|---| | Dispatch pieces that might fix each other | Step 1 — that is one piece | | Let two writers share a checkout | Step 2 — one worktree each | | Run `git worktree add` yourself | Step 2 — the CLI derives the path; raw git breaks list and removal | | Type a worktree path from memory | Step 2 — read `path` from the CLI's JSON | | Work around a CLI failure by hand | Report blocked; a failing CLI is a real problem, not a detour | | Send a card that references "the file we discussed" | Step 3 — absolute paths, pasted text | | Accept because the report says tests passed | Step 4 — run them yourself, from outside | | Skip the acceptance check because you know what was built | Step 4 — that knowledge is the bias | | Overrule a rejection because it looks wrong to you | Step 4 — evidence, or send it back | | Merge everything at once and run the checks once | Step 5 — one at a time | | Hand a long benchmark to a subagent | It dies with the agent — run it here | | Say sequential is safer | It is slower; independence is what makes parallel safe |
Files in this package (3)
- SKILL.md 8 KB
- references/acceptance.md 6 KB
- references/dispatch-card.md 3 KB
Versions
The database has no other skills named dispatching.
Database snapshot: 13.11.2026 · package version e24be9343589 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100coordinator-dispatching-work
Use when starting an epic, dispatching to an implementer, creating a worktree for an agent, or spawning a sub-agent. Loads coordinator-specific discipline for kicking off implementation work. - 100coordinator-dispatching-work
Use when starting an epic, dispatching to an implementer, creating a worktree for an agent, or spawning a sub-agent. Loads coordinator-specific discipline for kicking off implementation work." # source: claude-plugin/skills/coordinator-dispatching-work/SKILL.md # generated-by: scripts/sync-skills.sh - 100parallel-agent-work
Decide whether to split work across subagents or agent teams, and run the split safely. Use when dispatching parallel agents, or when deciding whether to parallelize at all. Covers branch isolation, when not to split, and what a dispatched agent owes when it finishes. - 90brief
Use when writing a work handoff for another agent, session, or worker, or updating a recipient about a relevant change in parallel work. - 90dispatching-parallel-agents
Plan, implement, or review dispatching parallel agents work in an existing codebase with compatibility, security, and verification controls. Use when the user explicitly requests dispatching parallel agents work. - 90dispatching-parallel-agents
Use when multiple frozen subtasks have non-overlapping write sets and can be implemented or reviewed in parallel.