An order of magnitude is a bit much. I'd say quick and dirty gets you 3 shots, while slow and beautiful gets you 1. And if you succeed, it means the result is dirty/ugly code that must be maintained forever.

Doing it many times tend to be much cleaner than trying to get it right the first time. So fast -> clean, slow -> ugly code, as long as you use the speed to redo and clean things up.

Except the redo and cleanup part never happens.

The PoC becomes a pilot becomes production becomes an exit becomes someone else’s problem. That’s the SLDC that has gotten us to a place with endless amounts of terrible software everywhere you look.

Though, I’m optimistic that at some point, the software industry will be so saturated, all the products have all the features, and the only place left to differentiate or disrupt will be quality.

That's not how you build big important, expensive things, though. It all depends on the context.

Do you know that the big expensive thing is what your customers actually need? Do you actually know what your customers need?

That’s basically the only important context. If you can’t deliver that, it doesn’t matter how well thought through, extensible, or scalable it is.

Do the customers know what they actually need?

Well if you don’t have a pretty good idea of the problem you’re solving for the customer, you’re much better off trying as many things as you can, quickly and cheaply, to figure out.

It seems that the biggest, most important, and most expensive things are built like that.

Like bridges and skyscrapers?

10 shots facing the wrong direction still gives 10 guaranteed misses. At least make sure which cardinal direction the target is in.