1. Nobody applies rigor to anything complicated anymore. The only way you can produce anything that works without rigor is to only produce very small things that you can prove work. So you can produce a lot of very small work and say "I'm developing so fast!", and meanwhile all the components connected together can be a tire fire. Short-term wins and long-term pain. This applies to a lot of the Agile process, but also the avoidance of processes and tools. Processes and tools can help or hurt, depending on how you use them. Even Agile is a process.
2. Working "software" is completely meaningless. What is actually valuable is a working solution to a user problem. I can make a program that very reliably spins in a loop forever, doing nothing. Who the fuck wants that? Not a user. And a large system, which is what a lot of software today is written for, cannot be connected together, operated, troubleshooted, etc without documentation. Nobody's going to be able to run your software or fix it when it breaks if they have no documentation, because they didn't write your software, so they have no fucking idea what to do with it. So we end up with a lot of unmaintainable widgets that don't solve user problems.
3. No software developer actually collaborates with a customer, because software developers have never cared about a customer. They care about their precious code, their algorithms, their design, their bugs, their tests. They don't care if the customer hates the software. I have literally never heard a developer utter the words "so how does the customer like the software?" This whole rule of customer collaboration is just an excuse not to have to think about a contract.
4. 'Responding to change' pretty much just means 'push out shit software and wait for bug reports'. For the first year of operation, Agile software is garbage. Because there was no coherent plan, it doesn't work for the customer, it isn't maintainable, and the other parts of a complex system that it operates as a part of will constantly break in weird ways. We don't need to make a plan, so we don't need to figure out how this thing is supposed to work, so in 6 months when we finally get around to a customer use case, we'll realize this architecture never would have worked within the constraints they're running it in.
Software development is not 'too damn complex'. Software developers are just lazy. We know that, because developers brag about being lazy all the time (I do too). They have these huge egos, and they believe that they're intelligent or talented because they can design an efficient algorithm or create 'beautiful code'. But the end result of all that code is what matters, not the code itself.
Agile is simply a 180-degree reaction to decades of work in developing processes that result in reliable solutions. The processes got complicated, so the software developers said, "fuck it, i'm just going to wing it". And as a result, most modern software is less reliable and more complicated than decades-old systems that are both simpler and solve more problems.