You make some good point. Howevr, imagine the following not uncommon scenario:
1. A small number of experienced developers starts a project
2. The devs choose to build their own framework for the reasons you describe
3. PM wants ever more features, the project grows, more developers join
4. All new code is build on the framework made in step 2
5. Framework is extended
6. Original devs leave
So now everyone can use the framework, but it's original devs stopped maintaining it. Everyone know how to use the framework, but nobody knows its inner workings well enough - we have a custom, still lightweight framework tailored for the job, but nobody's maintaining it. The worst of both worlds, a framework maintained by people you can't rely on to understand it and fix its bugs, and the initial investment to build it in the first place.
In the end, you're right, there is no clearly defined criteria for which approach is better than the other, both ways has a very good chance to bite you in the ass. My perspective however, not as a developers of production systems but a software testing engineer (writing code to break other people's code
This is hard to prove or disprove. Sure, throwing some huge framework on a small problem is not a sensible approach. Seems like a no-brainer. But where to draw the line? A real life application constantly grows, and has a good chance to eventually use a growing percentage of the features exposed by a given framework. If you know your application will not outgrow its initial specs (in an unexpected way), it might make sense to opt for an own framework.
My personal experience, however, is that developers too often opt for their own solutions, maybe due some kind of not invented here syndrome, and duplicate a lot of work. That is bad in a lot of ways, as a well maintained framework with multiple developers and documented bugs is always preferable to completely new code.
Usually, frameworks are not written and maintained by one person. And thus, you are free to worry about your own code and its bugs, and have others worry about the framework's bugs (within reason, for crucial bugs you will of course need to worry about finding a viable workaround). Code reuse is a good thing, and no single person is smarter than > 1 person.
Also, frameworks do not usually change completely in less than a year, and the change that does happen is gradual - as long as you keep the framework you use up to date the learning curve is flat.
I don't know about that specific case, but from your description it doesn't apply to my argument: Either the car worked and the guy was joyriding, which isn't panicking, just general douchebaggyness, or the car did indeed fail, and the guy killed neither himself nor anyone else, which also isn't panicking.
Generally yes, in most cases the guy operating the "failing" machine is himself the point of failure. But that doesn't mean that's always the case.