|Keep It Simple, Stupid|
There's two ways to look at this:
1. it's a mistake to reinvent the wheel if a good implementation matches your needs. If it's nearly there, consider adapting it, but don't reinvent.
This approach applies well to those focussed on getting the job done, to the end product. The proffessional job. Sometimes that's the right way to look at things. It's probably the fairest if someone is paying you to do the work (after all starting from scratch will probably take longer).
2. By all means reinvent the wheel. Then you'll see why I did it that way first. You'll make the same mistakes, probably abandon your project and then use my/someone elses existing one.
This approach might actually be the correct one if your main concern is process and understanding. The journey, but not necessarily arriving. Why? Because sometimes when it's not a job it's the learning thats important. In these circumstances, making the mistakes informs you of why other implementations did it that way in the first place. Then you can start afresh understanding more deeply an existing implementations (in terms of both it's strengths and weeknesses). You make an informed decision.
I must have programmed several hacked-up parsers (even after having completed my CS courses on parsers and compilers) before really understanding why the seemingly theoretical approach of my courses could be valuable. Now I know - a hacked together parser is probably not maintainable.
I personally think that a rounded programmer should practice both of these approaches. Probably the wasteful one in his/her spare time, but nontheless blindly applying approach 1. doesn't necessarily deepen your knowledge - which I personally value highly.
How's that for a bit of meditative thinking?