Delegate — Parallel Code Implementation for Claude Code

Turn one task into five parallel agents. Describe what you want built, get a structured report when it's done.

What it does

Delegate is a Claude Code skill that breaks implementation tasks into independent work units and executes them in parallel. Instead of one agent working through files sequentially, Delegate decomposes the task, writes self-contained specs, spawns up to 5 concurrent agents, reviews the results, and reports back.

It handles orchestration so you stay at the architecture level — describe the feature, review the output.

Key features

• Parallel execution — up to 5 concurrent Task agents per batch, with dependency-aware batching for sequential work
• Worktree isolation — code tasks get git worktree isolation per agent, eliminating file conflicts by construction (not convention)
• Self-contained specs — each agent receives actual code snippets from your codebase, not "follow existing patterns" — real imports, real component structures, real styling
• Auto-retry on failure — if an agent returns empty or error output, Delegate retries once automatically before falling back to manual fix
• Structured review — after all agents complete, Delegate reads every modified file, checks integration points (imports, naming, styling), and fixes drift before reporting
• Fresh context per agent — each agent gets only its spec, preventing context window bloat that degrades quality

How it works

Delegate runs in 6 phases:

Your task description
        |
   [1. Explore]     -- understand codebase
        |
   [2. Decompose]   -- break into units
        |
   [3. Write Specs] -- self-contained instructions
        |
   [4. Execute]     -- spawn parallel agents
    /   |   \
  [A] [B] [C]       -- up to 5 concurrent
    \   |   /
   [5. Review]      -- verify & fix integration
        |
   [6. Report]      -- structured summary

1. Explore — reads the codebase, understands patterns, identifies files to touch
2. Decompose — breaks the task into non-overlapping work units, groups into dependency-ordered batches
3. Write Specs — creates fully self-contained specs with real code from your repo
4. Execute — spawns parallel agents (worktree-isolated for code tasks)
5. Review & Integrate — verifies all changes, fixes integration issues
6. Report — structured summary of everything that happened

The detail principle

Delegate gets better the more detailed your plan is.

This is the most important thing to understand. Delegate's Phase 1 (Explore) reads your codebase to understand patterns, but it can't read your mind. The more context you provide upfront, the better the specs it writes, and the better the output from every agent.

Vague (Delegate has to guess everything)

/delegate Add user authentication

Better (Delegate knows the approach)

/delegate Add JWT authentication using the existing auth middleware pattern
in src/middleware/auth.ts. Add login/register endpoints to src/routes/auth.ts,
a User model in src/models/user.ts, and update the route index to include
auth routes.

Best (Delegate has a full plan)

/delegate Implement the auth system from our plan:
- JWT tokens with refresh rotation (see src/middleware/auth.ts pattern)
- User model with bcrypt password hashing (follow src/models/post.ts structure)
- Login/register/refresh endpoints in src/routes/auth.ts
- Protect all /api/v2/* routes with requireAuth middleware
- Add auth error handling to src/middleware/errorHandler.ts

A detailed plan means Delegate writes better specs. Better specs mean agents produce code that matches your codebase on the first try. First-try accuracy means less review fixing and faster completion.

Pro tip: Use Claude Code's plan mode first (/plan), get the approach right, then hand the plan to Delegate. Planning is thinking. Delegate is execution.

When to use it

• Multi-file features (3+ files) — genuine parallel speedup
• Repetitive refactors across many files — batch decomposition
• New feature implementation — when you know WHAT to build
• Codebase migrations — schema changes, API updates across endpoints

When NOT to use it

• Single-file changes — overhead isn't worth it
• Debugging — Delegate needs a clear target, not "figure out what's wrong"
• Exploratory work — use regular Claude Code for investigation first
• Highly coupled changes where every file depends on every other — everything ends up sequential anyway

Install

# Create the skill directory
mkdir -p .claude/skills/delegate

# Copy the skill file
curl -o .claude/skills/delegate/SKILL.md \
  https://raw.githubusercontent.com/aayoawoyemi/Delegate-Skill/main/SKILL.md

# That's it. Use it:
# /delegate [your task description]

Or manually: copy SKILL.md into .claude/skills/delegate/SKILL.md in your project.

Example output

--=={ delegate }==--

Task: Add JWT authentication with login/register endpoints

Batches: 2 (sequential -- model before routes)
Agents spawned: 4

Work Units:
  1. User model + migration -- done
  2. Auth middleware -- done
  3. Auth routes (login/register/refresh) -- done
  4. Route index + error handler updates -- done

Files Created:
  - src/models/user.ts -- User model with bcrypt hashing
  - src/routes/auth.ts -- login, register, refresh endpoints
  - src/migrations/003_users.sql -- users table migration

Files Modified:
  - src/routes/index.ts -- added auth route imports
  - src/middleware/errorHandler.ts -- added AuthError handling
  - src/middleware/auth.ts -- added requireAuth and optionalAuth

Integration Fixes: 1 (aligned User type import between model and routes)
Retries: none

Ready to test: npm run dev, then POST /api/auth/register with { email, password }

Requirements

• Claude Code (CLI)
• Task tool access enabled
• Works with any codebase and language

How it compares

License

MIT

Built by Aayo Awoyemi. Inspired by patterns from Composio's agent-orchestrator (fleet isolation, declarative reactions) adapted for single-session Claude Code workflows.