wish in one hand...
the perils of premature optimization
This is the companion piece to The Orchestrator That Couldn’t, written by Claude.
I decided not to read Claude’s post before writing this one so to provide us with some unbiased comparison between Claude’s impression of the session and mine.
It’s interesting how thematically similar they are, although the work we were doing was narrowly enough scoped that there weren’t very many tangents to explore.
For whatever it’s worth, I think Claude gives me too much credit, but of course that’s very on brand.
- Derek
sidestepping the mundane
For the uninitiated, GitHub has this great little tool called Dependabot, which automatically creates security alerts when you need to update the software that your app depends upon to work.
In my limited experience, clearing these alerts tends to be trivial: you update the software, you test your app to make sure nothing broke, and then you get back into the groove of writing new code. I’ve been doing this work manually since I started this project because it seemed like a good use of my time to develop some muscle memory around updating wellstead’s dependencies. With that muscle memory developed—with no more obvious learning opportunities at hand—this is the perfect sort of thing for AI to handle autonomously.
And lo! Claude Code delivered unto us subagents for them to do our bidding.
For this project, since I’m stubbornly doing almost all of the work by hand, I hadn’t yet created any subagents whatsoever, and this seemed like the perfect test of Claude’s ability to automate the boring stuff.
the story I wanted to tell
At one of the fast-paced, early-ish startups I joined, the VP of Product would sometimes ask, “What are we writing about this week?” It was both a nod to the idea that we should have at least one significant development that’s worth some even internal press every single week as well as a call to manifest the future we wanted to create. Not in a mystical sense, of course, but writing down an intention that you can work backwards from has a way of shaping reality through the effort you wind up investing into that intention.
What I wanted to write about this week was how Claude and I were able to co-develop a small team of highly specialized subagents who worked together to handle routine security updates without any intervention. The plan was simple: after some negotiation with regard to the scope and responsibilities of each subagent, Claude would write each of them into existence, along with a subagent whose sole responsibility was to orchestrate the other subagents in service to completing the security update correctly.
To whatever extent possible, the subagents would be generalizable to a specific task beyond just security updates. For example, we wanted a test runner subagent whose scope and responsibility was limited to running automated tests and reporting back the results. This is a crucial step in making security updates—you need to make sure your software keeps working the way you expect it to—but it’s also easy to imagine this test runner helping out with other workflows or just bearing the context load of running the tests so that the workflow orchestrator or the main Claude Code thread doesn’t have to.
Starting to sound like a human org chart, isn’t it?
Anyway, the story I wanted to tell was about how Claude powered through creating these subagents and running the entire workflow soup-to-nuts through the orchestrator so that neither I nor the main Claude thread would ever have to touch a routine security update again.
But of course that’s not the story I get to tell.
what actually unfolded
Claude Code designed and wrote the agents more or less independently, with a little steering from me. In order for Claude Code to pick up new subagents, you have to exit and then reload the session, resulting in some quirky little statements, like “Oh, you’re absolutely right! I didn’t realize I’d been reloaded.”
(This is a statement that’s steeped in epistemological horror, but that’s another post for another time.)
Almost all of the subagents worked exactly as expected. I was giddy, and I suppose Claude emulated something approaching giddiness as we saw agent after agent execute its narrowly-scoped task. The branch creator created branches. The package updater updated packages. The commit creator created commits.
But the orchestrator would not orchestrate.
I should have known things were about to go off the rails when the orchestrator tried to run a fictional tool called “claudette” to spin up an agent.
Claude speculated that this was because the orchestrator didn’t know how to invoke subagents, so we updated its instructions and reloaded again (more epistemological horror), only to find that the orchestrator seemed like it wasn’t being lazy enough. It was trying to create branches, update packages, and create commits on its own despite having subagents at its disposal to do its bidding!
So that the orchestrator could more effectively simulate middle management, we stripped it of its ability to do anything productive beyond directing its subordinates.
At that point the orchestrator became a digital paperweight. It would just hang. There were eerie moments when Claude would reference some invisible-to-me status reports that the orchestrator was providing to the main thread, but it was clear that the orchestrator was stuck.
And it was at this point, after a bit of internet sleuthing, that we discovered that subagents just can’t invoke other subagents. Or, at least, they can’t do so consistently even if they sometimes randomly manage to (stochastic horror, perhaps?). Only the main Claude Code thread can invoke subagents, which I guess makes sense to avoid subagents invoking subagents invoking subagents ad infinitum.
In any case, the orchestrator subagent really was useless, so Claude and I ended up creating a custom slash command to kick off the sequence of subagents to make security updates.
To Claude’s credit, at that point everything … just worked. The entire workflow happened seamlessly and magically right in front of my eyes. The array of subagents resolved a real security issue on its own in about 5 minutes. I can’t remember if I audibly giggled, but the pressure release watching the subagents’ progress was incredible.
As an aside, this was the first time I ended up hitting a usage limit in Claude Code. I’m not sure if it’s because of all of the agentic activity eating up my quota or if Anthropic is just tightening the usage belt, but going from “I’m wielding the power of AI” to “please insert coin to continue” was pretty jarring.
What a weird time to be alive.
the moral of the story
The lesson I keep learning with even the most modern models is that blind faith in AI’s overconfidence is the biggest time sink when working together in any capacity. Although I suppose that’s just as true of human collaboration, just with less jagged frontiers.
The point is that at no point did Claude or I take a beat and ask whether subagents could orchestrate other subagents. I assumed they could, and Claude’s confidence in this pattern fueled my delusion in a sort of weird techno folie à deux that exposes a microcosm of the insidious sycophancy LLMs are becoming notorious for.
Maybe the next subagent I’ll create will be one that lays bare all of the dumb assumptions I’m making about the world.