I took a four-day weekend. Friday, October 31 through Monday, November 3. Time off.
But I was fascinated. These ways of using Claude Code, building agents, discovering patterns, exploring what AI could do with the right architecture, this was too interesting to stop.
By Thursday afternoon, I’d built a complete 12-agent hierarchical system. I wanted to see what else I could discover. So I spent my weekend working on it anyway.
The weekend was supposed to be for using the system and refining it. Instead, I spent it discovering that the entire architecture was built on a foundation that didn’t exist.
Three Days of Testing
Friday morning, I launched the orchestrator.
It worked. Orchestrator coordinated managers. Managers coordinated workers. Perfect.
I ran it again on different files. Worked again. I was excited. This was exactly what I’d built.
Saturday morning, same workflow, different files: Error: agents cannot invoke other agents.
Wait. What changed?
I spent Saturday trying every variation I could think of. Different files. Different entry points. Launching the orchestrator. Launching managers directly. Sometimes it worked perfectly. Sometimes immediate errors. No clear pattern.
Sunday, still debugging. Running test after test. Taking notes on what worked versus what failed. Trying to find any consistent difference. File size? File content? Number of issues? Time of day?
Nothing made sense. The inconsistency was maddening.
I’d spent two full days testing and I still couldn’t figure out what determined success versus failure.
The Realization
Sunday afternoon, I finally saw it.
When the workflow “worked,” Claude wasn’t spawning manager agents. Claude was reading the orchestrator’s instructions that said “invoke this manager” and just doing the manager’s work directly in the main conversation.
The orchestrator never invoked the manager. Claude just executed those instructions as if they were for Claude itself.
When it “succeeded,” that was proof it was broken. Claude was compensating.
When it failed with the error message, that was Claude actually trying to spawn agents and hitting the limitation.
The truth: Agents can’t spawn other agents. The Task tool doesn’t work from within an agent.
Everything I’d built (orchestrator → managers → workers) was impossible.
The Adaptation
Monday, I flattened everything.
Deleted the orchestrator. Deleted all managers. Kept the workers (those worked fine).
The new structure:
Claude (following workflow instructions)
↓
Launches workers directly via Task tool
Two tiers instead of three. All the coordination logic Claude had to do directly.
What Survived
Not everything was wrong. The workers were fine. The patterns were sound.
What worked:
- The 10-step rule
- Intelligence distribution (workers contained their domain knowledge)
- Verification loops (check, fix, check again until clean)
- Context-agnostic design
- Job naming conventions
What didn’t:
- Orchestrator spawning managers
- Managers spawning workers
- Any hierarchy deeper than Claude → Workers
The architecture had to change. The principles didn’t.
The Lesson
The weekend taught me about intermittent bugs. When something works sometimes, you assume it’s correct. When it’s inconsistent, the problem might be deeper than your implementation.
In this case: the architecture was sound. The implementation was correct. The foundation didn’t exist.
I also learned the difference between architecture and patterns. The hierarchical architecture couldn’t work. But the patterns I’d discovered (how to structure agent instructions, how to distribute intelligence, how to verify and loop) were still valuable.
By Monday evening, I had a working system. Flatter than I wanted. But functional.
I’d gone from 12 agents with a three-tier hierarchy to 8 agents with flat coordination. But I’d gained clarity about what Claude Code could actually do versus what I’d assumed it could do.
Sometimes the best architecture is the one that actually works.
The rebuild forced me to make several architectural decisions. One of them: should workers have exactly one job, or can they have multiple related jobs?
That question led to a pattern I’d use throughout the system.
Next: Agent Jobs