Parallel dispatch

Skill NEXUZ-SYS/devflow/skills/parallel-dispatch

Use when multiple independent tasks can be executed simultaneously — coordinates parallel agent/subagent dispatchFrom its SKILL.md

Install

npx -y skills add NEXUZ-SYS/devflow --skill parallel-dispatch

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

4.0 KB, as published. Nobody here has run it

Parallel Dispatch

Coordinate parallel execution of independent tasks across multiple agents or subagents.

Announce at start: "I'm using the devflow:parallel-dispatch skill to parallelize these tasks."

When to Use

Implementation plan has independent task groups
Feature breakdown identified parallelizable chunks
Multiple specialists need to work on unrelated components
Need to maximize throughput during Execution phase

Prerequisites

Tasks must be truly independent (no shared state, no data dependencies)
Each task must have clear inputs and expected outputs
Merge strategy defined for combining results

Process

Step 1: Identify Parallel Candidates

From the implementation plan, find task groups where:

No data flows between tasks
No shared files being modified
No ordering requirement
Each task is self-contained

Step 2: Prepare Dispatch

For each parallel task, define:

Task: [description]
Agent: [which specialist]
Inputs: [files to read, context needed]
Outputs: [files to create/modify]
Verification: [how to verify completion]

Step 3: Dispatch

With subagents (Claude Code, Codex)

superpowers:dispatching-parallel-agents

Dispatch each task to a fresh subagent with:
- Task description
- Relevant file context
- TDD requirement
- Expected output

Use the Agent tool with isolation: "worktree" for file-level isolation.

Without subagents (Cursor, Windsurf)

Execute tasks sequentially but in optimal order:

Independent tasks first (unblock dependents)
Group by file proximity (reduce context switching)

Step 4: Merge Results

After all parallel tasks complete:

Verify each task's output independently
Check for unintended conflicts (same files modified)
Resolve any merge conflicts
Run full test suite to verify integration
Commit the merged result

Parallelization Patterns

By Component

Task A: Backend API     → backend-specialist (worktree-a)
Task B: Frontend UI     → frontend-specialist (worktree-b)
Task C: Database schema → database-specialist (worktree-c)

By Feature Slice

Task A: User CRUD       → feature-developer (worktree-a)
Task B: Admin dashboard → feature-developer (worktree-b)
Task C: Email service   → backend-specialist (worktree-c)

By Test Type

Task A: Unit tests      → test-writer (worktree-a)
Task B: Integration tests → test-writer (worktree-b)
Task C: E2E tests       → test-writer (worktree-c)

Mode Integration

Full Mode

agent({ action: "getSequence", task: "<description>" })

dotcontext identifies parallelizable agents and provides handoff sequences.

Superpowers Integration

superpowers:dispatching-parallel-agents handles the actual subagent dispatch mechanics. superpowers:using-git-worktrees provides isolated workspaces per parallel task.

Anti-Patterns

Pattern	Problem
Parallelizing dependent tasks	Race conditions and merge conflicts
No merge verification	Silent integration failures
Shared file modifications	Git conflicts and overwritten changes
Skipping TDD in parallel tasks	Each subagent must follow TDD independently
No integration test after merge	Parallel tasks may work alone but fail together

Branch omp (quando `detect-runtime` reporta `omp`)

Despache via o task tool nativo em vez do Task do Claude Code:

isolated: true → worktree isolada (pi-iso) por subagent.
agent (nome exato) + tasks: [{ id, description, assignment }].
Review/validação: passe schema (output schema de omp/schemas/*.json) p/ JSON validado.
Respeite o spawns allowlist do frontmatter; fan-out independente com model: pi/smol. Ao final, verifique integração e merge das worktrees (igual ao caminho Claude Code).