Many people in tech love to talk about going "all-in".
They hope to end the battle in one shot.
I personally feel that teams that casually talk about going all-in have significant issues.
Going all-in can sometimes be a form of laziness.
If you have contemplated things thoroughly and decided it is the right way to go, or more importantly, if the market sends you signals and pulls you to go all in, then by all means.
But in many cases, it's more like "I'm tired of thinking about it anymore, so let's just do it and hope things will work out."
Another way of taking shortcuts is over-abstracting things and excessively pursuing frameworks. I myself often fall that this one.
Frameworks are not as useful as they seem.
In many cases, when you abstract a phenomenon into a framework, you are applying leverage to your thinking. If this leverage is applied incorrectly, even a small error can lead to huge mistakes.
However, because frameworks can only be abstracted when there are enough instances occurring, attempting to do so at an early stage can be dangerous. Since much of it is unstructured and sporadic, overusing frameworks doesn't help your understanding of the truth.
Avoiding excessive abstraction and overuse of frameworks will also help maintain a balanced mindset.
If you're building cars, the abstraction is a car factory, but this depends on knowing that your domain can be abstracted to cars. If your domain is instead vehicles and you later need an airplane, your car factory was the wrong abstraction.
Abstractions are powerful tools in software, and they're mostly under-utilized because businesses largely do not understand them, and they tend to select engineers that would rather not abstract and instead duplicate code and logic all over the place. The main idea behind abstracting is leveraging the power of software to call an existing function. If you keep building on this "tower" correctly (albeit hard to do and requires specialization), you reap huge rewards by automating large parts of the pipeline.
And then that allows me to course-correct based on external events when need be.
So I completely agree: Being overly dependent on one framework leads to complacency, stagnation, plateau, etc.