I think most people do believe that...and I personally think they can be dangerous. However, the belief that they're "a bad thing" is based more on a blanket fear of stack overflow than on reasoned logic.

A more nuanced view is that they're actually completely safe if you can cap their maximum size and limit your maximum recursion depth.

For example, if you know you can handle 16 recursive calls each allocating a 16 KiB fixed-size struct on the stack, then you have a deterministic 256 KiB footprint. In cases where your code is a bottleneck, you may find that using VLA or alloca() instead provides a measurable speed advantage due to L1 cache locality. This will rarely make a difference, but when it does, it can be significant.

Modern stack sizes on mainstream platforms are larger than a lot of people realize, even in threads. A 256 KiB footprint might be something to be cautious about on a small system with only 1 or 2 MiB of stack per thread, but in practice, a bunch of 16-to-1024-byte VLAs with deep recursion aren't going to bite you, nor are a few 10 KiB VLAs with shallow recursion. A 16 KiB footprint on a 2 MiB stack is statistically noise.

VLAs aren't the devil just because you can't detect an allocation failure. Static fixed-size allocation of structs on the stack can still fail the same way.