"But when the vessel is sinking, you come to me and hoist the sails." — Epictetus, The Discourses, III.2

What do you call a shortcut that takes you to a dead end?

There is always the drive to be better and faster. We take shortcuts in reasoning. Much of the time that works fine (or we would not do it). The problem is that it does not work all the time. Shortcuts are sometimes mistakes. Not until later do we find that out. We end up spending too much time backtracking and debugging.

The software business (and sometimes we, ourselves) very often puts time pressure on us. This causes us to be in a "hard driving" mode. That, in turn, causes us to both make mistakes and use up our time in fixing them. Time pressure goes up further. No time to think? No, we can see through that.

OK, what to do? Be purposefully stupid. Act as if you do not know, that way you cannot keep taking shortcuts. And then? Well, a stupid mistake is caused by doing something stupid. So, ask stupid questions and get to the root.

Of course, you cannot be always doing this, but if you are smart about things, then you will do it at times when it is right.

Do you ever have a good day of coding where everything flows and then wonder: Why can it not be like this every day? Ever spend hours on debugging only to find the root cause to be something incredibly stupid? Why does that happen?

Well, what does that mean: to make a stupid mistake? It means we know enough not to make the mistake at the time we make it and do not use what we know. Why?

It is not because we are bad people! We have only so much mental energy; there are tradeoffs. We often purchase quickness but give up perception. When things are pretty much the same it is a waste of time to redo everything.

But sometimes it does not work out and we make mistakes. It would be nice to avoid those errors, but realistically, they are going to happen. Perhaps instead we can put our efforts into getting better at fixing things.

Let's think about this. Why does it feel like it takes longer than it should to debug things? Because once we have done it, it is not some revelation but rather something obvious and simple and stupid; because we already knew it. We are not getting enough information for the time we put in. Something is wrong.

What is it? Most likely, the same thing that caused the bugs to begin with. That is, being in a hard driving mode, not using our knowledge, not being smart about things. We must look into the code, be cogent, and use what we know.

OK, when is it the case that we must use our knowledge explicitly? When we teach and when we learn. And so, the trick is to be purposefully stupid and teach ourselves to use what we already we know.