Agentic AI

If Agents Write the Code, Why Do You Still Need a Team?

Title card for If Agents Write the Code, Why Do You Still Need a Team, showing one person's day as four focused blocks plus meetings and fixes, with the note that agents add work to the same day

If you only have a minute, here's what you need to know.

  • The question. If agents write the code, why does a delivery team need more than two or three people? Because two jobs in the agentic software development lifecycle (SDLC) still need a person: deciding exactly what a change should do, and checking that what came back is right.
  • The limit. Both of those jobs run on focused attention, and a person only has so much of it each day. Detection of problems drops noticeably after about 30 minutes of watching, and code reviewers lose effectiveness after about an hour.
  • The evidence. Teams heavy on AI merge 98% more pull requests, while review time rises 91%. In Faros's 2026 data, high-adoption teams merge 31% more pull requests with no review at all.
  • The sizing rule. Count the hours of deciding and checking your planned work needs each week. Divide by the focused hours one person can give. That number is your team. In the worked example below, 60 changes a week comes out at four people.
  • The shape. Keep each team small and add teams as the work grows. One person should never be the only one checking their own change, so every change needs at least two people.

A client asked me a fair question recently. Their engineers use coding agents now, and work that used to take days comes back much faster. So why keep paying for delivery teams the size they had before? If the agents do the building, a couple of people and a stack of agents should be enough.

The question assumes the expensive part of software delivery was typing. For most of the last thirty years, it was. Team sizes, sprint lengths, and hiring plans were all built around how much code a person could write in a week.

Agents took over most of the typing. The other parts of the job are still done by people.

98% more pull requests merged on teams with high AI adoption. Review time up 91%.

Source: Faros AI, The AI Productivity Paradox, 2025 (10,000+ developers, 1,255 teams)

Faros sells engineering analytics, and this comes from telemetry on more than ten thousand developers. On high-adoption teams, developers finished more work and merged far more pull requests, and then the work sat in line waiting for a person to look at it. Faros's summary of the company-level picture: any link between AI adoption and delivery performance "evaporates at the company level."

Here is how I answered. An agent can build a change in minutes. Someone still has to decide exactly what that change should do, and someone else has to confirm it does it. Both of those jobs run on a person's focused attention, and every person has a limited amount of it each day. So the size of a team in an agentic SDLC is set by how much attention the work needs, not by how much code it needs.

Where the work went

Every change in an agentic SDLC goes through three jobs.

The three jobs in every change: Decide and Check each take a person's attention, while Build is done by an agent in minutes, so team size is set by the first and third jobs

The middle job is the one that got cheap. It used to take most of a team's week, and now it takes the least.

The first and third jobs did not get much cheaper. A vague instruction still produces the wrong feature. A change nobody checked can still break production, and there are now many more changes.

I made the case for organizing around this in If I Built My Engineering Organization From Scratch Today: checking becomes a real job with its own headcount. This post is about the question that follows. How much headcount?

Attention is a daily budget

Think about proofreaders at a newspaper that just bought a press ten times faster than the old one. The faster press means more pages waiting to be read. And a proofreader who reads for eight hours straight misses more in the afternoon than in the first hour, however good they are.

That is a measured effect, and it was first measured on people watching radar screens.

During the Second World War, the psychologist Norman Mackworth built a test to simulate the long watches of British radar operators: a clock hand that ticked forward once a second and occasionally jumped two steps instead of one. People watched for the double jump for two hours. Their accuracy dropped noticeably after the first 30 minutes. It became one of the founding results in attention research, under the name vigilance decrement.

Code review shows the same pattern.

200 to 400 lines over 60 to 90 minutes finds 70 to 90% of defects. Past about 400 lines, or about an hour, the reviewer starts missing things.

Source: SmartBear, study of a Cisco Systems programming team

So a good reviewer does not have eight hours of review in them each day. They have a few focused sittings, with breaks between. Writing a precise spec draws on the same reserve. It is the same kind of careful, focused work, and it tires a person out the same way.

That reserve is what you are buying when you staff a team. Each person brings a fixed number of good, focused hours a week. Agents leave that number where it is and increase the work waiting for it.

What happens when the budget runs out

When the work waiting for a check is bigger than the attention available, one of two things happens. The work waits, or it goes through without a real check.

Faros's 2026 data, from 22,000 developers across more than 4,000 teams, shows both.

Median time in pull request review up 441%. 31% more pull requests merged with no review at all.

Source: Faros AI, AI Engineering Report 2026 (high- versus low-AI-adoption teams)

That second number is what attention running out looks like in the data. When the line of changes gets longer than the people available to check them, some changes get merged without a check.

Google's DORA research, which surveys thousands of technology professionals each year, found the downstream effect. In its 2025 report, AI adoption now improves how much software teams deliver. It also continues to make delivery less stable. DORA's explanation is that more changes, without strong testing and fast feedback to absorb them, turn into more failures.

