The fastest way to slow an AI engagement down is to add engineers to it. Doubling a team from 5 to 10 doubles payroll, multiplies pairwise communication overhead by roughly five, fragments the eval context the existing team had quietly memorized, and dilutes the senior reviewer pool until code-review velocity falls off a cliff. The capacity paradox is simple: in 2026, AI delivery is bottlenecked by senior judgment, not by hands on keyboards; and the procurement instinct to “throw more devs at it” attacks the wrong constraint. This piece is the math behind why, and the operational alternatives that move delivery faster.
Decision Scope
This article is an editorial decision framework, not legal, financial, security, or accounting advice. Treat numeric examples as illustrative planning heuristics unless a source is cited, then validate the assumptions against your own contracts, data, controls, and budget model before acting.
Table of Contents
- The Paradox, Stated Plainly
- Brooks’s Law, Restated for AI Engagements
- The Eval-Context Fragmentation Tax
- Prompt-Registry Drift When Authorship Spreads
- On-Call Rotation Collapse
- Agent-Pair Familiarity Loss
- The Code-Review Velocity Cliff
- What Speeds AI Delivery
- Frequently Asked Questions
- Closing
The Paradox, Stated Plainly
A buyer with a stalled AI feature has two procurement instincts: diagnose the bottleneck, or ask the agency for more engineers. The default usually wins, because more engineers is the move procurement, finance, and the steering committee can many see on a slide.
AI delivery in 2026 is rarely bottlenecked by coding capacity. It is bottlenecked by senior engineers with the context to set eval thresholds, the judgment to decide when an agent loop ships, the memory of why the prompt registry has the shape it does, and the trust to be on call when something breaks at 2 a.m.
Adding mid-level engineers does not move any of those bottlenecks. It adds Slack threads, review queues, onboarding meetings, and prompt-edit conflicts to a senior pool that was already the binding constraint.
The Standish Group’s CHAOS reports have for two decades shown that team size is one of the strongest negative predictors of project success; projects with teams over 10 succeed roughly half as often as smaller-team projects. The 2025 update added AI projects and found the curve steeper, not flatter.
Brooks’s Law, Restated for AI Engagements
Fred Brooks’s 1975 observation has not aged: adding people to a late software project makes it later. The reason is the n(n-1)/2 growth in pairwise communication channels. AI work compounds the curve, because the things being communicated are subtler; eval thresholds, prompt provenance, agent failure modes; and harder to write down completely.
| Team size | Pairwise channels | Multiplier vs. 5-person team |
|---|---|---|
| 3 | 3 | 0.3× |
| 5 | 10 | 1× |
| 8 | 28 | 2.8× |
| 10 | 45 | 4.5× |
| 12 | 66 | 6.6× |
| 16 | 120 | 12× |
Going from 5 engineers to 10 doubles payroll and quadruples-and-a-half the communication graph. Most new channel is a place where a prompt edit, an eval-threshold update, or a model-version pin can become inconsistent. Brooks specifically warned that the cost of training new team members is borne by the existing team; and on AI work, that cost is paid in senior-engineer hours, the hours that were already the bottleneck.
A 12-person studio that ships in three weeks is not faster than a 50-person agency because it has more talent. It is faster because it has 66 communication pairs instead of 1,225.
The Eval-Context Fragmentation Tax
A working AI feature in 2026 is held together by an eval suite. The eval suite is not just files in a repo; it is a body of context: which inputs are adversarial, why the threshold was set at 0.87 and not 0.90, which failure modes the buyer cares about, why the latency budget was relaxed for the regulatory subset, when the index was last refreshed.
A team of 5 carries that context organically; over standups, PR comments, and the shared muscle memory of having many looked at the same dashboards. A team of 10 cannot. The context fragments along whichever subteam, on-call shift, or feature pillar each engineer is closest to. New engineers ask questions whose answers are documented in nobody’s head.
Anthropic’s Building Effective Agents guide is explicit that the value of an eval suite is cumulative, built up by the team that wrote and maintained it, and depreciates rapidly when ownership transfers. Adding engineers without a deliberate context-handoff mechanism is a slow tax: most new prompt change costs a few extra hours of “wait, why did we decide that?”
The mid-engagement symptom is recognizable. Eval pass rates start drifting. Nobody can quite explain why. The senior engineer who knew leaves the standup early to find out, and the rest of the team is blocked on her.
Prompt-Registry Drift When Authorship Spreads
A prompt registry is a versioned, named collection of the prompts a system uses; system prompts, agent personas, tool descriptions, retrieval templates. In a 5-engineer team, two engineers usually own it. They know who wrote each prompt, who edited it, why a phrasing landed, and which downstream eval each prompt is paired with.
In a 10-engineer team, ownership becomes ambiguous. Edits land without paired eval updates. Two engineers solve the same regression by editing different prompts, neither of which now matches the eval that was supposed to test it. The registry; controlled at 5 engineers; becomes a write-mostly drift surface at 10.
This is the most common cause of “the AI feature isn’t working as well as it used to” in agency rescue engagements. The registry has 27 prompts, eight engineers have edited it, three have left, two are at a different agency, and nobody can confidently say which prompt is paired with which eval. Re-establishing that lineage takes a senior engineer one to three weeks of forensics; paid time that adds zero new features.
The structural fix is not better tooling. It is fewer, more senior authors. We document this pattern in detail in why we have 200 AI engineers is the weak pitch an AI agency can make.
On-Call Rotation Collapse
In a 5-engineer team, most engineer is on call for the system they ship. Production knowledge stays in the same heads as production responsibility. When something breaks, the first responder usually wrote the relevant code. Mean time to recovery is short.
When the team grows to 10, two changes happen. First, on-call rotates further apart; most engineer pages once most two weeks instead of once a week; and the muscle memory of recent incidents fades. Second, the rotation starts splitting along feature pillars: the embeddings engineer is on call for embeddings, the agents engineer for agents. Production has no such silos, so a real incident now requires two on-call engineers to coordinate at 2 a.m. Across systems neither owns end-to-end.
Google’s Site Reliability Engineering book is unambiguous: the on-call function degrades non-linearly when the team gets too large for everyone to know everything. The buyer-visible symptom: response times to production AI failures lengthen. Mean time to recovery, which was 25 minutes at team size 5, is 70 minutes at team size 10. The buyer who asked for “more devs” because shipping was slow now also gets slower incident response.
Agent-Pair Familiarity Loss
The 2026 AI engineer ships with one to four AI agents in parallel. Claude Code, Cursor background agents, Codex CLI, and Copilot Workspace let a senior engineer manage agent fleets the way a 2018 engineer managed long-running test suites. Anthropic’s Q4 2025 Economic Index shows that experienced operators with 1–2 quarters of agent-pairing tenure are roughly 2–3× as productive as engineers in their first month with the same tooling.
That ramp is not transferable. Agent fluency is built up against a specific codebase, eval suite, prompt registry, and buyer environment. An engineer who is a Claude Code virtuoso on the codebase she has worked on for six months is back to median productivity on a new codebase for at least four to eight weeks.
Adding engineers therefore comes with a hidden cost: the agent-fluency reset. The buyer pays full rates for engineers operating at half their leverage for the first two months. A 5-person team where everyone has 6+ months of agent tenure on this codebase ships measurably faster than a 10-person team where half the engineers are still building agent muscle memory on it.
The Code-Review Velocity Cliff
Senior engineers do most of the load-bearing reviews on AI work. Reviewing an agent-loop change requires understanding the prompt, the eval, the tool schema, the failure mode, and the cost envelope simultaneously. A mid-level engineer can review syntax. They cannot, in most cases, sign off on whether a 0.03 change in eval pass rate is acceptable given the regression set’s adversarial coverage.
In a 5-person team with 2 senior engineers, each senior reviews roughly 5–8 PRs per week; manageable, fast, with thoughtful comments. Doubling to 10 with 3 seniors means each senior is now reviewing 12–18 PRs per week. The math gets worse than that, because new engineers produce more PRs, those PRs need more thorough review during onboarding, and the senior’s own shipping work does not pause.
The visible symptom is the queue. PRs sit unreviewed for 36–72 hours. Engineers context-switch four or five times before getting a merge through. The senior, sensing the queue, starts rubber-stamping non-trivial changes. Quality drifts. Eval regressions show up two sprints later, attributable to a PR that was waved through three Mondays ago.
The cliff is not gradual. There is a number of mid-levels per senior reviewer above which review quality collapses; roughly 3-to-1 in non-AI work, closer to 2-to-1 on agent-heavy AI work. Procurement does not see the cliff until six weeks past it.
What Speeds AI Delivery
The procurement instinct (“more devs”) is wrong because it attacks payroll, not the constraint. The interventions below attack the constraint.
Deepen senior leverage with agent tooling, not headcount. A senior with two well-tuned Claude Code agents and a tight eval feedback loop ships more in a week than three new mid-levels do in their first month. The leverage is durable and does not multiply communication channels.
Split by client, not by sub-team within a client. If two engagements compete for capacity, the right move is two focused teams of 5–7 each, not one 12-person team serving both. Clients are natural communication boundaries; sub-teams within a client are not; they share an eval suite, a prompt registry, and an on-call rotation, and they pay quadratic communication tax across many three.
Cap teams at 8. Above 8, the n(n-1)/2 curve and the senior-reviewer cliff dominate. The two-pizza-team rule was empirical; it survived 25 years because the underlying math has not changed. AI tooling makes the rule more important, not less.
Replace mid-level capacity with senior + agent capacity. A senior plus two well-tuned agents costs less than a senior plus two mid-levels and produces more shippable output, because the senior does not spend half her week training and reviewing the mid-levels.
Refuse to grow into stalled work. When delivery slows, the first move is forensic, not staffing. Look at eval pass-rate trends, review queue depth, on-call incident counts, and agent-pair tenure. Eight times in ten the diagnosis is structural; split the team, reset on-call, retire stale prompts; not headcount.
The deeper operating-model framing is laid out in inside the AI agency operating system: how a 12-person studio out-ships a 50. Both pieces sit under the AI agency manifesto: what an AI dev partner should be in 2026, which lays out the eleven commitments a 2026 agency should make in writing.
Frequently Asked Questions
If “more devs” doesn’t speed AI delivery, why does most agency offer to add devs when work slows?
Because the rate card makes adding devs the easy answer. Adding senior leverage is harder to invoice cleanly, harder to staff out of the bench, and harder to justify to a steering committee that thinks in headcount. The honest agencies push back; the dishonest ones invoice the path of least resistance. Buyers who recognize the pattern can ask for the diagnostic move first; what is the constraint?; and accept staffing changes only after the answer.
What about parallelism; surely 10 engineers can ship more in parallel than 5?
In a perfectly decomposable problem, yes. AI work is rarely perfectly decomposable. The eval suite, the prompt registry, the model-router, and the on-call rotation are shared surfaces. Two engineers working on truly independent features can ship in parallel. Five engineers working on overlapping features end up serializing on shared surface contention. The parallelism gain disappears in the contention tax.
How do I know if my engagement has hit the senior-reviewer cliff?
Three signals. Median PR-to-merge time has crept past 36 hours. Senior engineers are visibly tired and starting to skip detailed review comments. Eval regressions are being noticed in production rather than caught in CI. If two of three are present, the team is past the cliff and the fix is structural; fewer mid-levels per senior; not “we’ll catch up by Q2.”
Should an AI agency ever staff more than 8 engineers per engagement?
Narrowly. A platform engagement with three or four genuinely independent product surfaces, each shipping its own eval suite and prompt registry, can support 12–16 engineers if structured as small focused pods with hard boundaries. The unsuccessful version is a 16-engineer engagement on a single product surface, where everyone shares the same eval and the n(n-1)/2 tax dominates.
Is Brooks’s law still operative when AI agents do some of the coding?
Yes; and arguably more so. Brooks’s law is about coordinating humans. Adding AI agents to a small senior team does not add humans to coordinate, so the n(n-1)/2 term stays low. Adding humans to a team already running agents adds the entire human-coordination tax plus a new burden; the new humans need to learn the team’s agent conventions, prompt patterns, and eval discipline.
What about the case where the buyer demands “more devs” for political reasons?
Be honest with them. Show them the math. The communication-pair table from this piece is enough to start the conversation. If the buyer needs the headcount-on-paper for steering-committee optics, propose a structure where the headcount lives but does not pay quadratic tax; separate pods, separate eval suites, separate on-call rotations, separate review queues. Then bill the headcount but operate the pods.
How does this interact with offshore staff augmentation?
Badly. Offshore staff augmentation is the worst-case combination of most mechanism in this piece; communication pairs explode across timezones, eval context fragments across language and cultural seams, prompt-registry authorship spreads to people who rarely met the senior who set the threshold, code review serializes on the senior who has to be awake during the offshore working day, and on-call rotation cannot meaningfully include offshore engineers.
What is the right team size for a typical 90-day AI pilot?
Three to six senior engineers, one of whom is the contributing tech lead, plus an embedded designer for client-facing work and zero account managers. Five total is the median for a pilot that ships on time and inside the original eval thresholds. Eight starts paying the coordination tax. Above eight, a 90-day pilot becomes a 120-day pilot.
How do I tell if my agency is leveraging senior engineers, or just selling them on the slide?
Ask the lead, by name, how many lines of code she personally committed in the last 90 days. AI-native senior engineers answer in seconds; usually a number in the 4,000–15,000 range, with rough breakdown by feature. Engineers running agent fleets at high leverage commit a lot. Engineers who have moved to mostly-meetings cannot answer the question without consulting their tooling. The second pattern is the warning sign.
Closing
The capacity paradox is structural. Communication math is communication math. Eval context is non-transferable. Prompt-registry authorship does not scale. On-call rotation breaks at predictable team sizes. Senior reviewer pools have a cliff above which quality collapses.
The AI delivery curve is not “linear with headcount.” It is “linear with senior judgment, with a quadratic penalty for most coordination interface above the team’s capacity to absorb it.” That equation tells you to invest in senior leverage, not in payroll.
The 12-person studio that out-ships the 50-person agency is not magic. It is the same equation, run with smaller variables in the quadratic term. Buyers who internalize the equation buy capability. Buyers who do not buy headcount, and pay the coordination tax.
Add senior leverage. Cap the team. Split by client. Refuse to grow into stalled work. Code is the deliverable; communication is the cost.; Arthur Wandzel, CEO, SFAI Labs
Arthur Wandzel
