Its clear to me that XP ensures we get it done, naturally.
We all knew we should write tests. The developers knew it. The managers knew it. Even the executives knew it. And still, it rarely happened. We ran out of time, budget, or energy before we got to them. And then agile said, if we simply write the tests first, then we know they'll get written. You can't avoid it. Common sense right? It wasn't for the first 15 years of my career. The beautiful part of this story is that once we started writing the tests first, we found all sorts of pleasant benefits. Better design, humbler coders, and higher productivity. Win. Win. All because we were forced to do what we all knew we should be doing.
Many places "encourage" their developers to have code reviews. It's clear to me that code reviews are not enough. It's very hard to give them the time and energy they require to be somewhat effective. Pair programming enforces continuous, effective code reviews.
At some workplaces, the developers are "encouraged" to discuss problems. Of course, each developer has a completely different task, so finding someone to help is kind of painful. Adopting XP would require us to discuss our issues. It's kind of difficult to pair program without discussing the code at hand. The whole team is required to discuss the ins and outs of the Stories during the iteration meeting. Since we have shared code ownership, we have to learn the why's of our decisions from each other.
Developers are encouraged to have brown bag sessions to share what they know. Think about it. You are encouraged to stop writing production code to create a presentation. So that all developers can stop writing production code to learn, in a rather limited fashion, the information you are spewing at them. As another example, I organized a weekly tech book club. The last three weeks have been cancelled due to production needs.
Instead, pair programming ensures that all developers are continuously learning from each other, organically. While production code is being written. Learning about coding and about design. Learning editor tips and tricks. Learning the appropriate use of patterns (sometimes through abuse). Knowledge rises to the highest common denominator. No extra effort required. It simply happens.
We are encouraged to break our Story our into smaller pieces. We are encouraged to use our time wisely. We are encouraged to stop and re-evaluate if the task is taking longer than we expect. Because our practices do not support either of these steps, these necessary actions only happen when each individual developer's self-discipline makes it happen. All the time. Every time.
XP has evolved to support the human side of the developer. To ensure the stuff that needs to get done, gets done. Even when you're tired. Even when you are stressed. Even when the deadline is looming. It has to get done. It's weaved into the ecosystem.
XP proved that the philosophy "if you must do it, you should do it all the time" was sound. Don't wait until you've made all the decisions before you get some feedback, you can be highly productive with continuous feedback.
Don't encourage your developers to do the right thing, ensure the right things are done through supportive principles and practices.