One of the most derided kinds of software, especially among seasoned developers, is software that tries to be smart. For example, a menu that reorders itself based on which items you use the most often. At first blush, this seems pretty clever: items you use the most become easier to access, which saves you time. The problem is that now this smart system is unpredictable. Quick, where do you click to open a new file? The answer depends on all the clicks you've made previously, which makes it very difficult to reason about.
Which means it's often preferable to make software dumb. Dumb software is predictable, like a hammer or a chair. Your chair doesn't decide to remove its armrests because you haven't been using them, and your hammer doesn't try to shift its weight to more effectively deliver force from your wrist. If it did that, and you weren't expecting it, chances are you would misjudge your swing and hit yourself instead. Even though it could theoretically be a better hammer by being smart, a dumb hammer is easier to understand, easier to predict, and much, much easier to make.
But I think this celebration of dumbness easily goes too far and becomes limiting. You start to think that a smart tool is necessarily worse than a dumb tool, and if someone made a magic genie that always did what you wanted it would somehow still be less effective than doing it yourself. Yes, it's easier to make a dumb tool than a smart one, and yes, there are way more ways to get it wrong, but that's a fact about the implementation difficulty, not the outcome. A good smart tool is better than a good dumb tool, but a smart tool is much less likely to be good.
This results in what I think of as dumb valley. Like the uncanny valley, dumb valley is a counterintuitive gap where as your tools get smarter, the immediate effect is that they get worse. Only after a lot of painstaking effort do you begin to climb out of dumb valley into a smart tool that actually works properly. If you're not looking far enough ahead, or don't have the resources to get there, the effective but mistaken conclusion is that dumber is always better.
However, as with the uncanny valley, there is a hill on the other side if you keep going. It is difficult but possible to make smart tools that work properly, and there is every reason to think that, if we build them, they can be better, easier and more powerful than the dumb tools we mostly rely on today. Unfortunately, incrementalism won't get us there. It's going to require a long, brave slog through dumb valley.