I'll attempt to provide a reasonable argument for why speed of delivery is the most important thing in software development. I'll concede that I don't know if the below is true, and haven't conducted formal experiments, and have no real-world data to back up the claims, nor even define all the terms in the argument beyond generally accepted terminology. The premise of the argument therefore may be incorrect.

Trivial software is software for which

- the value of which the software solution is widely accepted and widely known in practice and

- formal verification exists and is possible to automate or

- only has a single satisfying possible implementation.

Most software is non-trivial.

There will always be:

- bugs in implementation

- missed requirements

- leaky abstractions

- incorrect features with no user or business value

- problems with integration

- problems with performance

- security problems

- complexity problems

- maintenance problems

in any non-trivial software no matter how "good" the engineer producing the code is or how "good" the code is.

These problems are surfaced and reduced to lie within acceptable operational tolerances via iterative development. It doesn't matter how formal our specifications are or how rigorous our verification procedures are if they are validated against an incorrect model of the problem we are attempting to solve with the software we write.

These problems can only be discovered through iterative acceptance testing, experimentation, and active use, maintenance, and constructive feedback on the quality of the software we write.

This means that the overall quality of any non-trivial software is dominated by the total number of quality feedback loops executed during its lifetime. The number of feedback loops during the software's lifetime are bound by the time it takes to complete a single synchchronous feedback loop. Multiple feedback loops may be executed in parallel, but Amdahl's law holds for overall delivery.

Therefore, time to delivery is the dominant factor to consider in order to produce valuable software products.

Your slower to produce, higher quality code puts a boundary on the duration of a single feedback loop iteration. The code you produce can perfectly solve the problem as you understand it within an iteration, but cannot guarantee that your understanding of the problem is not wrong. In that sense, many lower quality iterations produces better software quality as the number of iterations approaches infinity.