Sometimes someone has a great idea that solves a problem. But as time passes, people forget why it was a great idea and try to use it in ways that end up causing problems as bad (or worse) than what the idea was originally supposed to solve.
Example:
I'm sure that distributed source control is sufficiently counterintuitive that people try to establish conventions that defeat the point of distributed source control.
Example 2:
it's very natural to think that when you're writing some code, you should handle all errors that could possibly arrise. But a function doesn't always have enough information to handle the error properly, so all it can do is somehow tell whoever called it that the error occured. Passing errors up the call stack by hand is tedious, so exceptions were invented. With no extra typing on the part of the programmer, exceptions will bubble up the call stack until somebody can do something with them. It seems like checked exceptions, at least in practice, tarnish the awesomeness of exceptions. At best, the programmer has to tediously work her way up any possible call stack, specifying that every method throws a given exception up to the point where it can be handled (if it can be handled). Worse, she might swallow the exception to avoid the chore!
What are some other examples where an approach that seems like the common-sense thing to do is actually recreating a problem that had been solved in some way?
Point of this question: internalizing what is wrong with the common-sense "obvious" solution is a very good way of developing an intuition for how and why to use the initially counterintuitive elegant solution.