2G

Claude Code supports real subagents. When you structure your prompt to use them, it spawns isolated Agent instances, each with its own context window and synthesizes their findings into a final result.

Most engineers use Claude Code for one task at a time. But for complex engineering work, the most powerful prompts are ones that say:

Break this into focused subagents, each with a specific role, perspective, or step.

Here are three patterns that do exactly that.

1. Stochastic Consensus

Simple meaning

Ask AI to look at the same problem from multiple perspectives, then compare the answers.

Behind the scenes

Claude Code spawns each perspective as a real Agent with its own isolated context window. Because each agent starts fresh, they cannot influence each other’s reasoning.

Any convergence across agents is genuine, not the result of one answer anchoring the next.

Outliers are also more meaningful: if one agent surfaces an idea the others missed, it came from independent reasoning, not a variation on a shared thread.

Use it for

• Brainstorming
• Root cause analysis
• Approach comparison

Example Prompt

Spawn 4 parallel subagents, each taking a different engineering perspective independently:
- Subagent 1: Backend engineer — application code and service design
- Subagent 2: Infrastructure engineer — deployment, scaling, and reliability
- Subagent 3: Database engineer — data access, queries, and storage
- Subagent 4: Systems architect — design trade-offs and long-term maintainability
Task for each subagent: list your top 3 approaches for reducing P99 latency in a high-traffic checkout API.
Run them in parallel so they cannot influence each other. Then synthesize all responses into a master list, noting which ideas appeared across multiple perspectives and flagging any unique outliers.

2. Fan-Out / Fan-In

Simple meaning

Split a large task into smaller parts, analyze each part separately, then combine the findings.

Behind the scenes

When you put a large task into one prompt, the model must juggle too many concerns at once. It gives shallow coverage across each dimension and misses things.

Claude Code solves this by spinning up each reviewer as a separate Agent with a focused scope. Each agent reads only what it needs to and goes deep in its area, without being distracted by concerns outside its lane.

The parent agent then collects all findings and synthesizes them. This is significantly more thorough than asking one agent to “review for security, performance, reliability, and architecture” in a single prompt.

Use it for

• Large code review
• Service analysis
• Technical debt review
• Architecture assessment
• Production readiness checks

Example Prompt

Spawn 5 parallel subagents to review this service for production readiness. Run them in parallel:
Subagent 1 — Security: auth, input validation, secrets handling, data exposure risks
Subagent 2 — Performance: DB queries, N+1 problems, caching, connection pooling, timeouts
Subagent 3 — Reliability: error handling, retries, circuit breakers, graceful degradation
Subagent 4 — Observability: logging, metrics, distributed tracing, alerting coverage
Subagent 5 — Architecture: separation of concerns, coupling, scalability, API design

Each subagent gives their top 3 findings. Then synthesize into a single prioritized list of the most critical issues to fix before production.

3. Debate

Simple meaning

Ask AI to argue different sides of a decision before recommending one.

Behind the scenes

When you ask a single agent “should I use X or Y?”, it forms a view early and then rationalizes it. You rarely get a genuinely critical take on both sides.

Claude Code runs each advocate as a separate Agent that builds its case without seeing the other side’s arguments. Separate agents cannot anchor on each other, each has to construct its position from scratch.

The neutral architect agent reads both completed arguments before forming its recommendation. This produces a genuinely balanced analysis, not a rationalized one.

Use it for

• Kafka vs REST
• SQL vs NoSQL
• Sync vs async
• Build vs buy
• Framework selection
• Architecture trade-offs

Example Prompt

I need to decide how to deliver order status updates to downstream services.
Option A: Kafka — publish events to a topic, consumers subscribe
Option B: REST webhooks — our service POSTs to registered callback URLs
Spawn 3 subagents:
Subagent 1 — Kafka advocate: build the strongest case for Kafka, include the real risks of REST webhooks
Subagent 2 — REST webhooks advocate: build the strongest case for REST webhooks, include the real risks of Kafka
Subagent 3 — Neutral architect: read both completed arguments, then give a balanced recommendation
Run Subagent 1 and Subagent 2 in parallel. Subagent 3 runs after both complete.
For each option, cover: operational complexity, failure modes, team skill requirements, scalability ceiling, and when you would regret the choice.

Key Takeaway

Subagents are most powerful when you use them deliberately.

Don’t ask one large question. Structure your prompt to use focused subagents for different roles, perspectives, or steps.

Real subagent isolation means better coverage, cleaner context per agent, fewer missed gaps, and stronger technical decisions.

Note
True subagent isolation, where each agent runs in its own independent context window is currently available in Claude Code. Other AI tools may simulate this by roleplaying multiple personas in a single context, which is useful but not the same thing.

Written by

Balaji G