Why delegation matters

Using one single, powerful model for everything is intuitive, but inefficient. An Opus-class model for trivial syntax fixes is like a surgeon putting on band-aids. Expensive, and the surgeon will eventually get tired of it.

The right delegation — which task goes to which agent, at which point — is one of the most important disciplines in productive AI workflows. And it has nothing to do with the latest model release.

How I delegate by complexity

I think in three tiers:

  • Haiku / small models: syntax validation, linting, simple text transformations, quick status checks, data parsing. Anything that doesn't need deep reasoning.
  • Sonnet (default): pair programming, feature implementation, high-frequency tasks that need full accuracy but no architectural thinking.
  • Opus: complex architecture decisions, deep debugging, critical code reviews, planning larger refactors. Rare, but deliberate when used.

This split saves 30–40% in cost compared to "always Opus" — without a quality hit on most tasks.

Delegation by task type

Beyond model size, there's delegation by specialization. Some agents are better suited to certain domains — not because they run a different model, but because their skills and context fit better.

I run specialized setups for: infrastructure-as-code, Python services, frontend components, documentation. Each setup carries the relevant conventions in memory, the right MCP connections, the right boundaries.

Subagents for parallel work

An underrated option: instead of working a task sequentially, split it into independent subtasks and delegate them in parallel. One agent reads documentation, another writes tests, a third checks security implications — at the same time.

This doesn't always work, but for tasks with cleanly separable parts it's a real lever. The coordination overhead pays off past a certain level of complexity.

When delegation doesn't help

Delegation doesn't fix vague tasks. If I don't know exactly what I want myself, the best delegation is useless. A subagent working an ill-defined task just produces bad results faster — not better ones.

The rule of thumb: delegation presupposes clarity. Whoever delegates has to know what should come out of it. That's the same requirement as with delegating to people.