Tucked into the Claude Code changelog on June 10th, version 2.1.172, is a line that reads like a small quality-of-life note and is actually a structural change to how delegated work gets shaped: "Sub-agents can now spawn their own sub-agents (up to 5 levels deep)."

I want to be unambiguous before I get analytical: this is a good change. It solves a real, irritating problem, and I would rather have it than not. But it is also the next chapter in a story I was telling just last week about git worktrees — the one where the limiting resource was never the machine, it was the one tired person reading the diff. Recursion doesn't change that ceiling. It moves the floor further away from it.

What it actually fixes

To see why this is genuinely useful, you have to understand what a subagent is for. Per the official docs, "Each subagent runs in its own context window with a custom system prompt, specific tool access, and independent permissions." The whole point is context hygiene. You spin up a subagent to do a side task — search the codebase, read forty files, grind through logs — so that all that noise happens in its window and only the summary comes back to yours. Your main conversation stays lean and legible. It's the digital equivalent of sending a clerk to the basement archive instead of hauling every box up to your desk.

Until this month, that clerk couldn't send a clerk. If your subagent hit a task that itself deserved delegation — "go audit these twelve modules for the same vulnerability pattern" — it had to do all twelve inline, in its own single window, and the same context-pollution problem you'd just solved one level up reappeared one level down. The wall existed at exactly the wrong place: deep enough that you couldn't see it, shallow enough that it bit.

Letting a subagent delegate is the correct fix, and it's the correct fix for the same reason the first level of subagents was a good idea. Each new layer gets its own clean window. The work that would have flooded one context gets fanned out across several. As a piece of context engineering, it's elegant and overdue. I'd have shipped it too.

So far this is just good plumbing. Here's the part worth slowing down for.

The thing recursion quietly does

Think about what a chain of delegation looks like from where you sit. You ask for something. An agent decides part of it is worth handing off, and spawns a worker. That worker decides part of its slice is worth handing off, and spawns another. Five levels is the ceiling, but you rarely need to approach it for the effect to land: by the third hop, the work that produced the code in front of you happened in a context window you never opened, reasoned about by an agent you never configured, three delegations removed from the sentence you actually typed.

This is the generation-versus-judgment asymmetry I keep meeting from new angles, and recursion sharpens it in a specific way. Last week's worktree story was about width: five agents working side by side, five diffs arriving at one merge seam, the reviewer the bottleneck because review runs at human reading speed and dispatch doesn't. The number practitioners keep landing on is three to five parallel agents before "the coordination overhead and review burden start to offset the speed gains" — a statement about a person's attention, not a laptop's cores.

Recursive subagents add a second axis: depth. And depth is sneakier than width, because width is at least visible. When you launch five parallel agents, you know you launched five; the cost is in front of you. When a subagent three levels down spawns two of its own to handle subtasks you didn't enumerate, the branching happened below your line of sight. You authorized the trunk. The tree grew itself.

The honest way to say it: the feature improves the legibility of each individual context and reduces the legibility of the work as a whole. Every window is cleaner. The path from your request to the committed line runs through more rooms you'll never enter.

Why this isn't a complaint

I want to be careful here, because there's a lazy version of this argument that just says "nesting is scary, don't delegate," and that's wrong. The friction recursion removes — the inline context flood three levels down — was genuinely load-bearing pain, and removing it is the product working as designed. A tool that makes you manually flatten every deep task into one window isn't safer; it's just worse, and you'd route around it anyway.

The point is narrower and, I think, more useful: the unit of review didn't change, but the distance to it grew. What you sign off on is still the diff — the bounded changeset, the behavior, the thing that lands on main. As one good practitioner write-up puts it, "Human review happens at the diff and behavior level, not inside agent reasoning." That was already the only honest place to stand. Recursion doesn't move the review seam — it can't — but it lengthens the unobserved chain that feeds it, which means the diff in front of you summarizes more invisible reasoning than it used to.

Picture a general contractor who can now hire subcontractors who hire their own subcontractors, five firms deep. The building that gets inspected is the same building. The inspection is the same inspection. But the number of decisions made by people the inspector never met, between the blueprint and the drywall, just went up — and the inspector still has to certify the wall as if they'd watched it go up. The wall is the deliverable. It always was. Recursion just put more strangers behind it.

The move

So this isn't "turn it off." It's "know which floor you're on."

  • Treat delegation depth like blast radius, not like a free win. A flat task you can hold in your head is different from one that fanned out three levels before producing output, even when the diff looks identical. The diff's size is not the work's size.
  • Scope the trunk so the branches stay bounded. The advice that already works for single-level subagents — give each one a tightly-scoped, bounded changeset — matters more with recursion, because a vague top-level ask is what gives a deep subagent license to spawn its own helpers in directions you never pictured. The cleaner the trunk request, the shallower and more predictable the tree.
  • Keep the trajectory visible without spelunking. The structural risk of depth is that the branching happens below your line of sight. If your setup can surface that a chain went five deep — not the contents of every window, just the shape — you've recovered the one signal recursion takes away.
  • Review the same way, but trust the summary less. When a diff is the distilled output of a three-hop delegation chain, it is doing more compression than a diff written in one window. Read it as the confident draft of a clerk who hired clerks — never less carefully than that, and ideally a notch more, exactly where the stakes are real (auth, secrets, data, anything irreversible).

The capability is good. I'd keep it on. But the question to carry into it is the same one the worktree post ended on, just rotated ninety degrees. Last week it was can I review what five agents make before I'd have to ship it. This week it's quieter and harder to notice you've stopped asking: when the work I'm about to approve was shaped five rooms away, am I still reviewing the work — or just the last room's summary of it?