That basic claim landed as obvious to most people. The sharper point was that AI is not just another abstraction layer like a compiler or high-level language because it is nondeterministic and often wrong in ways that still require expert judgment. A calculator can replace arithmetic cleanly. An
LLM often cannot replace thinking cleanly, because the user still has to notice when it took a shortcut, misunderstood the problem, or produced plausible garbage. That is why several engineers said the real danger is not losing the ability to type code, but losing the ability to generate plans, build taste, mentor juniors, and feel when an implementation is painful in ways that signal a bad design.
The discussion kept returning to delegation. Many people said this is the same pattern seen in managers, professors, executives, and support staff who stop doing hands-on work and slowly lose touch. AI just makes that loop faster and cheaper. Instead of handing work to another person who pushes back, holds context over time, or notices ambiguity, you hand it to a system that is fast, agreeable, and available for everything. Several commenters argued that this changes the economics more than the cognition. Bosses do not usually turn AI time savings into deeper thinking time. They turn it into more output, more code review, more throughput, and more pressure to accept weaker understanding.
The strongest pro-AI position was narrower than the hype. People reported real gains in setup, exploration, boilerplate, debugging, and trying ideas that would have been too expensive before. A few said AI let them remove code, refactor more aggressively, prototype unfamiliar systems, or break through frustrating tooling barriers. Even supporters mostly framed it as useful when paired with existing skill, external checks, and deliberate practice, not as a substitute for understanding. The skeptical response was that this works best for people who already know enough to spot drift. For juniors, reviewers, and people entering new domains, AI muddies the feedback loop. If the code in a pull request is not really the author's thinking, it becomes much harder to teach, assess, or trust.
Where the conversation settled was not "never use AI". It was that the tradeoff is real, the burden of managing it falls on the worker, and most organizations are incentivized to ignore that until quality drops. People expect some new skills to emerge, but they do not think those new skills automatically replace the old ones that let you evaluate truth, correctness, or design quality. The practical conclusion was blunt: if you still need human judgment, you have to keep exercising it on purpose, because routine AI use will not preserve it for you.