You can build your systems with as few assumptions as possible. The fewer assumptions you make, the less probable it is that any of your future assumptions will conflict with your previous assumptions. Your code will be built for change.

If your API call to some external system assumes the existence of a particular button in the UI, then your system isn’t built for change. Maybe you want to change this button? Then you need to go through all places in the code that relies on this particular button to see if it doesn’t conflict with any of their assumptions.

As long as loose coupling, and separation of concerns are well tinkered into your application you minimise risks of breaking everything on a restructuring.

If you have for example shared state leaking everywhere into the program, your most probably doomed on the slitest changes.

I am not saying you're wrong, but there are ways to mitigate the risks even without knowing what will happen in the future.

Just saying.

.... Saying what, exactly?

I said that we should

• design for change
• "within reason"
• because we can't know what exact changes are needed.

And you argued... The same thing? Just in the reverse order?

You can design it to be changeable at all, though.

In the simplest case that's just proper abstractions. You can't change details in the rest controller, if the persistence layer absolutely needs to call methods from the rest controller for no reason.

Finding the right balance between YOLO and YAGNI is almost impossible to get right. But you can at least try not to land on the extremes.