Adding People to a Late Project: When Brooks’s Law Holds, and When It’s an Excuse


man standing in front of people sitting beside table with laptop computers

About half the managers of runaway software projects try the same rescue. A UK study cited by Steve McConnell in his 1999 IEEE Software column found that when projects overran their schedule or budget by more than 30 percent, roughly half of the managers responded by adding staff. It is the most intuitive move in delivery management, and it has had a famous warning label on it since 1975.

That warning is Brooks’s law: “Adding manpower to a late software project makes it later.” Fred Brooks wrote it in The Mythical Man-Month after watching IBM’s OS/360 effort swell, and it has been quoted in roughly every delivery meeting since. The trouble is that both camps use it badly. Executives ignore it and ask for more people. Product and engineering leads quote it as a reflex to shut the request down, even when more people would actually help.

The evidence is more useful than either reflex. Here is what it says, and how a product manager should handle the conversation when someone senior asks, “What if we just throw more people at it?

What Brooks actually claimed

Brooks’s argument rested on three costs, and it helps to name them separately because they behave differently.

Ramp-up. New people are not productive on day one, and the people who are productive have to stop and teach them. That is a tax paid by your best engineers, at exactly the moment you need them most.

Communication overhead. Every person you add creates new pairs who need to coordinate. The count of communication paths grows as n(n−1)/2: a team of five has 10 possible pairs, a team of ten has 45. Not every pair talks, but the meetings, handoffs and “quick syncs” grow faster than the headcount does.

Indivisible work. Some tasks cannot be split. Brooks’s line about nine women not being able to deliver a baby in one month is the part everyone remembers. The less famous point is that most software sits somewhere in between: partly divisible, with a sequential core that no amount of staffing will compress.

Brooks himself was not dogmatic about it. Twenty years later, in the anniversary edition of the book, he described the law (as McConnell reports it) as “the best zeroth order approximation to the truth.” A zeroth order approximation is a starting point, not a verdict.

The data: bigger teams buy a little time at a large price

The best long-running evidence on team size comes from QSM, which has been collecting completed-project data for decades. Its summary of four studies on team size is worth reading in full, but the pattern is consistent:

  • Doug Putnam’s 1997 analysis of 491 completed projects found that for medium-sized systems, teams of 3 to 7 people delivered the best combination of productivity, schedule and cost.
  • A 2012 study of nearly 1,060 IT projects found that on large projects, the bigger teams cost about four times as much and produced about three times as many defects, for what the author called “meager schedule compression.”
  • Putnam’s later revisit of 390 applications found that the larger teams did cut the schedule, by approximately 30 percent. They also increased cost by 350 percent and produced 500 percent more defects.

Read that last result carefully, because it is the honest version of the trade. More people did make the project shorter. They did not make it later, which is what the slogan predicts. But the time came at a ruinous price in money and quality, and the defects show up after launch, which is when you can least afford them.

The cost-and-schedule literature points to a ceiling. Bertrand Meyer, summarizing Barry Boehm’s work and McConnell’s later book on estimation, describes a firm limit: spending more can shorten a schedule, but the maximum reduction from the nominal schedule seems to be about 25 percent. Below 75 percent of the nominal time is the “impossible zone.” If your project needs to land 40 percent sooner, no hiring plan gets you there.

So the evidence does not say “never add people.” It says adding people buys a modest amount of time, with a hard ceiling, at a steep and partly hidden cost.

“Later than what?”

McConnell’s column makes a sharper point that product managers should borrow. Brooks’s law, he argues, only applies in the final stretch of a project, once the remaining work is too short for newcomers to pay back their ramp-up. The problem is that most teams have no idea where the final stretch begins.

His phrasing: “Most projects think they’re 90 percent complete for the last 50 percent of the project.” If you believe you are a month from done, adding people looks pointless. If you are actually five months from done, a new engineer has plenty of time to become productive. McConnell’s conclusion is blunt: “Because of widespread poor tracking, people think they’re at risk from Brooks’ Law for significantly longer periods than they really are.”

That flips the usual argument. The person quoting Brooks’s law to block headcount is often relying on the same optimistic estimate that made the project late in the first place. Before you agree or disagree with the staffing request, you need a credible answer to how much work actually remains. I have written before about the 90 percent done trap; this is where it bites hardest, because the staffing decision inherits every error in the completion estimate.

A late project I would staff differently today

Running IT operations at a large telecom, I sat in the room for a version of this more than once. The one I think about most was a provisioning system replacement that was supposed to cut over before a regulatory deadline. About two-thirds of the way through the plan, the team reported it was on track for the build and behind on integration testing. The response from above was to bring in a block of contractors.

Two things went wrong, and neither was the one Brooks warned about. The contractors arrived ready to write code, but the remaining work was mostly testing against legacy systems that only three of our people understood. Those three spent the next month answering questions instead of testing. And because nobody had re-estimated the integration work honestly, we did not know the project was actually about four months from done, not six weeks. If we had known, we would have had time to train people properly, and we would have aimed them at work they could own.

