IMHO, the idea of patterns addresses two things: 1 - attacking the "haystack/spaghetti" that most large systems tended to result in, by providing a vocabulary or standard set of metaphors that can be used to encourage rather than discourage some good practices; and 2 - provide a common meta-vocabulary for discussing design (sometimes those "discussions" are between a long gone programmer and someone that encounters the code later).
Of course what we got instead was fetishism and towers of factory classes emitting envelopes resulting code that was diffuse, incomprehensible, and that focused on things other than the actual problem at hand. Despite my theoretical sympathies I stay far far away from the GoF.
This reminds me of the Agile movement: not that bad an idea for a technical management consulting team trying to solve a customer's tactical problem. But outside that domain only some bits and pieces make sense, and, depending on the domain, not always the same bits and pieces. Again: fetishism took over.
Yeah... "once they know," which is after their time and effort has been spent and the opportunity cost has been incurred. Investing time and effort in learning something is, indeed, an effective way of finding out if the investment is worth it, but since you find out after the fact, it can't inform the decision to make the investment or not.
Also, somebody who was hired for their knowledge of one paradigm and is currently working productively in it, as is frequently the case, does not need "cover" for not knowing a different paradigm.
Most people won't remember, but there was a time in the 1990s when there were a lot of professional programmers who were not comfortable with OO. In a codebase, you'd get fights between people who embraced classes and utilized dynamic dispatch and people who didn't see the point of those things and were able to be extremely productive without them. Now there are a ton of professional programmers who are not comfortable with FP, coexisting in the profession with programmers who have fallen in love with type classes and use them habitually to solve every problem. It's a massively unjust cop-out to tell the former that they need to "reject purity," as if it's a moral flaw they need to fix. It's a long process of learning new skills and concepts, during which they will not be performing as accustomed at their job. People who balk at that are not just narrow-minded. People who focus on present productivity rather than future productivity are often the people who are getting the most work done, and it's important for an organization to figure out a path forward for the entire team before letting a new paradigm loose in the codebase. Moreover, it's legitimate to ask if the short-term consequences will be balanced out by long-term gains.
Also, as a response to the article trying to mix design patterns into the argument, if people want to make design patterns a thing, the idea needs a complete relaunch. Convince me that they're worth the effort. In my twenty years of experience working with other programmers, programmers who know design patterns are not better programmers than those who don't. I don't feel any less capable having 99% forgotten them. Most importantly, younger programmers who never bothered with them are just as good at structuring code as those of us who worked through the GoF book during our formative years. My opinion: just let it go.