Wow, that seems quite patronising on the face of it, are they interacting in this way to get you to keep your distance?
> "shaking the tree" with every code commit
Out of interest what do you mean?
"Shaking the tree" in this context means re-building the entire inheritence model when a new object is added to the tree. Any time the new object is not a leaf node, or it requires behavior from two non-direct ancestors, the inheritance tree must be "shaken" to re-order the inheritance such that the new node gets the behaviors as its ancestors, while avoiding things like diamond inheritance.
The (overly simplistic) example is placing the platypus in the inheritance tree to account for its characteristics in common with two otherwise distinct parent classes (birds/reptiles & mammals).
I suspect they mean that changes which one might expect to be small and well-contained end up requiring touching your class (to add a parameter), your superclass, your superclass's superclass, and then all of the tests that depend on the superclass being a certain shape.
I know I've encountered this, in several projects, so I'm not sure if it's a product of poor design (possible, I wrote some of them! ;)), or merely a side effect of a complex system. I know that lately with React, I've been having similar issues when composing things (and adding new features), so that I can pass callbacks far enough down, so it's definitely not solely related to inheritance.
There's nothing technically wrong with them, and so long as you have the time to add new behaviors at the correct level and re-order the hierarchy accordingly, everything goes swimmingly. The problems arise when deadlines loom and you don't have time to identify the proper location in the hierarchy for a behavior (let alone code it), or when new members of the team don't have the knowledge of the code base to identify the proper location, or when the codebase gets too large for any single person to know where the "best" place is for something to exist...
It boils down to a human problem. And since all of our developers are humans...
"Shaking the tree" i.e. commits in the middle of the hierarchy will make long and broad affects in the codebase.
The actual quote was '... let me know how that goes.' That is not the positive statement that you're trying to spin it as. It is dismissive and condescending.
On the other hand, if you did but they were unable to understand or unwilling to listen, then I cannot fault you.
I hate to say it, but this kind of direction is also pushed frequently by inexperienced developers. It is also frequently made worse when they feel they have to prove their ability to developers with more experience.
Just the other night I was having a conversation with colleagues from a side project - one is the CTO (he made the position a stipulation of employment when the founder was starting this side project), the other the founder, and I was trying to convince them both why deep inheritance and "shaking the tree" with every code commit creates code maintenance problems down the road.
Unfortunately, the inheritance model was the CTO's design (after all, the data has very strict hierarchical relations, right?), and the only real answer I got to justify his plan was "so there's nothing technically wrong with it, your objection is purely fear based; keep tabs on that fear and let me know how it goes". I was concurrently scolded by the founder that "I'll never make deadlines, so you'll always have plenty of time to refactor the codebase". Needless to say, they decided that it was best for the development group to go forward with the deep inheritance hierarchy.
So yeah, the lack of experience definitely inhibits communication, particularly when you disagree with them based on your experience.