The lesson I took from it was not “don’t add people.” It was that the staffing question is downstream of two others: where are we really, and what kind of work is left?

Four questions to ask before approving more people

When the request lands on your desk, or comes out of your own leadership team, these four questions do more work than any slogan.

1. Can the remaining work be split into pieces someone new could own?

This is the partitioning question, and it is about the remaining work, not the project as a whole. A new service with a clean interface, a separate client platform, a documentation or migration workstream: those can absorb people. A tangled core with one architect holding the design in their head cannot. McConnell notes that well-controlled projects have better designs and documentation, which makes tasks “more partitionable and training less labor intensive.” If your architecture lets you hand someone a bounded problem, staffing can help. If every task touches the same three files, it will not.

2. How late are we, measured by something other than optimism?

Replace the percentage-complete number with evidence: remaining items with a realistic throughput, a forecast based on how fast work has actually been finishing, or a fresh bottom-up estimate by the people doing the work. If the answer is weeks, extra people will mostly cost you time. If it is months, they might earn their keep. The work item age of what is in progress tells you a great deal here; a pile of items that have been “almost done” for weeks is a signal the estimate is wrong.

3. Who pays the training tax, and can we afford it?

New hires take a long time to reach full output. A Microsoft Research study on the ramp-up of new developers measured how long it took new hires to reach the median output of existing employees, and found the journey ran to weeks or months, with mentoring and well-chosen starter tasks speeding it up. Someone has to do that mentoring. Name the person. If it is the one engineer who understands the critical path, you are trading their throughput for a future payoff that may arrive after the deadline.

4. Is the bottleneck actually people?

Late projects are often late because work is waiting, not because nobody is available to do it. Approvals, environments, a dependency on another team, a vendor, a test lab booked solid. Adding engineers to a project whose real constraint is a shared staging environment produces more half-finished work queued behind the same constraint. If the team already has too much work in progress, more people usually means more items started and the same number finished.

Levers that usually beat headcount

If the answers above point away from staffing, the PM still owes leadership an option, not just a “no.” The usual candidates, in rough order of how fast they work:

Cut or defer scope. McConnell cites the Standish finding that more than half of late projects ended up cutting significant functionality anyway. Doing it early, on purpose, beats doing it late by accident. The conversation is easier if you bring a ranked list of what ships at the date and what follows in the next release.

Resequence. Pull forward the pieces customers or the deadline actually depend on. A regulatory cutover usually needs a narrow slice of the system working, not the whole thing.

Remove a dependency. One escalation to unblock another team’s work can be worth several engineers.

Protect the people you have. Pull the core team off support rotations, interviews and side projects for the remaining stretch. This is the cheapest capacity you will ever find, and it has no ramp-up.

Move the date honestly. Sometimes the right answer is a new date, delivered early and with a forecast behind it. Leaders forgive a moved date far more readily than they forgive a status that stayed green until the week before launch.

When adding people does make sense

There are cases where the answer is yes, and a PM who only ever quotes Brooks will lose credibility when they come up.

  • The project is early or mid-stream, and an honest forecast shows months of work left.
  • The new people can take a separable workstream with a clear interface: a second platform, a data migration, test automation, an integration with its own contract.
  • The additions are experienced people who have worked in this codebase or domain before, so ramp-up is days rather than months.
  • You are adding to a small team, where the coordination cost of one or two more people is low.
  • The business has explicitly accepted the cost and quality trade QSM’s data describes, because the date is worth more than the money.

The last one matters. “Thirty percent faster at three and a half times the cost, with more defects” is a legitimate trade when a contract penalty or a market window is large enough. The PM’s job is to make sure the people approving it know that is the trade they are making.

What to say in the meeting

When someone asks whether more people would help, avoid both “yes, absolutely” and “Brooks’s law says no.” Give them the shape of the trade instead. Something like: “We have roughly four months of work left based on how fast we’ve actually been finishing. Two experienced engineers could take the reporting module on their own, which might bring the date in by three or four weeks. Adding more than that would mostly slow the core team. If the date matters more than that, here is the scope we would cut.”

That answer respects the evidence, gives leadership a real decision, and shows you know the difference between a slogan and a forecast. It is also the kind of answer that gets you invited into the next staffing conversation instead of being told about it afterward.

Ty Sutherland

Ty Sutherland is the editor of Product Management Resources. With a quarter-century of product expertise under his belt, Ty is a seasoned veteran in the world of product management. A dedicated student of lean principles, he is driven by the ambition to transform organizations into Exponential Organizations (ExO) with a massive transformative purpose. Ty's passion isn't just limited to theory; he's an avid experimenter, always eager to try out a myriad of products and services. While he has a soft spot for tools that enhance the lives of product managers, his curiosity knows no bounds. If you're ever looking for him online, there's a good chance he's scouring his favorite site, Product Hunt, for the next big thing. Join Ty as he navigates the ever-evolving product landscape, sharing insights, reviews, and invaluable lessons from his vast experience.

Recent Posts