Claude Code as an orchestrator: how to delegate tasks to specialized subagents

The biggest Claude Code power users aren't using it as a single coding assistant. They're using it as an orchestrator — a coordinator that breaks work into pieces and delegates each piece to a specialized subagent.

Here's the mental model shift that unlocks 10x productivity.

The orchestrator pattern

Instead of one long session:

"Build me a full-stack todo app with auth, database, tests, and deployment"

You run one orchestrator session that spins up parallel specialist sessions:

"You are the orchestrator. Break this into 4 tasks:
1. Schema + migrations (delegate to DB agent)
2. API routes + auth (delegate to backend agent)  
3. React components (delegate to frontend agent)
4. Docker + CI (delegate to devops agent)

Run each in its own git branch. Report blockers."

Why this works

Context isolation: Each subagent only sees what's relevant to its task. The frontend agent doesn't need to know about your Postgres migration strategy. Less context = better decisions.

Parallel execution: While agent 1 writes migrations, agent 3 is building components. Real-world 4-5x speedup on large features.

Rate limit management: Smaller, focused sessions hit rate limits less often than one massive session that touches 50 files.

Rollback safety: Each agent works in its own branch. If the frontend agent makes a mess, you delete the branch. Clean.

The exact prompt template

You are the orchestrator for this feature: [FEATURE DESCRIPTION]

Project structure:
[paste your tree output]

Break this into exactly 3-5 independent tasks.
For each task:
- Define the input (what files/data it needs)
- Define the output (what files it produces)
- Name the git branch: feature/[task-name]
- List any dependencies on other tasks

Start with tasks that have no dependencies.
Report when each task is complete with: branch name, files changed, tests passing.

A real example: adding Stripe payments

I used this pattern to add Stripe subscriptions to a Node.js app. Without orchestration, one session = 3 hours + 2 rate limit hits.

With orchestration:

Orchestrator session (5 minutes):

• Analyzed existing auth system
• Broke work into 4 tasks
• Identified dependency order

DB agent (branch: feature/stripe-schema):

• Added subscription_status, stripe_customer_id columns
• Wrote migration files
• Done in 20 minutes

Backend agent (branch: feature/stripe-routes):

• /api/billing/create-session
• /api/billing/webhook
• Stripe SDK integration
• Done in 35 minutes (ran parallel with DB agent)

Frontend agent (branch: feature/stripe-ui):

• Pricing page component
• Checkout button
• Success/cancel pages
• Done in 30 minutes (parallel)

Integration agent (branch: feature/stripe-integration):

• Merged all three branches
• Ran tests
• Fixed 2 integration issues
• Done in 15 minutes

Total: 50 minutes instead of 3 hours. No rate limit hits.

Setting up the git workflow

# Create the orchestrator branch first
git checkout -b orchestration/stripe-payments

# Each subagent creates its own branch from main
git checkout main
git checkout -b feature/stripe-schema

# After each agent completes, merge to orchestrator branch
git checkout orchestration/stripe-payments
git merge feature/stripe-schema --no-ff -m "merge: stripe schema from DB agent"

The rate limit problem with parallel agents

Here's the catch: if you're on Claude Pro, parallel agents share your rate limit.

Run 5 agents simultaneously → you hit limits 5x faster.

The solution is using ANTHROPIC_BASE_URL to point each agent at a pooled API. With SimplyLouie's Claude proxy ($2/month flat rate), each agent session draws from API credits without eating your subscription limit.

# Agent 1 terminal
ANTHROPIC_BASE_URL=https://api.simplylouie.com \
claude "You are the DB agent. Create migrations for Stripe schema..."

# Agent 2 terminal (simultaneously)
ANTHROPIC_BASE_URL=https://api.simplylouie.com \
claude "You are the frontend agent. Build the pricing page..."

Now parallel agents don't compete for the same rate limit bucket.

When to use orchestration vs. single sessions

Use orchestration when:

• The feature touches >3 unrelated files/systems
• Tasks can run in parallel without dependencies
• You've hit rate limits on this type of work before
• The feature will take >1 hour in a single session

Single session is fine when:

• It's a small bug fix
• The work is highly sequential (step B depends on step A's exact output)
• You're still exploring/prototyping

The hidden benefit: documentation

Orchestrator sessions naturally produce documentation. The orchestrator's output — "here are the 4 tasks, here are the dependencies, here are the contracts between them" — is your technical design doc.

Save it:

claude "Orchestrate this feature" > docs/stripe-integration-plan.md

Now new team members understand the architecture by reading the orchestrator's output.

---

One more thing: If you're regularly running multi-agent workflows and hitting rate limits, SimplyLouie gives you a flat $2/month Claude API endpoint. Parallel sessions, no rate limit competition, no usage spikes. Worth knowing about.

What patterns are you using for parallel Claude Code sessions? Drop them in the comments.