dispatch

Files (1)

• SKILL.md

SKILL.md (first lines)

# Dispatch — Parallel Task Execution

Execute multiple independent issues concurrently via subagents, each running the `implement` skill.

**Use when** issues from `write-todo` touch different files with no shared state. **Do not use** when issues share files or depend on each other — sequential `implement` is safer.

## Process

### 1. Scan Issues

Read the issues produced by `write-todo`. Group them by independence:

- **Independent:** Different files, no shared state, no sequential dependency
- **Dependent:** Same file, shared state, or issue #2 needs issue #1 completed first

### 2. Confirm

Present to the user:

```
3 issues can run in parallel (independent files):
  #1: Add RegisterHandler       → auth/register.go
  #2: Add PaymentValidator      → payment/validate.go
  #3: Refactor error messages   → utils/errors.go

1 issue is dependent:
  #4: Add auth middleware        → auth/middleware.go (depends on #1)

Dispatch 3 parallel agents for #1, #2, #3?
```

Wait for confirmation before dispatching.

### 3. Dispatch Subagents

For each independent issue, launch a subagent with curated context:

- The full issue body and acceptance criteria
- The target file path
- Instruction: "Use the `implement` skill to execute this issue. Do NOT modify files outside the scope of this issue."

Dispatch all subagents in parallel.

### 4. Collect and Integrate

When all subagents return:

1. **Review each result** — did each subagent complete successfully?
2. **Check for conflicts** — do any commits touch the same lines?
3. **Run full test suite** — verify all changes work together
4. **Handle failures** — if a subagent failed, run that issue sequentially with `implement`

### 5. Commit

If all results are clean and tests pass, all subagent commits are already in place. No additional commit needed — each subagent committed independently.

## Next Steps

After integration, suggest `code-review` for the combined changeset.

## Anti-Patterns

- **Sharing files** — two subagents editing the same file will conflict. Run sequentially.
- **Too many agents** — more than 4-5 parallel agents increases conflict risk without proportional speedup.
- **Broad scope** — each subagent should touch 1-2 files max. Break large issues before dispatching.

From atalariq/skills, MIT.

More from atalariq/skills