Skip to content
Back to search

dispatch

SkillWorks with Claude CodeGitHub

A Claude Code skill that 10x's your effective context window by dispatching tasks to background AI workers.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/bassimeledath-dispatch/badge.svg)](/listings/bassimeledath-dispatch)

HTML

<a href="/listings/bassimeledath-dispatch"><img src="/api/listings/bassimeledath-dispatch/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx skills add bassimeledath/dispatch -g     # user-level (all projects)
npx skills add bassimeledath/dispatch        # project-level (team-shared)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 215 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1>/dispatch&nbsp;<img src="skills/dispatch/assets/logo.svg" alt="Dispatch logo" height="56" /></h1>
  2. **Dispatch 10x's Claude Code's effective context window size.** Instead of filling your session with implementation, `/dispatch` turns it into a lightweight orchestrator — work fans out to background agents, each with their own full context window.
  3. <p align="center">
  4. <img src="skills/dispatch/assets/before-after.jpg" alt="Before: a single session where context fills up fast doing tasks sequentially, with the user overwhelmed tracking everything. After: dispatch keeps your main session lean while workers execute in parallel with their own fresh contexts, and the dispatcher carries the cognitive load." width="900" />
  5. </p>
  6. > **Without dispatch:** You ask Claude to review code, refactor a module, write tests, and update docs. Each task fills the context window. By task 3, Claude is losing track. By task 5, you're starting a new session.
  7. >
  8. > **With dispatch:** You describe all 5 tasks. Workers execute in parallel with fresh contexts. Your main session stays lean. Questions surface to you when needed — no polling, no context lost.
  9. ```
  10. /dispatch use sonnet to find better design patterns for the auth module
  11. ```
  12. ---
  13. ## Why dispatch
  14. ### Your session stays lean
  15. Dispatch inverts the usual model: the main session becomes a **mediator**, not the thinker. It writes a checklist and hands it off. The actual implementation — reading code, reasoning about edge cases, writing tests — happens in fresh worker contexts that each get their own full window. Your main session's context is preserved for orchestration.
  16. ### The dispatcher carries the cognitive load
  17. With `claude --background`, multiple terminals, or fire-and-forget agent runners — _you_ are the orchestrator. You track what's running, check on progress, notice failures, and context-switch between outputs.
  18. With dispatch, the AI dispatcher tracks all workers, surfaces questions, reports completions, handles errors, and offers recovery. Your job reduces to: **(a)** describe what you want, **(b)** answer questions when asked.
  19. ### Workers ask questions back
  20. When a `/dispatch` worker gets stuck, it doesn't silently fail or hallucinate. It **asks a clarifying question** — the dispatcher surfaces it to you, you answer, and the worker continues **without losing context**. No restart, no re-explaining, no lost work.
  21. ```
  22. Worker is asking: "requirements.txt doesn't exist. What feature should I implement?"
  23. > Add a /health endpoint that returns JSON with uptime and version.
  24. Answer sent. Worker is continuing.
  25. ```
  26. ### Non-blocking — you never wait
  27. The moment a worker is dispatched, your session is **immediately free**. Dispatch another task. Ask a question. Write code. Workers run in parallel and results arrive as they complete.
  28. ### Any model, one interface
  29. Mix models per task. Claude for deep reasoning, GPT for broad generation, Gemini for speed. Reference any model by name — if it's not in your config, `/dispatch` auto-discovers and adds it. If multiple models are named in one prompt, dispatch uses the last one mentioned. If no model is specified, dispatch confirms your default before proceeding.
  30. ```
  31. /dispatch use opus to review this PR for edge cases
  32. /dispatch use gemini to refactor the config parser — it's getting unwieldy
  33. ```
  34. ---
  35. > **Requires [Claude Code](https://docs.anthropic.com/en/docs/claude-code) as your host session.** Dispatch is a skill that runs _inside_ Claude Code — the host plans tasks and spawns workers. Other CLIs like [Cursor](https://docs.cursor.com/) and [Codex](https://github.com/openai/codex) work as **workers only** (background agents that execute subtasks).
  36. ## Install
  37. ```bash
  38. npx skills add bassimeledath/dispatch -g # user-level (all projects)
  39. npx skills add bassimeledath/dispatch # project-level (team-shared)
  40. ```
  41. ## How it works
  42. 1. You run `/dispatch task description`
  43. 2. A checklist plan is created — *the only context your main session needs*
  44. 3. A background worker picks it up in a **fresh, full context window** and checks off items as it goes
  45. 4. If the worker has a question, it asks — you answer — it continues *(no context lost in either direction)*
  46. 5. You get results when it's done, or ask for status anytime — *your main session is still lean*
  47. ## Complex example
  48. Example — pre-launch sweep for a fullstack SaaS app:
  49. ```
  50. /dispatch we launch Thursday, need a full pre-launch sweep:
  51. 1) security audit the auth flow (JWT, sessions, password reset) and the
  52. stripe payment integration. use opus, do it in a worktree
  53. 2) performance - load test the top 5 API endpoints, find N+1 queries,
  54. check db indexes on users/orders/products tables. sonnet in a worktree
  55. 3) frontend audit - accessibility (WCAG 2.1 AA), bundle size, flag any
  56. components missing error boundaries. dispatch sonnet
  57. 4) generate OpenAPI specs for every endpoint that's missing one. use gemini
  58. 5) error handling audit - find uncaught exceptions, missing try/catch,
  59. inconsistent error response formats across all API routes. sonnet, worktree
  60. ask me if anything is unclear. security is highest priority - flag
  61. anything critical immediately
  62. ```
  63. Dispatch reads the prompt, creates 5 plans, and fans out:
  64. ```
  65. All 5 workers dispatched with their monitors. Here's the summary:
  66. Security (worktree):
  67. ● security-audit — Opus 4-6 (worktree): Full auth + payment security review
  68. Performance (worktree):
  69. ● perf-audit — Sonnet 4-6 (worktree): API load testing + DB index review
  70. Frontend (single worker):
  71. ● frontend-audit — Sonnet 4-6: Accessibility, bundle size, error boundaries
  72. Docs (single worker):
  73. ● api-docs — Gemini 2.5 Flash: Generate missing OpenAPI specs
  74. Error handling (worktree):
  75. ● error-handling — Sonnet 4-6 (worktree): Uncaught exceptions + error format audit
  76. All running in background. Five workers, three models, three worktrees —
  77. your session wrote five checklists and is idle. Dispatch more work or say
  78. "status" anytime.
  79. ```
  80. ## Best practice: warm up at session start
  81. Run `/dispatch` with no arguments at the beginning of a session to pre-load your config:
  82. ```
  83. /dispatch
  84. ```
  85. This reads `~/.dispatch/config.yaml` into the dispatcher's context so subsequent dispatches are faster and don't need confirmation prompts. It's a good habit to add as a [Claude Code memory](https://docs.anthropic.com/en/docs/claude-code/memory) so you remember to do it each session:
  86. > "Run /dispatch at the start of each session to warm up the config."
  87. ## Setup
  88. On first run, `/dispatch` auto-detects your CLIs (`claude`, `agent`, `codex`), discovers available models, and generates `~/.dispatch/config.yaml`. No manual config needed.
  89. ## Configuration
  90. Three sections in `~/.dispatch/config.yaml`:
  91. **Backends** — CLI commands for each provider:
  92. ```yaml
  93. backends:
  94. claude:
  95. command: >
  96. env -u CLAUDE_CODE_ENTRYPOINT -u CLAUDECODE
  97. claude -p --dangerously-skip-permissions
  98. cursor:
  99. command: >
  100. agent -p --force --workspace "$(pwd)"
  101. codex:
  102. command: >
  103. codex exec --full-auto -C "$(pwd)"
  104. ```
  105. **Models** — one line each, mapped to a backend:
  106. ```yaml
  107. models:
  108. opus: { backend: claude }
  109. sonnet: { backend: claude }
  110. gpt-5.3-codex: { backend: codex }
  111. gemini-3.1-pro: { backend: cursor }
  112. ```
  113. **Aliases** — named shortcuts with optional role prompts:
  114. ```yaml
  115. aliases:
  116. security-reviewer:
  117. model: opus
  118. prompt: >
  119. You are a security-focused reviewer. Prioritize OWASP Top 10.
  120. ```
  121. ## Prerequisites
  122. **Host (required):**
  123. - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (`claude`)
  124. **Workers (optional — for multi-model dispatch):**
  125. - [Cursor CLI](https://docs.cursor.com/) (`agent`)
  126. - [Codex CLI](https://github.com/openai/codex) (`codex`)
  127. - Any CLI that accepts a prompt argument
  128. ## Updating
  129. **Skills CLI (recommended):**
  130. ```bash
  131. npx skills update
  132. ```
  133. This updates all installed skills to their latest versions. Run `npx skills check` first to see what's changed.
  134. **Symlinked to a local clone?** If your `.claude/skills/dispatch` is a symlink to a local git checkout, just pull:
  135. ```bash
  136. cd /path/to/your/dispatch && git pull
  137. ```
  138. Changes are picked up immediately — Claude Code hot-reloads skills from disk.
  139. ## Architecture
  140. The dispatcher reads your config, creates a checklist plan, then spawns a background worker and monitor. The worker executes each item and checks it off. If it needs clarification, it writes a question to the IPC directory — the monitor detects it and notifies the dispatcher, which surfaces it to you and relays your answer back, all without the worker losing context.
  141. <p align="center">
  142. <img src="skills/dispatch/assets/architecture.png" alt="Sequence diagram showing the dispatch flow: user triggers dispatch, dispatcher creates plan and spawns worker + monitor, worker executes checklist items, IPC handles questions and answers, monitor detects completion and notifies dispatcher." width="900" />
  143. </p>
  144. ## License
  145. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.