Operating off experiences that one hasn't personally had is sensible and normal. I don't need to be bitten by a snake to know that it's not going to be very pleasant. This style of learning carries over to our professional lives too. Junior Doctors don't need to kill a few patients early on; civil engineers don't need to have their first bridge fall down; and software developers don't need to write tightly coupled balls of mud.
Except we do. A lot.
Outrageously, I don't think there's a burden of proof on me as the author to prove this either. As an industry, we're aware of our short-comings compared to the "real" professionals. We speak at length about this at conferences and in blogs and during coffee breaks.
The experience that motivated me to think about this is a code review with another developer recently on a little piece of kotlin code. I added a FooSerializer interface with a single implementation called CsvFooSerializer. This was called out as too enterprise-y. When I pointed to the "OLD" in "SOLID" being violated in the absence of this interface, I was told that we should give up on things like Dependency Inversion because doing so makes the code simpler.
While this is ostensibly simpler, we're going to discover soon that this isn't the case. We're tightly coupling our system in such a way that we have to hold a huge amount of context in our heads to accomplish anything at all.
I have no words for the sheer arrogance that goes into decisions like this. A lot of very smart people worked for a long time to produce these rules. Why are we petting a poisonous snake in the hopes that something bad won't happen? Let's leverage the knowledge of those that came before! We can point back to how primitive they were way-back-when and delight in the incredible productivity that we now experience as a result.
Now if you'll excuse me, I'm going to try to figure out how to build something called a "wheel". Wish me luck.