An Ask HN thread from today revealed something striking: the engineers who build Claude Code don't use it the way most developers do. They run a hierarchy of specialized agents — leads, project managers, individual contributors — each with distinct roles, communicating through a structured protocol. The result: 30-50 prompts per day driving 8-10 parallel projects with agents that run autonomously for 2-3 days at a time.
This isn't a hypothetical architecture. It's how Daisy, an engineer on the Claude Code team, describes her daily driver in an internal email that made its way to Hacker News. The gap between this workflow and what most developers experience is wide, and understanding it changes how you should think about building with AI coding tools.
The Architecture: Leads, PMs, and ICs
Daisy's setup runs two lead agents that "keep each other accountable and restart the other if either fails." These leads delegate to tech lead or PM agents for the 8-10 projects running concurrently. Each project spins up 5-10 IC agents — generalists or specialists depending on the problem.
The interaction breakdown: 60% with the leads, 35% with project leads, 5% when something goes off the rails. All communication happens through the SendMessage tool, meaning agents talk to agents directly without human mediation for the majority of the work.
Contrast this with the typical developer workflow described in the same thread: create a session, plan in plan mode, implement, open a new session to review the PR, feed findings back, iterate for 3 rounds, then run E2E tests. That's a linear, human-in-the-loop process. Anthropic's internal workflow is a parallel, agent-native system.
Why This Matters for Developers
The implication isn't that you should copy this exact org chart. It's that the tool you're using was designed for a multi-agent, long-horizon, delegated workflow — not the single-session, human-reviewed loop most people fall into.
Claude Code's SendMessage tool, its session management, its ability to spawn sub-agents — these aren't convenience features. They're the primitives of the workflow the builders themselves use. When you treat Claude Code as a fancy autocomplete or a single-shot code generator, you're using a distributed system as a REPL.
The Verification Gap
The thread's author feels their workflow "is not automated enough" and their "verification loops are still too manual." They read every report and have a general sense of PR quality without reading the code. This is the tension: human review doesn't scale, but blind trust fails.
Anthropic's answer is structural: the leads review the ICs, the PMs review the leads, and the human only engages the 5% that goes off rails. The verification is distributed across the agent hierarchy, not concentrated in the human.
What You Can Adopt Today
You don't need 20 agents to start shifting toward this model. Three practical shifts:
1. Delegate review to a separate agent
Instead of reading the diff yourself, spawn a reviewer agent with a strict rubric. Feed it the PR, get structured findings, then feed those back to the implementer. This is exactly what the thread author does manually — automate the loop.
2. Run parallel sessions for parallel work
If you're building a frontend feature and a backend API, don't sequence them in one session. Spawn two sessions with a shared spec, let them run, then integrate. The leads in Daisy's workflow don't wait for one project to finish before starting the next.
3. Define "off rails" explicitly
The 5% escalation rate only works because the system knows what normal looks like. Write down what constitutes an escalation: test failures beyond a threshold, security findings, architecture deviations. Let the agents handle the rest.
The Skill Layer Is the Leverage
Notice what Daisy's workflow depends on: "specialized agents instead of just the general-purpose one." The difference between a generalist IC and a specialist is the skill — the prompt, the tools, the context, the constraints you bake in.
This is where the leverage lives. Not in prompting better, but in encoding your domain knowledge into reusable agent definitions that can be composed. The leads don't need to know React; they need to know how to delegate to a React specialist and verify its output.
The Real Takeaway
The Anthropic engineers aren't using a different tool. They're using the same Claude Code you have, but they're using it as a multi-agent runtime instead of a chat interface. The primitives are all there: SendMessage, sub-agents, session persistence, skill definitions.
The question isn't whether this workflow works — it's what's stopping you from adopting it. The tooling is ready. The patterns are proven. The only missing piece is treating your AI coding assistant as a platform for agent orchestration rather than a conversational coding partner.
If this was useful, you can support my open-source work on Ko-fi or check out my services.