One developer’s reported Claude Code operation uses two senior leads to coordinate nine projects, with project managers, technical leads, and narrowly scoped coding agents beneath them. The account describes a way to organize heavy parallel work—not a measured benchmark or a setup most solo developers should copy wholesale.
Ali Suleyman TOPUZ describes the arrangement in a first-person account published on DEV Community; the page says it first appeared on Medium on September 11 and was posted on DEV on September 13, but the year is not established in the available article text. The project count, staffing estimates, and daily prompt volume below are the author’s reports, not independently measured results. Read the account on DEV Community.
![Claude AI for Beginners Bible: [5 in 1] The Ultimate Guide to Automate Your Work, Save Hours Every Week, and Use AI for Real-World Results](https://m.media-amazon.com/images/I/415+fSJacsL._SL160_.jpg)
As an Amazon Associate I earn from qualifying purchases.
How the nine-project hierarchy is organized
The setup separates portfolio-level coordination from project execution. Two persistent lead sessions—named lead-alpha and lead-beta—run on different machines. The author says they exchange periodic heartbeat messages and can restart one another if a session stops responding. Together, they divide ownership of nine projects.
Each project has two roles beneath the top-level leads:
- Project manager (PM): tracks scope, turns requests into tickets, and discusses priorities with the top-level lead.
- Technical lead: breaks work into tasks, assigns tasks to individual-contributor (IC) agents, and reviews their diffs before a human sees them.
The author estimates five to ten scoped IC agents per project technical lead and roughly 75–90 active agent roles across the operation. These are the author’s estimates; most roles are reportedly idle when there is no queued work. The figures describe roles, not a claim that every agent is continuously coding.
Where the human’s attention goes
The author reports writing 30–50 prompts per day across the operation, not per project. They estimate that their interaction time is divided roughly as follows; the account does not describe a measurement method.
| Reported focus | Approximate share of interaction time |
|---|---|
| Two top-level leads | 60% |
| Project technical leads and PMs | 35% |
| Escalations | 5% |
The structure is meant to make the human’s work mostly supervisory: discuss priorities and outcomes with leads, while project roles handle decomposition and workers handle defined implementation tasks. The reported prompt count and time split are specific to this author’s operation, not a productivity target or a prediction for another team.
Rank #2
What the author says makes the workflow possible
The account attributes the setup to two Claude Code behaviors: forked subagents and messaging between sessions. It says a fork inherits the spawning agent’s conversation context and prompt cache, usually runs in the background, and returns a final result without adding all of its tool output to the parent’s context. It also claims forks ignore model overrides and names CLAUDE_CODE_FORK_SUBAGENT=0 as a way to disable the behavior.
For communication between sessions, the author says that mentioning a live named session routes a message through SendMessage. The account also says /config includes dialog-expiry and inbound-message options—accept, hold, or refuse—and describes the capabilities as default behavior in Claude Code 2.1.232.
These are claims in the author’s account, not confirmed current product documentation. The account does not establish whether the version, command, environment variable, messaging behavior, or defaults remain accurate in the Claude Code version a reader currently uses. Confirm such details in current official documentation before building a workflow that depends on them.
How work is bounded and reviewed
The hierarchy’s practical safeguard is clear ownership. A technical lead divides a request into work that can be checked independently, assigns non-overlapping areas where possible, and reviews each diff. Workers are expected to stay inside a narrow task or code area rather than make broad changes on their own authority.
The article’s examples illustrate that boundary. A technical-lead definition directs the lead to decompose work, delegate, check diffs, and avoid overlapping file assignments. A migration-only worker definition limits changes to db/migrations/ and instructs the worker to stop if asked to edit outside that directory. Those are example instructions, not proof that a worker will always obey them; a reviewer still needs to check the actual changes.
The author also describes withholding broad credentials from lower-level agents and requiring lead approval for production access. These controls reduce how much authority a worker has, but the account does not establish them as guarantees against mistakes or misuse. The key design principle is to keep delegated permissions commensurate with the task and preserve a human review point for consequential changes.
Failures the author is trying to prevent
The account says the hierarchy was shaped by concerns about multi-agent coordination and describes three failure patterns. Its numerical examples are relayed secondhand; the underlying studies, methods, and results were not independently verified in the available material.
Agents converging on the same choice
The article calls this “low-variance conformity”: agents working separately may still select the same answer rather than explore alternatives. It reports that 18 of 30 agents chose the branch name “mvp-game-loop,” and describes a polling system that generated 2.4 million job requests. These examples are claims from the account, not independently established measurements here.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Conflicts between interdependent changes
Parallel work can collide when tasks touch shared files or depend on decisions made elsewhere. The author refers to game-development experiments with low pull-request merge rates, but the account does not provide enough primary-study detail to assess that result. In the described workflow, narrow assignments, routing cross-task decisions through a technical lead, and reviewing diffs are intended to reduce this kind of conflict.
Agents pursuing incompatible objectives
The article describes “turf wars” in which agents with conflicting objectives escalate into sabotage-like behavior. It says a tested model reached a truce in 98% of runs, but the underlying experiment and conditions are not established in the available account. That figure should not be read as a general safety rate or assurance about real software work.
The author’s response to these risks is organizational rather than a claim that more agents automatically improve results: keep worker scope small, centralize decisions that cross task boundaries, inspect changes, restrict credentials, and put production access behind lead approval. Two leads provide another coordination layer in this particular operation, but the account does not demonstrate that redundancy prevents failures.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.What a solo developer or small team should borrow
The author explicitly advises against reproducing the full nine-project design for one person or one or two projects. In that situation, a second lead with heartbeat restarts and a dedicated PM-agent layer add coordination overhead without the same portfolio-scale need.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →The more transferable pattern is a single agent responsible for decomposition and review, paired with workers assigned narrowly bounded tasks. A small team can apply it in a few deliberate steps:
- Choose one accountable lead. Give that agent responsibility for breaking a request into independently verifiable tasks and coordinating dependencies.
- Define each worker’s boundary. Specify the task and the files or directory it may change; say what to do if the task requires work outside that boundary.
- Separate conflicting work. Avoid assigning multiple workers overlapping edits unless the lead has a clear integration plan.
- Review every diff. Treat an agent’s completion message as a handoff, not approval to merge or deploy.
- Keep sensitive access controlled. Do not give a worker broader credentials or production authority than its task requires.
- Check tool behavior before relying on it. Verify the current Claude Code version’s subagent and session-messaging behavior rather than assuming the account’s version-specific claims still apply.
This smaller structure retains delegation while keeping human oversight and integration manageable. Its success depends on the work, task boundaries, and review quality—not on matching the source account’s agent count.
Examples are illustrative, not production-ready infrastructure
The account also includes a Python example that uses SQLite as a local message mailbox and the Anthropic Python client for a worker call. It distinguishes that file-backed example from native interactive Claude Code sessions. The available account does not establish that the code was executed, tested, secure, or suitable for production, so it should be treated as an illustration rather than a ready-made orchestration system.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minute
