alt Hacker News> Wouldn't it be fair to think of AI as just another search ability?
If you're asking it questions, yes. It's like search but with a simulation of understanding and information synthesis far faster than a human can perform it.
If you're having it write your code, no. It's like a junior developer who has no awareness of the bigger picture, of incompatibilities, of understanding that hasn't been contained and can't be derived from the codebase.
> If you can just search with GPT and tell the difference, wouldn't that be enough?
The situation the satire is describing is an individual who is unable to tell the difference. The way the scenario is laid out, everything she's 'accomplished' has been to prompt ChatGPT and publish its answers with some degree of editing; it's clear that she, as an individual, is not an expert, does not understand the thing she is presenting, and does not know any of what she has purported to know. This is also a sadly common refrain these days.
> I can't imagine memorizing thousands or tens of thousands of lines.
It's not about memorizing thousands of lines of text; it's about demonstrating to the panel that you have an understanding of the thing you're claiming to have an understanding of.
I work with a lot of software and infrastructure at work. I can tell you how it all (or most of it) works together and interacts. I could not reproduce the configurations of any of the software from memory, nor recite any of the code, but I have an understanding of the system, how it works, what it was designed for, and what choices were made and why.
The professor in this article does not have any of that understanding. It would be as if I had Claude deploy a cluster of X, Y, Z components, configure them, and get them online, and then put on my resume that I had done it. It was accomplished as result of me, but if I don't understand the system then there's no difference between me doing it and the CEO doing it, or my son, or someone from Taskrabbit.
So yeah, it's not about memorization, it's about understanding.
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