My experience is that static typing tends to lead to higher coupling and monolithic design, while you tend to break things up more aggressively in a dynamic language like Clojure.
I understand what you mean, and it's definitely a trade off.
Static typing requires all types to make sense together no matter how small the addition is.
In dynamic typing, we can just add a class/object/field here and there because it'll only be used narrowly anyway. So, it's often fine.
This would be great if we can think of a small example to illustrate this trade off.
One example I can think of is how Ring middleware works. The request map is passed through a series of functions, and each one can modify it in its own way. For example, you could have an authentication library that adds an :identity key, and another that adds a :session key. These libraries can work together without having to know anything about each other.
Dynamic typing is punitive if we make mistake (e.g. using the wrong architecture, now we have to refactor), and we'll make mistakes.
Writing perfect code with perfect architecture and perfect test has been the argument "for" dynamic typing, but I don't think that's a realistic assumption.