One of the advantages of inheritance is that it supports incremental development. You can introduce new code without causing bugs in existing code; in fact, you isolate new bugs inside the new code. By inheriting from an existing, functional class and adding fields and methods (and redefining existing methods), you leave the existing codethat someone else might still be usinguntouched and unbugged. If a bug happens, you know that its in your new code, which is much shorter and easier to read than if you had modified the body of existing code.
Its rather amazing how cleanly the classes are separated. You dont even need the source code for the methods in order to reuse the code. At most, you just import a package. (This is true for both inheritance and composition.)
Its important to realize that program development is an incremental process, just like human learning. You can do as much analysis as you want, but you still wont know all the answers when you set out on a project. Youll have much more successand more immediate feedbackif you start out to grow your project as an organic, evolutionary creature, rather than constructing it all at once like a glass-box skyscraper.
Although inheritance for experimentation can be a useful technique, at some point after things stabilize you need to take a new look at your class hierarchy with an eye to collapsing it into a sensible structure. Remember that underneath it all, inheritance is meant to express a relationship that says: This new class is a type of that old class. Your program should not be concerned with pushing bits around, but instead with creating and manipulating objects of various types to express a model in the terms that come from the problem space.