One of the Extreme Programming practices is to Refactor Mercilessly. When you find two methods that look the same, you refactor the code to combine them. When you find two objects with common functionality, you refactor to make there be just one. Extreme projects do not use Big Design Up Front. Therefore they upgrade their designs continuously. Relentless Testing and Continuous Integration permit changes that would introduce the risk of bugs in slower projects.
And you change all the users of the old capability to use the new. In Smalltalk, that's particularly easy to do, because you can open a browser on all the senders of the old one and edit them to the new. There may be Code Ownership issues, of course.
Since we have extensive Unit Tests and Functional Tests, we can always refactor with the confidence that we haven't broken anything.
The result of these practices is that the system does not get held hostage by some old, hide-bound, ill-conceived idea from the past. It remains fresh and new, productive and fun to work with.
Since we Do The Simplest Thing That Could Possibly Work, sometimes what we do needs improvement an iteration or so down the line. We welcome these opportunities to make the system more like what it should be, and we welcome the fact that we do it in solid knowledge of what is really needed, not what we imagined in the past was needed.
The result of this is that the system is always as simple as we can make it, which means we can understand it better, which means we can change it more rapidly while keeping it reliable.