
There is no doubt that Brooks understood many of the challenges involved in developing software, and some of his observations remain as relevant today as they were when he first made them.
However, software engineering has changed enormously over the last fifty years, and even over the last thirty. Modular software development, Agile practices, modern tooling and, more recently, artificial intelligence have changed the way we design, build and deliver software.
Consequently, while I found some interesting ideas and useful reminders throughout the book, I also found a great deal that felt dated, unnecessarily lengthy or simply less applicable to modern software engineering.
Brooks' Law
Perhaps the most famous idea in the book is Brooks' Law:
Adding manpower to a late software project makes it later.
Brooks argues that adding more engineers to an already late project introduces additional communication and coordination overhead. Existing team members must spend time bringing new colleagues up to speed, and the number of potential communication paths increases as the team grows.
He also points out that some tasks cannot be accelerated simply by assigning more people to them. His analogy is that having a baby takes nine months, regardless of how many women are assigned to the task.
I agree with the underlying principle that adding more people to a project doesn't necessarily make it progress faster. However, I don't believe Brooks's Law holds as universally as it might once have done.
Modern software systems are increasingly modular, with clearly defined responsibilities, interfaces and boundaries. It is entirely possible for different engineers, or even different teams, to work on separate parts of a system without needing to communicate with everyone else involved.
The communication overhead Brooks describes is real, but it doesn't necessarily grow in the way his argument suggests. Not every engineer needs to speak to every other engineer, and good software architecture can reduce the need for that communication considerably.
Of course, adding engineers to a tightly coupled system, particularly when they are unfamiliar with the codebase, can still make matters worse. Equally, adding people won't help when the remaining work is inherently sequential or cannot sensibly be divided.
However, where work can be divided into relatively independent tasks, and new engineers can become productive without significant disruption, adding capacity can accelerate delivery.
I think Brooks's Law is better treated as a warning about the consequences of adding people without considering the structure of the work, rather than an immutable law of software engineering.
The Second-System Effect
One of the most interesting and enduring ideas in the book is what Brooks calls the second-system effect.
His argument is that an engineer's second major system is often the most dangerous. Having learned from the mistakes and limitations of their first system, they approach the second with greater confidence and a long list of improvements they want to make.
Unfortunately, that confidence can lead to overengineering. The second system becomes an opportunity to incorporate everything they couldn't include in the first, whether it is needed or not.
The result is often a system that is considerably more complicated than it needs to be.
This is something I recognise in modern software engineering. We have an enormous range of frameworks, architectural patterns and technologies available to us. Microservices, Kubernetes, event-driven architectures and elaborate abstractions all have their place, but that doesn't mean they are appropriate for every system.
It is all too easy to introduce complexity to solve problems that don't yet exist.
I also see a connection here with Donald Knuth's advice about premature optimisation. Both warn against allowing technical ambition to take precedence over demonstrated requirements. Knuth warns against optimising before there is evidence that optimisation is necessary, while Brooks warns against introducing complexity simply because we have the experience and confidence to do so.
For me, the most important lesson is that experience alone doesn't necessarily produce better software.
Experience needs to be accompanied by judgement and restraint.
Being capable of building something is not, in itself, a good reason to build it.
Architecture and Implementation
Another observation I particularly liked appears in Brooks's discussion of the relationship between architects and those implementing their designs.
Brooks argues that an architect should suggest rather than dictate implementation details, recognise the creativity and responsibility of the engineer doing the work, and be willing to accept alternative approaches that satisfy the architectural objectives.
He also acknowledges that engineers implementing a design may discover problems or costs that weren't apparent when the architecture was conceived.
I agree with this wholeheartedly.
An architect shouldn't be detached from the practicalities of implementation, and engineers shouldn't simply be expected to follow instructions without question. Good architecture needs to accommodate the knowledge and experience of the people building the system.
This is one of the areas where I think Brooks' observations have aged particularly well.
Documentation, Communication and Code
Brooks also discusses the importance of documentation and recording decisions. His observation that writing decisions down is essential remains sound.
Documentation doesn't need to be extensive, but important decisions, particularly why they were made, should be recorded. Otherwise, that knowledge can easily disappear as engineers move between teams or leave an organisation.
I was also interested in his description of a program having two audiences. The first is the computer executing it, while the second is the human who needs to understand it.
This remains fundamental to good programming style. Code must be correct, but it must also communicate its purpose clearly to the engineers who will maintain and extend it.
The tools, languages and programming paradigms have changed, but the importance of writing understandable code has not.
No Silver Bullet
Brooks' No Silver Bullet essay, included in later editions of the book, considers why software engineering is so difficult and why no single technological development is likely to deliver an order-of-magnitude improvement in productivity.
He distinguishes between the essential complexity of the problem being solved and the accidental complexity introduced by the tools and techniques used to solve it.
This is an interesting distinction, and one that remains useful.
However, I think the software engineering industry has made considerably more progress than the book sometimes seems to acknowledge.
Modern programming languages, frameworks, cloud infrastructure, automated testing, continuous integration and deployment, and Agile development practices have transformed how software is produced.
Artificial intelligence is now changing things again. AI-assisted development can generate code, tests and documentation, explain unfamiliar systems and help engineers work through problems more quickly.
None of these developments eliminates the need to understand requirements, make architectural decisions or exercise engineering judgement. Nor does AI remove the possibility of introducing defects or unnecessary complexity.
However, taken together, these changes have substantially altered the effort involved in building and maintaining software.
I don't think AI is necessarily the silver bullet Brooks argued didn't exist, but I do think it challenges some of the assumptions about the relationship between effort, productivity and software development that were reasonable when the book was written.
Fifty Years of Progress
My biggest criticism of The Mythical Man-Month is that much of it feels rooted in a world of software engineering that no longer exists.
Brooks was writing from his experience of large software projects at IBM, at a time when development practices, computing resources and organisational structures were very different from those we have today.
Software development is now much more iterative. Agile practices encourage teams to deliver smaller increments, obtain feedback and adapt their approach rather than attempt to plan and build everything in advance.
Modern architectures can make it easier to divide systems into independently developed and deployed components. Automated build and deployment pipelines reduce the effort involved in delivering changes. Testing tools and observability make it easier to identify and investigate problems.
None of this means that modern software engineering is easy, or that the problems Brooks identified have disappeared. Poor communication, unrealistic schedules, unnecessary complexity and badly managed projects remain common.
However, the solutions available to us have changed, and some of the constraints that shaped Brooks's thinking are much less significant than they once were.
I also found parts of the book frustrating to read. Some of the later discussions, particularly No Silver Bullet Refined, seemed to go on for considerably longer than necessary without adding much to the argument.
There were interesting observations about reusable and customisable software, encapsulation, abstract data types and information hiding, but I often felt that the useful ideas were buried in too much explanation.
Is It Still Worth Reading?
I think The Mythical Man-Month is an important book historically, but that doesn't necessarily make it essential reading for every modern software engineer.
There are some excellent ideas here. The second-system effect, the importance of architectural restraint, the relationship between architects and engineers, and the need for clear communication and documentation are all worth understanding.
Brooks's Law is also worth knowing, even if I disagree with treating it as universally applicable.
However, I don't think the book is as relevant today as it was fifty years ago, or even thirty years ago.
Too much has changed in the way we develop software, and too many of its arguments need to be considered in the context of the time in which they were written.
Interestingly, Chapter 18, Propositions of The Mythical Man-Month: True or False?, revisits the book's original arguments twenty years after publication. It may actually be a better starting point for someone interested in understanding Brooks's ideas without reading the entire book.
I'm pleased I've read it, particularly because of its historical importance and the influence it has had on software engineering. However, I wouldn't put it at the top of a reading list for engineers looking to improve the way they design, build and deliver software today.
There is still plenty to learn from Brooks, but I think the most valuable approach is to understand his principles, question his conclusions and consider how much the industry has changed since he wrote them.
After all, if software engineering has genuinely progressed over the last fifty years, we shouldn't expect all the advice from 1975 to remain equally relevant today.
ISBN-13: 978-0201835953
28 October 2026
