Plans are useless, planning is fundamental
Dwight D. Eisenhower, reflecting on military strategy, famously said: Plans are useless, but planning is indispensable. This idea is incredibly relevant to Software Development.
Hello, developers! 🚀
Welcome back to the Learn Agile Practices newsletter, your weekly dose of insights to power up your software development journey through Agile Technical Practices and Methodologies!
Before starting, I quickly remind you that my brand new Test-Driven Development 101 5-day Email Course is available: it is the introduction to TDD I wish I had when I started learning it, so I think you will find it very useful!
As a subscriber to my newsletter, you can have it with a 10EUR discount! 👇
Now, let's dive into today's micro-topic!
In short
💡 Rigid plans are often a recipe for failure in software development, as they assume all information is known upfront. Instead, planning should be an ongoing, flexible process.
🛠️ Sticking to a fixed plan can lead to wasted effort, outdated solutions, and missed opportunities for improvement. As systems evolve, so should the plan.
🔄 Effective planning enables learning and adaptation. It helps teams align, deal with complexities, and refine their approach continuously, making it indispensable in delivering value.
Focus on planning, not plans
In Software Development, sticking to a fixed plan is proven to be a recipe for failure. Dwight D. Eisenhower, reflecting on military strategy, famously said:
Plans are useless, but planning is indispensable.
This idea is incredibly relevant to Software Development.
The problem with fixed, rigid plans is that they assume we know everything upfront. But in software, we rarely do. In fact, software development is full of unknowns—from changing customer needs to evolving technologies and unforeseen complexities that we will learn during the process. The moment we begin developing, reality often reveals that our assumptions were off or incomplete.
Software Development is a learning process: every piece of behavior we provide to the users we get more feedback to understand some more about users real needs and how well our solution is solving those needs. This means that the expectation of knowing everything upfront is totally misplaced.
A detailed plan that doesn't evolve with new information sets us up for failure. As Taiichi Ohno, the creator of the Toyota Production System, said:
If a business sticks to the idea that a plan should not be changed, it will fail soon.
The world is dynamic, and software development is even more so, therefore we should approach planning in a more sustainable and effective way.
The Danger of a Fixed Plan
At the beginning of a project, especially for large, complex systems, there’s a natural inclination to define everything upfront: it feels safe to create a detailed roadmap, meticulously laying out every task, milestone, and deadline.
However, this illusion of certainty will actually increase risks, for multiple reasons:
Customer Needs Change
If we're locked into a plan, we risk delivering something obsolete by the time it reaches the user. Most of times, customers may not even be able to articulate their real needs, but they will also improve on this as the product evolves and they see early iterations.Unforeseen Technical Challenges
No matter how skilled your development team is, complex systems often bring surprises. A rigid plan doesn’t account for the unexpected and may pressure the team to rush through these problems without solving them properly.Lost Adaptability
A fixed plan can make teams feel obligated to follow it, even when it no longer makes sense. Instead of searching opportunities for improvement or responding to new discoveries, teams may feel tied to the original roadmap—resulting in wasted effort on features that add little to no value.
In the worst-case scenario, sticking to a fixed plan means we deliver a product that nobody wants. The market may have shifted, customer preferences changed, or we might simply realize too late that our solution isn’t good enough.
Why Planning is Indispensable
What’s actually valuable is the act of planning. Planning forces us to think critically, consider different options, and identify risks early on. But more importantly, it helps build shared understanding across the team and stakeholders. It allows us to align on the general direction, and identify critical dependencies and architectural considerations.
We shouldn’t think to planning as a one-time event, but a continuous process. We plan iteratively, using short feedback loops to refine our solution as new information becomes available. Flexibility is built into the process, allowing teams to respond to change and course-correct when necessary.
Here’s why planning is so powerful:
Learning as You Go
In software development, the first draft of anything is almost always wrong: let’s embrace this fact and treat every piece of work as an experiment. We plan and execute in small increments, getting feedback and adapting as we learn more. This way, we’re not committing to the wrong direction for too long.Dealing with Complexity
Planning gives us a high-level architectural vision and guides the team on where to start. It sets the groundwork for big-picture decisions, such as choosing technologies or defining key interfaces. Over time, anyway, we should replace detailed plans with constant refinement, ensuring we’re never stuck with decisions that don’t scale or adapt to new knowledge.Adaptation Over Commitment
Instead of focusing on rigidly following a plan, we focus on delivering value in short iterations. Each increment of work is an opportunity to validate assumptions, get real feedback from stakeholders, and adjust the next steps accordingly.
One of the biggest misconceptions is that planning means commitment: we should not treat plans as promises, but more as a high-level map. The more we learn, the more the plan will evolve.
Software Development is a learning process, and the real value of planning lies in the way it helps to express that learning over time.
Until next time, happy coding! 🤓👩💻👨💻