I think differently. The reason is our intuitive understanding of what it means to 'understand.' To be explicit, purpose and design always depend on scale. And software engineering operates on trust, at least at its foundation. Do you know every implementation detail of the libraries and frameworks you use? If you do, then I have nothing to say.
There are several things I don't understand.
How many people actually understand the internal workings of std::vector or React? Honestly, people use them just fine without knowing. And on the flip side, those who do know sometimes struggle with architecture design. Why? Because of 'cognitive resource limits.'
What I really don't understand is this: if everyone truly understood everything and could connect everything properly, then realistically, LLMs shouldn't have made the discoveries they have. The reason is simple—they're just encyclopedias at their core. But LLMs do make new discoveries, by applying knowledge from one domain to another.
Ultimately, it's a matter of what 'understanding' means and how deep we can go. I think we need to reconsider how we verify knowledge production systems in a society that produces at massive scale.
What I find hard to grasp about your notion of 'understanding' and 'knowing structural constraint failure modes' is this: can you actually list all possible failure conditions? The largest system I've worked on was a Chinese booking service with about 330,000 lines of code. There were so many failure conditions there—starting from external I/O and errors everywhere—that it was impossible to classify them all.
In the end, what matters is the abstraction boundary and failure modes that match the level you're claiming. And I think that's entirely valid. Do you have a counterargument?
I actually think a truly great developer is one who can limit the blast radius when a black box explodes. In that sense, I don't think the idea of knowing a black box empirically is wrong at all.
Not every developer can know everything about compilers, kernels, TLS, database engines, React, libc, or CPU memory models.
What I find difficult about this satire is this:
We're already standing on top of black boxes. We confidently use libraries in our projects, trusting the author's documentation. Is that really 'understanding'? I think it's memorization. We 'memorize' that something works and put it into our project. That's why I don't find it funny as a satire.
Right now, our knowledge transfer systems only operate within the clear cognitive limits of human understanding. But as things get deeper, something that goes beyond those limits will eventually emerge. At that point, can we really define that behavior as wrong?
No matter how detailed a map you have, it's still not the actual terrain. In the process of abstraction, we inevitably lose information. But how can we know exactly how much was lost? And even if we conceptually guess, I wonder if that will still be possible in future eras