Ready – Book Review
Ready: Why Most Software Projects Fail and How to Fix It by Luniel de Beer and Max Guernsey, III
A Tale of Two Ambitions
‘Ready’ presents itself as a solution to software project delivery struggles, and it delivers precisely that—masterful process engineering that may however be optimising the wrong thing.
The authors’ central thesis—that premature implementation causes most software development waste—leads to Requirements Maturation Flow (RMF), a three-part framework creating explicit gates around implementation readiness. Think Design by Contract for work items rather than code methods: preconditions (Definition of Ready), postconditions (Definition of Done), and invariants (responsibility rules).
What RMF Actually Delivers
The book’s opening case study at ‘The Bank’ is compelling: teams transforming from delivering nothing to shipping working software after adopting systematic readiness practices. The detailed progression from chaos to flow is vividly illustrated with workflow diagrams and specific examples.
RMF creates mechanisms for:
- Explicit collaboration before implementation starts
- Documented shared understanding via bespoke Definitions of Done and Ready
- Workflow gates that prevent premature starts and closures
- Visible tracking of readiness work
- Contract-like responsibility transfers between Product and Engineering
The practical guidance is outstanding—detailed templates, adoption strategies, common objections with responses, and integration patterns for Scrum/Kanban make implementation genuinely feasible.
The ‘Software Last’ Context
When viewed through Seddon’s ‘Software Last’ principle—understand the work first, then design solutions to support that work—RMF operates at a specific layer of the problem stack.
RMF doesn’t address whether teams should build what they’re asked to build—it focuses entirely on the handoff: ‘Given that we’ve decided to build X, let’s make sure we build X correctly.’ Questions about whether X is the right solution are explicitly outside the book’s scope.
The authors acknowledge this limitation directly: ‘The techniques in this book don’t tell you what to build, why to build it, or how to find out whether it’s the right thing to build.’ This honest scope disclaimer might help reduce false expectations.
The Bank example illustrates this perfectly. After RMF, they successfully built a loan repayment portal that satisfied all stakeholders. But the book never asks: Did customers actually need a portal? What work were customers trying to accomplish, and what prevented them from doing it well? RMF enhances confidence in execution without addressing purpose.
The Gall Warning: When Solutions Become Systems
Gall’s Systemantics provides a devastating critique of RMF’s approach. His principles predict exactly how this kind of designed system will behave in practice.
‘A Complex System Designed from Scratch Never Works’: RMF is precisely what Gall warned against—an elaborate, architected solution with three interconnected habits, multiple behaviours, templates, gates, and responsibility transfers. The book presents this as a complete framework without showing how simpler practices might work first.
‘Systems Tend to Oppose Their Own Proper Function’: RMF aims to help teams build the right things correctly, but Gall would predict it will oppose itself. Teams may become obsessed with satisfying DoD/DoR criteria rather than delivering value. Readiness work becomes an end in itself. Process compliance replaces judgement—’The DoR is satisfied, so we must start’ even when common sense says wait.
‘The System Always Kicks Back’: Gall would predict RMF creates new problems it wasn’t designed to solve. Teams learn to game DoDs that are easy to satisfy rather than meaningful. Collaboration meetings consume increasing time. Elaborate DoRs give an illusion of control whilst missing real sources of uncertainty.
‘Systems Serve Themselves’: Most damning—who benefits most from RMF? Process consultants, teams that prefer meetings to building, and managers who want visible ‘readiness progress.’ Meanwhile, customers waiting for working software see longer delays as teams perfect their readiness processes.
The Upstream Questions (Deliberately Out of Scope)
RMF creates elaborate processes to ensure teams build exactly what Product Management requests. The framework’s collaboration meetings are structured around ‘How do we build X correctly?’ rather than ‘Should we build X at all?’
This is by design—the authors explicitly position RMF as addressing execution mechanics, not strategic direction or stakeholder identification. Questions about whether Product Management is listening to the right people or solving the right problems are upstream challenges that RMF doesn’t claim to adress or solve.
The Ethical Question (Also Out of Scope)
This raises an interesting question: Do development teams have a professional responsibility to question whether they’re building the right things for the right reasons? RMF’s focus on execution efficacy doesn’t address this question—and the authors don’t claim it should.
However, it’s worth noting that teams focused intensely on execution mechanics without corresponding frameworks for questioning purpose might inadvertently become more efficient at building things nobody needs. This isn’t a flaw in RMF per se, but rather a reminder that execution excellence requires complementary disciplines around strategy and purpose.
What Works Within Its Scope
Despite these caveats, RMF offers genuine value for teams suffering from implementation chaos:
- Framework agnostic: Enhances existing methodologies rather than replacing them
- Incremental adoption: Start with RMF 1, see benefits, then expand
- Practical mechanics: Detailed templates and guidance make implementation feasible
- Process discipline: Contract-like nature of DoD/DoR creates healthy constraints
- Collaboration structure: Systematic approach to shared understanding addresses real coordination problems
- Honest positioning: The authors clearly state what the book doesn’t solve
The Real Innovation
RMF’s core insight is bringing the rigour of Design by Contract to human collaboration and work handoffs. Instead of code method contracts, teams get collaboratively negotiated work item contracts with clear preconditions, postconditions, and responsibility transfers.
This is genuinely sophisticated process engineering. The problem is the assumption that better process engineering addresses root causes of software project struggles—though the authors are now explicit that this isn’t their claim.
Who Should Read This
Definitely read if:
- Your teams struggle with constant rework and implementation chaos
- Requirements frequently change mid-implementation
- ‘Almost done’ work items plague your sprints
- You want systematic approaches to collaboration and handoffs
Read with caution if:
- Your organisation tends toward process bureaucracy
- You suspect you’re building wrong things (regardless of execution quality)
Don’t read if:
- You need help identifying what to build or for whom
- Your problems are primarily market timing, funding, or strategic direction
Verdict
‘Ready’ succeeds brilliantly at what it explicitly attempts—providing systematic relief for teams drowning in implementation chaos. The framework offers concrete mechanisms where many teams have only informal practices. The authors’ honest acknowledgement of scope limitations prevents false expectations about strategic guidance.
However, readers should watch for Gall’s predicted pathologies: RMF serving itself rather than its purpose, readiness work expanding beyond necessity, and process compliance replacing judgement about value creation.
The book positions RMF appropriately within the larger Synapse Framework, acknowledging it doesn’t replace product strategy or vision work. This contextual honesty significantly strengthens the overall package.
Bottom line: If your problem is delivery mechanics, this will likely help—and the authors are clear about what problems it doesn’t solve. The combination of sophisticated process engineering and honest scope positioning makes this a valuable resource for teams struggling with implementation chaos.
Teams struggling with implementation chaos will find systematic, practical relief. The book is explicit about not solving upstream strategy or vision problems—which makes it trustworthy rather than overselling its scope.
‘Ready: Why Most Software Projects Fail and How to Fix It’ is available at https://leanpub.com/ready
Further Reading
De Beer, L., & Guernsey, M., III. (2025). Ready: Why most software projects fail and how to fix it. Leanpub.
Gall, J. (2003). The systems bible: The beginner’s guide to systems large and small (3rd ed.). General Systemantics Press.
Jones, C. (1994). Assessment and control of software risks. Prentice Hall.
Meyer, B. (1997). Object-oriented software construction (2nd ed.). Prentice Hall.
Project Management Institute. (2021). A guide to the project management body of knowledge (PMBOK guide) (7th ed.). Project Management Institute.
Reinertsen, D. G. (2009). The principles of product development flow: Second generation lean product development. Celeritas Publishing.
Seddon, J. (2003). Freedom from command and control: A better way to make the work work. Vanguard Press.
Sutherland, J., & Schwaber, K. (2020). The Scrum guide: The definitive guide to Scrum (2020 ed.). Scrum.org.


