The important thing is not to worry that what we have is merely good, because the perfect might be waiting around the corner. It's not.
The other "standing on the shoulders of giants" is used as justification for accumulating more and more dependencies and not writing stuff oneself, no matter how simple, which is how we get into left-pad-like territory.
We should indeed focus on reusing libraries, but please, _good_ libraries and not ones, which impose limitations in implementation as well as future thinking, by creating a high mental barrier to change ("But if we switch out this library we need to change aaalll this stuff, because our code is adapted to how the library works."). Sometimes adding a dependency is simply not worth it, like in the left-pad scenario. Just write that one function yourself and don't add more dependencies to the project. Always weigh the benefit against the additional load of dependencies added directly or indirectly as dependencies of dependencies.
But should I really start writing a graph algorithm for the 15th time? I believe the point of the quote is not “blindly add dependencies”, but that a significant boost in productivity can come from reusing already existing, high quality code that fits in with the projects requirements. Left-pad is clearly not such for most projects, and “it is not a free lunch” (:D) in that maintaining dependencies also has a cost.
His argument is developers use a lot of time on the intrinsic complexity of designing solutions for complex problems. Representing these solutions in code is a smaller part of the job. So even if a new language increased coding productivity by 10x (like going from assembler to C might) it wouldn't increase overall productivity with the same factor.
In short, the bottleneck is not the coding, the bottleneck is our minds thinking about how to solve the problem.
But it does also mention that since the appearance of high level languages, we are on a path of diminishing returns:
“The most a high-level language can do is to furnish all the constructs the programmer imagines in the abstract program. To be sure, the level of our sophistication in thinking about data structures, data types, and operations is steadily rising, but at an ever-decreasing rate. And language development approaches closer and closer to the sophistication of users. Moreover, at some point the elaboration of a high-level language becomes a burden that increases, not reduces, the intellectual task of the user who rarely uses the esoteric constructs.”
Also, Brooks originally wrote this paper for a 10 years timeline, and my point was mostly that even though we are like 3 times over its original length, I still don’t think languages would be even 3 times more productive, let alone more (and I won’t buy empirical evidence of your fav language, but some form of objective one).