Every mistake that you’ve made in software development was already a well-known mistake before you made it. Every mistake you’ve made in the past that continues impeding your ability to make progress at the pace you’d expected was known at the time you made it.

Every mistake you’re making right now is already a well-known mistake. You just have to learn to sharpen up your mental lens to see these mistakes before you make them, and avoid them.

You don’t have to personally experience every class of mistake to finally become attuned to them. You can know them merely by their fingerprints. You can know them through the fundamental design principles and design qualities that define software development.

But principles and qualities are subtle things. They’re subtle knowledge. You have to have a more fine-tuned sense of software to see them. But that doesn’t mean you have to wait years or decades to get that fine tuned sense. You can just acclimate yourself to them on purpose. And that will kick start the emergence of a finer sensibility of the subtle end of the knowledge spectrum.

Subtle knowledge — or knowledge of subtle things — is the most powerful knowledge you can be equipped with. It means the difference between making mistakes that you’ll regret, and that compound the complications of the other mistakes that you regret, and always moving forward without having to deal constantly with the setbacks that issue from those mistakes.

The challenge is that subtle knowledge isn’t easily-accessible through a lens that works at the magnification level where mostly the crude knowledge is found. And because of this, it’s common to reject the effects of subtle knowledge on the work. And it’s possible from this perspective to dismiss this power reflexively because it isn’t yet within view or within reach.

To the unpracticed eye, the subtleties are invisible. But they remain the foundation of everything. A cancer cell is invisible to the naked eye, but it’s impacts are undeniable. So too are the particles that act as countermeasures to it. When you’re working at the cellular or atomic level, you can have profound effect on the level of the organ or the organism. And the most pervasive, all-encompassing impact you can have on your software work are at that level.

Nonetheless, no amount of rejection of the very existence of subtle knowledge can obviate its object existence and its impacts. Knowledge of the subtle is power. It’s at that level of fine-tuning and super-fine tuning that the cancer that characterizes so much software is avoided. Developers don’t make mistakes because they want to. Developers make mistakes because their design sensing devices aren’t yet tuned to the most powerful level of conceiving of design.

Everyone starts at the beginning. And the beginning is the crude. At the beginning, just getting some code to work is a victory. Over time, it just fades into the background and becomes a given as we acquire an ever greater inventory of tools, and more experience with them.

Tools are on the crude end of the spectrum. Sooner or later we learn a thing or two about patterns. Patterns are a bit more subtle than tools, but patterns as well are crude.

Patterns and tools don’t tell us when we should use them and when to avoid using them. It’s design principles and design qualities that give us these signals.

Principles and qualities are on the other side of the spectrum: they’re subtle. In the beginning, while enjoying the victory of getting software to work at all, we may pay no attention to principles and qualities. Nonetheless, they’re still in-effect, and they’re still dictating the terms of whether we’ll regret how we’re using those more crude things.

Every developer can code. Every developer can use tools. Not every developer can see mistakes before they’re made. But every developer can become acclimated to the subtle knowledge that illuminates mistakes before they’re made–even if these things are presently invisible in the present. Design principles are subtle. Design qualities are even more subtle. Yet they are the most powerful things you can know and leverage. And they’re the difference between the enthusiasm you feel at the beginning of some work, and the enduring regret you have later.

The subtle knowledge is the ever present early warning system that keeps you from having to experience your work through the lens of eventual regret. You just have to practice seeing it, and making it a tangible part of every line of code you conceive of.