When embarking on a new initiative or project within an agile environment, the aim is to progress with minimal blockers, essentially threading the project to its fullest potential. However, one aspect that often gets overlooked in this process is the importance of iterative programming.

The Pitfall of Overplanning

• A common pitfall for many software engineers is attempting to plan the entire project before even making a single brush stroke.
• The issue with this approach is that circumstances frequently change.
• A seemingly insignificant item may unexpectedly become a significant blocker, or the product requirements may evolve based on new insights from the field.

Embracing Iterative Programming

• In light of these realities, iterative programming emerges as a crucial development strategy.
• Throughout the software development life cycle, it's possible to mitigate the need for extensive research spikes to determine suitable technologies, available packages, or other third-party components for inclusion in the application.
• This can be achieved simply by implementing them at the outset, acknowledging the possibility of revisiting them later.

Leveraging Known Solutions

• In my experience, the time saved by integrating a known package or component that can easily be swapped out for alternatives with minimal effort has proven to be invaluable.
• I advocate not forgoing the evaluation of third-party software packages or components altogether, but rather for utilizing time efficiently.

Prioritizing Efficiency

• Finding a package, component, or library that meets your requirements is often not a daunting task.
• Many of these options offer interchangeable alternatives.
• Instead of investing days in exhaustive research, hours in meetings, and additional time documenting the rationale behind each choice, it's often more prudent to rely on intuition after a brief research period and commence implementation promptly.

Striking a Balance

• Similarly, it's often preferable to err on the side of under-architecting rather than over-architecting your software.
• By maintaining a degree of flexibility and keeping your options open for interchangeability to address potential flaws in your code, you effectively maximize your agility.