The post says the important loss in the AI era is not raw competence but acquaintance. Earlier personal computing forced users into config files, drivers, memory limits, boot disks, and other rough edges. That friction taught a working mental model of the machine. The author argues that AI removes the struggle, so future users may get results without ever building that feel for how systems behave underneath.
People mostly accepted the underlying discomfort, but trimmed away the melodrama. The strongest consensus was that nobody ever knew the whole stack. Even in the 1990s, most users called someone else when the machine broke, and even serious engineers only understood a few layers deeply. What mattered was not total mastery but having a mental map below your current layer, plus the habit of poking at systems until they make sense. Several commenters said good
CS and computer engineering programs still teach that map from transistors and logic gates up through operating systems and networks, even if graduates later specialize.
Where the conversation got sharper was AI itself. Many saw a real break from past abstraction jumps because deterministic software let you build contracts, tolerances, tests, retries, and other guardrails around lower layers. LLMs may be technically deterministic under fixed settings, but in practice they are unstable in the way engineers care about. Small prompt changes can produce large output swings, and prompt success does not transfer cleanly from one task to another. That makes them useful as assistants or junior-staff analogs, but weak foundations for unattended system building.
The broader worry was not that curiosity disappears forever. Plenty of people pointed to modding scenes, hobby hardware, low-level programming, and repair-minded engineers as proof that inquisitive minorities persist. The real concern was drift in incentives and habits. Consumer software, touch-first devices, social media, managed platforms, and now coding agents all reward getting the answer fast rather than understanding why it works. Commenters who teach or mentor said the bigger problem they see is helplessness when something fails, not ignorance by itself.
A second concrete concern was dependency. Traditional abstractions usually stayed local once built. You could ignore transistor physics and still own your compiler. AI adds a layer that often lives behind a metered subscription and a provider's business model. That changes the risk from "I no longer understand the lower layer" to "I no longer control the tool that thinks for me." A few people were optimistic that local models will eventually blunt this, but the near-term mood was that teams should assume black-box dependence is a strategic cost, not just a convenience.
There was also a side argument over whether the essay itself sounded AI-written. Most treated AI detectors as junk and saw the accusation as a distraction. That tangent fit the main theme better than intended. People are already losing confidence in their ability to tell genuine understanding from machine-shaped output, which is exactly why verification and firsthand knowledge now feel more valuable, not less.