It is an open secret that programmers like to use static typing like a spell checker. Getting those kinds of error messages from a compiler is rewarding because these errors are easy to fix. Synchronizing variable definitions with variable uses is so common that it can be the core of our workflow.

Static typing is very productive when making small changes with a known design. When facing big changes / a substantial redesign, the static typing: edit – compile – test workflow becomes increasingly less productive. It is disorienting to have to manage old and new types and distracting to manage wrappers. Increasing effort is invested in assuring design stability for an increasingly distant implementation of requirements. The slower prototyping process makes the software less adaptable.

Dynamic typing is a hard sell because its advantage is hard to demonstrate. The maximum advantage of dynamic typing is with the most complicated programming challenges and the use of unstructured programming. The hierarchical structure that static typing imposes on data structures is similar to the hierarchical structure that structured programming imposes on control structures. 

Object Oriented Programming (OOP) is the use of a hybrid type system. OOP uses static typing to form a hierarchy / tree, but allows dynamic typing at the leaves. This change adds flexibility while eliminating run-time type errors.[1] A problem with this solution is that the competition between static and dynamic typing shows up in the organizational structure. The more flexibility we need, the more we must implement as subtypes. 

I think that user defined types were initially invented for static typed languages because of the brittleness of static typing. Adapting user defined types for dynamically typed languages has been less successful because user defined types serve a different purpose for dynamically typed languages. Types restrict the flexibility of dynamic typing. Modularity is useful where there is a transition of responsibility (implementation vs use). 

(see dontuse)

1 Inherited classes are same as far as the static typing goes, so they are differentiated by dynamic type checks. While dynamic typing can result in run-time mismatch, the static typing of OOP guarantees that (dynamic) dispatching is restricted to sub-types.