Claude Code Parallel Agents: Measuring The Actual Speedup

The narrative around parallel agents is that more agents equal proportional speedup. That is false. Coordination overhead is real, and the shape of the work matters more than the agent count. I measured it on a real feature.

The Setup

I built the same feature twice: a newsletter signup form with backend, frontend, tests, and email template. Once serially with a single Claude Code session. Once with four parallel subagents (backend, frontend, tests, template) coordinated by an orchestrator.

Serial run:
- Time: 42 minutes
- Human review rounds: 2
- Lines of code: 380
 
Parallel run:
- Time: 19 minutes (2.2x faster)
- Human review rounds: 3 (one per handoff)
- Lines of code: 410

Four agents did not mean 4x. It meant 2.2x. The extra reviews and the handoff coordination ate the rest. But 2.2x on a 42-minute task is still a huge win.

Where Parallel Wins Most

Parallel wins when the tasks are genuinely independent. Backend and frontend touch different files. Tests and templates touch different files. No agent blocks another. That is the sweet spot.

Parallel loses when the tasks share state. If two agents want to modify the same schema file, they serialize anyway. Better to do it with one agent.

The Rule Of Thumb

If the task decomposes into independent pieces across different files, parallel. If it is a single refactor across many files, serial. This seems obvious written down, but it is the rule I violated most before measuring.

See the Claude Code parallelization patterns in the docs. Two-to-three parallel subagents hits the sweet spot for me. More is rarely worth it.