Shrinking the team makes this worse. Fewer people means less attention to spend on the same, or larger, volume of changes.

Why one person cannot run ten agents

The natural follow-up is to keep two people and give each of them ten agents.

The limit is the checking. A person can start ten agents in a morning. They cannot check ten agents' worth of changes properly by the afternoon, and the agents keep producing.

The teams I have seen do this well put two rules in place.

There is also a rule that sets a floor on team size. The person who directed a change does not approve it. They are too close to it, the way a student grading their own exam reads what they meant to write rather than what is on the page. A separate AI reviewer that did not write the code can take the first pass. A different person still signs off.

That means every change needs at least two people. With each of them capped at about two streams, a pair can keep roughly four streams of work moving at once. That is the ceiling a two-person plan would hit.

How to size the team

Work backward from attention. Here is the arithmetic for a hypothetical team, with the assumptions stated so you can swap in your own.

Imagine a retailer's e-commerce team that wants its agents to ship 60 changes a week. They come in three risk levels, and each level needs a different amount of human attention.

That comes to about 68 hours of focused human attention every week. Assume each person can give about four focused hours a day to this kind of work, or 20 a week. The rest of their day goes to meetings, conversations with the business, and fixing what the checks catch.

68 divided by 20 is about three and a half people. Round up to four.

Sizing a hypothetical team shipping 60 changes a week: 40 low-risk, 15 medium-risk and 5 high-risk changes add up to about 68 hours of focused attention, divided by 20 hours per person, rounds up to four people

If the retailer wants 180 changes a week instead of 60, the same arithmetic says about ten people. The right way to get there is three small teams, each with its own work. One team of ten would struggle. In my experience, past about six people a daily check-in can no longer cover what everyone is doing, and it gets unclear who is checking whose work.

Two things in this math matter more than the exact minutes.

Risk sets the cost. The five high-risk changes take more human time than the forty low-risk ones combined. Sorting every change by risk before an agent touches it lets the team spend its checking time on the changes that can hurt the business.

The number is yours to measure. My minutes are placeholders. Your team's actual time to specify and check a change, by risk level, is a number you can track from your own pull requests within a month.

What to do this week

Measure review wait. Pull the median time from "change ready" to "change checked" for the last month. If it is growing while output grows, attention is your constraint, and cutting people will lengthen the line.

Sort changes by risk before they start. Agree on three levels and write the level into each change's description. Decide in advance what checking each level gets.

Separate the author from the checker. Make it a rule, in your tooling where you can: the person who directed a change cannot be the only person who approves it.

Cap work in progress. Start with two active agent streams per person. Raise the cap only when review wait stays flat.

Set a stop rule. Pick a threshold, such as one working day of review wait, and stop starting new work when it is crossed.

Size from attention. Run the arithmetic above with your own numbers before your next headcount conversation, and bring the result to it.

The answer to the client

The client was right that their teams should look different. The people on them now spend their days deciding and checking rather than writing code, and the roles, hiring, and career paths should change to match.

They were wrong about the headcount. A team's size now comes from how much deciding and checking its work needs, and agents increase that amount. Size the team for that work, keep each team small, and add teams when the arithmetic says so.

Matthew Kruczek is Managing Director at EY, leading Microsoft domain initiatives within Digital Engineering. Connect with Matthew on LinkedIn to discuss how to size and structure delivery teams for agentic development.

References

  1. Faros AI, "The AI Productivity Paradox Research Report," 2025. Telemetry from 10,000+ developers across 1,255 teams: 21% more tasks completed, 98% more pull requests merged, 91% longer PR review time, and the finding that correlation with performance "evaporates at the company level." https://www.faros.ai/blog/ai-software-engineering
  2. Faros AI, "AI Engineering Report 2026: The Acceleration Whiplash." 22,000 developers across 4,000+ teams: median time in PR review up 441.5% and 31.3% more PRs merged without any review, high- versus low-AI-adoption teams. https://pages.faros.ai/hubfs/AI_Engineering_Report_2026_The_Acceleration_Whiplash_Faros.pdf
  3. Google Cloud, "Announcing the 2025 DORA Report: State of AI-Assisted Software Development," September 23, 2025. AI adoption's positive relationship with throughput and continued negative relationship with delivery stability. https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report
  4. Mackworth, N. H., "The breakdown of vigilance during prolonged visual search," Quarterly Journal of Experimental Psychology, vol. 1 (1948), pp. 6-21. The clock test and the decline in detection after 30 minutes on task.
  5. SmartBear, "Best Practices for Code Review," citing SmartBear's study of a Cisco Systems programming team: 200-400 lines over 60-90 minutes yields 70-90% defect discovery; effectiveness drops beyond 400 lines and after about 60 minutes. https://smartbear.com/learn/code-review/best-practices-for-peer-code-review/
  6. Matthew Kruczek, "If I Built My Engineering Organization From Scratch Today." https://matthewkruczek.ai/blog/agentic-engineering-org.html

Continue Reading