I think there are three factors that come into play here.
Lack of Critical Mass
First, a pattern is basically little more than giving a name to some code that implements a particular "chunk" of functionality. The only way that name provides much real value is if you can depend on everybody knowing what the name means so just by using the name, they immediately understand quite a lot about the code.
Patterns never established the critical mass they needed to accomplish that though. Rather the opposite, AAMOF. In the 20 (or so) years since the GoF book came out, I'm pretty sure I haven't seen as many as a dozen conversations in which everybody involved really knew enough design patterns for their use to improve communication.
To put it slightly more quaintly: design patterns failed specifically because they failed.
Too Many Patterns
I think the second major factor is that, if anything, they initially named too many patterns. In a fair number of cases, the differences between patterns are sufficiently subtle that it's next to impossible to say with real certainty whether a particular class fits one pattern or another (or maybe both--or perhaps neither).
The intent was that you'd be able to talk about code at a higher level. You'd be able to label a fairly large chunk of code as the implementation of a particular pattern. Simply by using that pre-defined name, everybody listening would usually know as much as they cared about that code, so you could move onto the next thing.
The reality tends to be nearly the opposite. Let's say you're in a meeting and tell them that this particular class is an Facade. Half the people in the meeting either never knew or have long since forgotten exactly what that means. One of them asks you to remind him of the exact difference(s) between a Facade and, say, a Proxy. Oh, and the couple of people who really do know patterns spend the rest of the meeting debating whether this should really be considered a Facade or "just" an Adapter (with that one guy still insisting that it seems like a Proxy to him).
Given that your intent was really just to say: "this code isn't very interesting; let's move on", trying to use the name of a pattern only added distraction, not value.
Lack of Interest
Most design patterns don't really deal with the interesting parts of code. They deal with things like: "how do I create these objects?", and "how do I get this object to talk to that one?" Memorizing pattern names for these (as well as the aforementioned arguments over details and such) is simply putting a lot of energy into things most programmers just don't care very much about.
To put it slightly differently: patterns deal with the things that are the same between lots of programs--but what really makes a program interesting is how it's different from other programs.
Design patterns failed because:
- They failed to achieve critical mass.
- Differentiation between patterns was insufficient to guarantee clarity.
- They mostly dealt with parts of code almost nobody really cared about anyway.