Anti-Patterns: When Subagents Hurt
Delegation Has a Cost
Launching a subagent isn't free. You lose visibility into its work and you compress its findings into a summary. That overhead only makes sense when the subagent does something the main thread genuinely can't. When it doesn't, delegation actively hurts. Three anti-patterns account for most of the damage.
The overhead is real
Every delegation trades visibility and detail for a clean context. If you're not buying anything with that trade — no fresh context, no parallelism, no custom prompt — you're paying the cost for nothing.
Anti-Pattern 1: Expert Personas
Subagents that merely claim expertise rarely help. Prompts like 'you are a Python expert' or 'you are a Kubernetes specialist' add no value — Claude already has that knowledge. There's nothing a so-called expert subagent can do that your main thread can't do directly. You've added delegation overhead and bought nothing.
The test
Before creating an 'expert' subagent, ask: 'Could the main thread do this just as well with the same instruction?' If yes, you don't need a subagent — you need a better prompt in the main thread. Subagents earn their cost through isolation, parallelism, or a genuinely different prompt — not through a job title.
Anti-Pattern 2: Sequential Dependent Pipelines
Sequential subagent pipelines create problems when each step depends on the previous one's discoveries. Consider a three-agent bug flow: one to reproduce a bug, one to debug it, one to fix it. Pipelines work when tasks are truly independent — but they fail when each step needs context from the last, because information gets lost in the handoff between agents (remember: only a summary crosses each boundary).
A dependent pipeline loses information at every summary boundary; bug fixing almost always needs the full prior context.
Anti-Pattern 3: Test Runners
Test-runner subagents tend to hide the very information you need. When tests fail, you want the full output to diagnose the issue. A subagent that returns 'tests failed' forces you to create additional debug scripts to recover details that would have been visible in direct output. In Anthropic's own testing, the test-runner pattern performed worst among all configurations.
| Anti-pattern | Why it hurts | Do instead |
|---|---|---|
| Expert persona | Adds overhead, no new capability — Claude already knows | Improve the main-thread prompt |
| Sequential dependent pipeline | Info lost at each summary handoff | Keep dependent steps in the main thread |
| Test runner | Hides the full output you need to debug | Run tests in the main thread (or have the subagent return full failing output) |
The three anti-patterns and the better move for each.
Next
You know when subagents help and when they hurt. Next we make the decision crisp with one rule — and cover the execution modes (foreground, background, forks) that change the calculus.
Key Takeaways
- ✓Delegation has a real cost: you lose visibility and compress findings into a summary — only worth it when the subagent does something the main thread can't.
- ✓Anti-pattern 1 (expert personas): 'you are a Python expert' adds overhead but no capability — Claude already knows; improve the main-thread prompt instead.
- ✓Anti-pattern 2 (sequential dependent pipelines): when each step needs the previous step's context, information is lost at each summary handoff (e.g. reproduce→debug→fix).
- ✓Anti-pattern 3 (test runners): hide the full output you need to debug; in Anthropic's testing this pattern performed worst.
- ✓The test for an 'expert' subagent: could the main thread do it just as well with the same instruction? If yes, skip the subagent.
- ✓Subagents earn their cost through isolation, parallelism, or a genuinely different prompt — not through a job title or a linear handoff chain.
Check Your Understanding
Test what you learned in this lesson.
Q1.Why are 'expert persona' subagents (e.g. 'you are a Python expert') an anti-pattern?
Q2.Why do sequential dependent subagent pipelines (reproduce → debug → fix) fail?
Q3.What's wrong with a test-runner subagent?
Q4.What genuinely justifies the overhead of a subagent?
Practice This Lesson