A veteran software developer has shared a valuable insight that can revolutionize the way we approach software design. The key takeaway is that the best software is built by keeping as many doors open for as long as possible, resisting the temptation to make premature decisions and locking in implementations too soon.

This counterintuitive approach may seem to go against traditional wisdom, which emphasizes the importance of planning and deciding on every detail before starting a project. However, the developer argues that making decisions early on can lead to solutions driving the implementation, rather than the other way around. This, in turn, can result in systems that are inflexible and difficult to maintain.

The solution lies in focusing on abstractions rather than implementations. By coding against abstractions, developers can defer decisions about specific implementations, keeping their options open for as long as possible. This approach allows for greater flexibility and adaptability, making it easier to change and maintain systems over time.

The developer shares a personal anecdote about the moment they understood dependency injection, highlighting the importance of passing in abstractions rather than creating implementations. This epiphany is closely related to the idea of keeping doors open, as it enables developers to make more informed decisions later in the development process.

In a hypothetical conversation between an engineering director and a development lead, the director might express concern about the lack of decisions on database and authentication solutions. However, the developer argues that this uncertainty is a good thing, as it allows for more flexibility and adaptability down the line.

The benefits of this approach are twofold. Firstly, it enables developers to create systems that are well-abstracted and thus well-designed. Secondly, it helps to mitigate the risks associated with unknown unknowns, which can be a major bogeyman in software development.

While it may seem impractical to avoid making decisions altogether, the developer emphasizes that this approach is not about avoiding decisions, but about making them at the right time, with the right information. By waiting to decide on specific implementations, developers can create systems that are more decoupled, easier to change, and simpler to maintain.

In conclusion, the developer's revelation serves as a valuable reminder that the best software is built on possibilities, not premature decisions. By keeping doors open and focusing on abstractions, developers can create systems that are more flexible, adaptable, and ultimately, more effective.