cat
Subagent-driven development as the explicit combination of /subagent-driven-development (sequential, review-gated execution) and /dispatching-parallel-agents (independent fan-out). Opens with one combined pre-dispatch question to set the execution mode and the edit-approval mode, then dispatches accordingly.
- License 许可
- MIT
- 最近更新
- 2026-09-10
- Stars
- ★ 3
- Forks
- 1
01 前言 Front Matter
- name
- cat
- description
- Subagent-driven development as the explicit combination of /subagent-driven-development (sequential, review-gated execution) and /dispatching-parallel-agents (independent fan-out). Opens with one combined pre-dispatch question to set the execution mode and the edit-approval mode, then dispatches accordingly.
- user-invocable
- true
03 SKILL.md 正文
What /cat Is
/cat authorizes subagent dispatch for the work at hand, as the explicit
combination of two superpowers skills:
/subagent-driven-development— sequential plan execution: a fresh implementer subagent per task, with two-stage review (spec compliance first, then code quality) before the next task starts./dispatching-parallel-agents— independent fan-out: one concurrent agent per independent problem domain, integrated and suite-verified together.
You do not silently guess which shape fits. You ask the user up front, then dispatch on their answer.
Pre-Dispatch Question
Before dispatching anything, ask one combined AskUserQuestion covering two
orthogonal axes — both axes in a single AskUserQuestion call (multiple
questions in one call), not two sequential calls. Wait for both answers before
any dispatch.
Axis 1 — Execution mode (how subagents are sequenced):
| Preset | Drives | Use when |
|---|---|---|
| Full parallel | /dispatching-parallel-agents |
2+ independent tasks — no shared state, no sequential dependencies |
| Hybrid (plan-gated parallel) | /dispatching-parallel-agents within phases, /subagent-driven-development across |
a plan with one or more parallelizable phases plus dependent tasks between them |
| Strict sequential | /subagent-driven-development |
each task needs the spec-then-quality review loop to pass before the next can start |
Axis 2 — Edit approval (who clears each edit). The real distinction is whether edits are auto-accepted or you approve each one — not background vs foreground. Backgrounded subagents surface permission prompts too, so "background" does not mean "silent":
| Mode | Semantics |
|---|---|
| Auto-accept | edits auto-accepted — no per-edit gate. Subagents run in the background; fastest, the default for large fan-outs. Requires auto-accept-edits to be ON. |
| Manual-approve | you approve each edit interactively. Subagents are dispatched in the foreground (all independent agents at once; dependent tasks still serialize), so the approval stream stays coherent instead of interleaving across many background agents. |
If the user picks Auto-accept but hasn't enabled auto-accept-edits, prompt
them to turn it on (press a or /allowed-tools) and wait for them to enable
it before dispatching — otherwise even backgrounded dispatch stops on every edit
for approval.
Dispatch
Map the chosen execution mode to its source skill and follow it. These are bare invocations on their own line — they load and run the composed skill:
<!-- prettier-ignore -->
- Full parallel → /dispatching-parallel-agents
- Strict sequential → /subagent-driven-development
- Hybrid → apply the Full parallel dispatch (above) within each independent phase, and the Strict sequential dispatch (above) across the dependent tasks. Switch on dependency: a task that needs a prior task's output — or its review to pass — is sequential; everything else in that phase fans out. Don't force one shape onto the wrong work.
Edit-approval × execution-mode
Manual-approve is orthogonal to execution mode: it changes how edits are
approved (foreground, per-edit), not how many subagents run at once. "All
subagents dispatched at once" is the parallel/hybrid manifestation; under Strict
sequential it does not collapse the review-gated, one-at-a-time loop. Your
per-edit approval is separate from /subagent-driven-development's
two-stage spec-then-quality review — approving a diff does not stand in for that
review; the reviewer subagents still run.
| Execution mode \ Approval | Auto-accept | Manual-approve |
|---|---|---|
| Full parallel | all agents concurrent, background | all agents dispatched at once, foreground, approve each edit |
| Hybrid | parallel phases background; rest serial | parallel phases dispatched at once foreground; dependent parts serialized |
| Strict sequential | one task at a time, background | one task at a time, foreground, approve that task's edits |
No Shortcut for "Trivial" Edits
When the user chose /cat (directly, or via a composition like /super-cat,
/super-duper-cat), they authorized subagent dispatch as the execution model.
Do NOT substitute inline Edit/Write tool calls on the main agent because
edits seem small, mechanical, or repetitive — fresh-subagent-per-task isolation
(whether sequential via /subagent-driven-development or concurrent via
/dispatching-parallel-agents) IS the skill's value, not an optional ceremony.
Manual-approve is not a license for inline edits. Foreground/manual-approve changes WHO APPROVES each edit (you, interactively) — not WHO MAKES it (still the dispatched subagent). "I'm approving every diff in the foreground anyway, so I may as well edit directly" is the same shortcut as every row below, wearing a new hat. The execution model the user chose holds in every approval mode.
If the tasks are truly below the threshold for subagent dispatch (e.g., a single 1-line typo fix), surface the tradeoff to the user explicitly and ask before short-circuiting. Never skip silently.
Rationalization counter:
| Excuse | Reality |
|---|---|
| "Dispatching subagents for 5-line edits is overkill" | The user picked /cat explicitly. Respect the choice. Isolation is the point, not speed. |
"Parallel Edit calls are faster than parallel agents" |
Speed is one rationale for /dispatching-parallel-agents but not the only one — context isolation prevents bleed between independent investigations. If you want inline edits, the user should pick a different workflow. |
| "The output will just say 'done', it's the same thing" | Same output ≠ same process. Fresh-context-per-task is the value; skipping it defeats the skill. |
| "Subagents + review loops take too long" | That's the cost the user agreed to when they invoked /cat. If the budget is tight, ask — don't decide unilaterally. |
| "Manual-approve makes context isolation moot — I'm hand-approving every diff anyway" | Approval mode and execution model are orthogonal. You approve the edit; the subagent still makes it. Foreground ≠ inline. Dispatch anyway. |
Red flag — STOP: if you catch yourself writing "I'll do this directly
instead of dispatching because [trivial/fast/simple/foreground]", you are
violating /cat. Dispatch the subagent.
04 同仓库更多 Skills
visual-aid
Use when the user asks for a quick visual aid, visual explainer, concept card, one-pager, poster, cheat sheet, infographic, visual summary, summary card, or mini explainer page — especially from input like a block of text, attached images, an attached song (lyrics/audio), a web link, a CSV/dataset, a math formula, a code snippet to walk through, a tutorial's steps, a timeline, or an A-vs-B comparison. Triggers include "make me a quick visual aid", "turn this into a one-pager / cheat sheet / explainer", "summarize this visually", "give me a visual of", "explain this on a single page", "make a concept card for", "whip up a page about", "build a mini page that shows", "something I can paste into a doc explaining X", or any request to render a topic/text/link/image-set/song/data into a standalone page. Prefer this skill over frontend-design when the ask is an explanatory single-file page (not a production UI), over playground when the output is static information display (not an interactive configurator), and over a Markdown/code answer when the user explicitly wants a *page* (HTML). Produces a single self-contained HTML file that opens on double-click without a server.
tesseract
Use when you've been poking at the same file, concept, or problem across many sessions and want to step outside time to see its whole arc — or when you want to leave a note for next-session-you. Triggers: 'I've been going in circles on X', 'what have I learned about X', 'what did past-me say about X', 'I keep rediscovering this'.
tdd
Invoke test-driven development as an explicit one-at-a-time micro-cycle — one test, one piece of functionality, refactor, then repeat for the next behavior
tdd-cat
TDD workflow with subagent-driven-development — /tdd composed with /cat, plus the A/B TDD execution-mode axis (split-phase vs micro-cycle) asked as a third question in /cat's combined pre-dispatch question
task-list
TaskCreate / TaskUpdate / render the current TaskList in response to `/task-list` (with or without flags). The skill body executes immediately on the syntax — no permission-seeking, no echoing the list back as plain text.
sync
Sync files between two local directories, repos, or git worktrees. Five modes (plan/interactive/push/pull/mirror), .gitignore-aware, Claude-workflow allowlist via --claude, dropbox-restore-style per-directory prompts.