A post on Lobsters accumulated 114 upvotes and 71 comments under the tag vibecoding. Titled simply “On AI,” it linked to a post on jcs.org (currently unreachable). Yet the discussion itself quickly turned into a focal point for developer anxiety.
At the top of the comment thread, user tmcb offered a memorable metaphor:
“It’s like being Sisyphus, but there’s another hill nearby and people are having a blast watching a crane lifting boulders to the top of it with questionable accuracy while it hits some spectators every now and then. One must imagine Sisyphus pissed.”
That comment garnered 93 upvotes because it touched on a growing unease among software engineers: AI coding tools have become so convenient that developers are beginning to wonder if they are still actually learning.
This article examines what happens when you hand off code generation to AI—and where the process of “incidental learning” goes when it disappears.
Image: In modern development environments, AI code generation is standard infrastructure. But behind the productivity gains, the cost to learning is often overlooked.
The Learning Step Magicked Away
Lobsters user duck_tape captured the core thesis of the discussion in a comment that earned 38 upvotes:
“Regarding that last Andreas quote at the end, something that I don’t think we’ve come to terms yet is that a lot of our learning was happening incidentally, as part of our everyday tasks. You couldn’t help but learn while you were implementing some random feature, or doing the yak shaving to set up CI for a new compilation target, etc. And now, we can magic those bits away. We can just ‘create’ whatever is in our head. But we can’t just incidentally learn anymore. It’s actually really hard to stay engaged while the LLM churns through a bug for you.”
Incidental learning isn’t just an obscure term from educational pedagogy. It describes humanity’s most natural way of acquiring skills—learning something unexpected while attempting to do something else. Software engineering has traditionally depended almost entirely on this mechanism.
Consider a junior developer assigned to fix a real-world bug. His goal is simply to resolve the bug, but along the way he is forced to inspect the architecture of the codebase, master the debugger, understand why the issue triggers only under specific conditions, and memorize relevant API patterns. He didn’t set out to study these topics; learning occurred incidentally as a side effect of problem-solving.
Since GitHub Copilot launched in 2022, adoption has grown to over 20 million users by 2025. According to Microsoft data, roughly 46% of code written by users is now AI-generated (rising as high as 61% in Java projects). That trajectory continues to steepen.
AI tools break this feedback loop. Their core interaction mechanism bypasses learning-by-doing: you enter a prompt, and the model emits code.
When those missed opportunities accumulate, the incidental learning mechanism disappears entirely.
Image: AI code completion shifts the developer’s role from “creator” to “reviewer”—reviewing is faster than authoring, but depth of understanding suffers.
Why This Is Not Just “Stack Overflow 2.0”
A common counterargument is familiar: when Stack Overflow emerged, critics warned that developers would stop reading documentation; when IDE auto-complete arrived, skeptics claimed engineers would stop memorizing APIs. Yet the software industry did not collapse.
However, that analogy fails under closer scrutiny. User bendmorris outlined the crucial distinction:
“There absolutely are programmers who have been getting by primarily by copying and pasting from Stack Overflow and not really understanding what they were doing. In the glut of jobs caused by ZIRP I guess this was fine, and now those programmers can use LLMs and their average output quality will probably go up. I don’t think outcomes will be stellar though, and certainly the human in this exchange is adding very little actual value.”
Stack Overflow and IDE auto-complete improved execution speed on top of existing knowledge structures. Developers still needed to comprehend the search results to choose the right snippet; auto-complete only helped when an engineer already knew which function to call. They accelerated execution without eliminating comprehension.
Generative AI skips comprehension altogether. A developer does not magically learn logic simply by inspecting generated output—especially when that output consists of 30 lines of unfamiliar abstractions.
Cognitive psychology highlights two foundational concepts here: the fluency illusion and desirable difficulties. UCLA cognitive psychologists Elizabeth and Robert Bjork demonstrated in the 1990s that learning methods that feel effortless often produce the weakest long-term retention. Conversely, learning that demands active recall and effortful problem-solving leads to far durable mastery.
AI tools provide maximum fluency and minimum friction by design. While this design optimizes product usability, it weakens long-term skill acquisition.
A 2025 randomized controlled trial tested this exact dynamic. Researchers split learners into two groups: one used ChatGPT to assist with tasks, while the other relied on traditional methods. The AI-assisted group performed better on immediate tasks, but scored significantly lower on subsequent independent tests. This outcome aligns with cognitive offloading theory—when answers come too easily, the brain chooses not to store the underlying information.
”I Can Still Learn, But I Don’t Want to Be Just a Code Reviewer”
Another widely upvoted comment (29 votes) came from zetashift, describing a quiet burnout spreading across technical communities:
“The part about scrolling past a lot of news stories / links to things people have shared really resonates with me. I’ve found myself doing the same. In the somewhat rare case that I actually click through to some Github repository, when I notice a
CLAUDE.mdorAGENTS.mdor similar, I instinctively find myself closing the tab. Whatever interest I might’ve had in the project just evaporates immediately… When I use LLMs to assist in software development, I find they just rob me of this satisfaction, almost entirely. I almost feel ‘dirty’ afterwards.”
This reaction is far from unique. User gered chimed in to echo that vibe-coding left him feeling hollow, while user lake shared a personal perspective:
“I’d been working on my main open source project on and off for about 1.5 years. In that time, some other projects appeared and got to where I would have loved to get, in just a few months… I’m genuinely glad they exist, and if they had before I started my project, I may have never started to work on it. My goals are now somewhat different from the other projects, I’m telling myself. Maybe someone will appreciate a project that has human-written code, I’m telling myself. Maybe there’s room for multiple different approaches, I’m telling myself. Open source is not a competition, I’m telling myself. But watching someone take laps around me is dispiriting.”
Underneath these sentiments lies an overlooked structural problem. When senior engineers—those with a decade or two of experience—use AI, they possess the mental model to evaluate output quality, spot subtle hallucinations, and refactor 50 lines of bloated generated code into 10 clean lines. Junior developers lack that foundational judgment.
bendmorris summarized this predicament sharply:
“It’s easy for someone like Andreas to pivot to using LLMs because he has built up the skill to ensure they’re doing quality work and solving the right problems, and that’s not going to atrophy immediately. But I don’t know how the next generation of programmers ever gets there if they have LLMs from the outset, and the simple types of work that build skill are also the easiest to automate away. As an industry we are collectively shooting ourselves in the foot.”
The Problem Isn’t AI, It’s Workflows That Bypass Understanding
A distinction must be drawn carefully. Pointing out these risks does not mean claiming “AI is bad”—such a binary stance is neither helpful nor accurate. AI coding assistants genuinely boost productivity, allowing small teams to ship software that once required tenfold headcount. They allow non-programmers to build useful applications with natural language. Those benefits are real.
The real question is: When developer tools bypass the learning loop by default, who ensures that learning still happens?
Today, almost every AI coding workflow follows a linear pattern: Prompt → Code → Accept. Tools are optimized for task completion rather than developer comprehension.
A research paper titled Agents That Teach: Towards Designing Incidental Learning Back into AI-Assisted Software Development (arXiv:2607.06101) analyzed this gap, introducing the concept of Knowledge Debt:
When AI agents execute code changes that developers do not fully understand, these gaps in comprehension accumulate over time. Today AI fixes a bug you don’t understand; tomorrow it generates an optimization you can’t explain. A year later, your system functions fine, but you can no longer truly maintain it—because you don’t know how it actually works.
Knowledge debt is far harder to detect than technical debt. Technical debt manifests in static analysis or code quality metrics. Knowledge debt leaves no trace in the repository—it hides inside developer minds, revealing itself only when an engineer must troubleshoot independently.
The Cost of Offloading Thought
Lobsters user pyj raised a practical question that resonated with many:
“My personal issue with using AI is that I find I retain much less when using it. I might get the task done, but I don’t learn nearly as much, or remember nearly as much. Are there good strategies for retaining the learning side of building while using AI tools?”
That question remains largely unanswered. A few experienced developers shared personal habits—such as letting Claude generate an initial prototype, then manually refactoring it into a cleaner architecture. But doing so requires already knowing what a clean architecture looks like.
The Lobsters thread eventually diverged into two viewpoints. One perspective holds that hand-crafted coding is becoming an artisanal craft—much like woodworking or playing an acoustic instrument. You can choose power tools or hand planes, and neither choice is inherently superior. The other perspective argues that as industry incentives shift heavily toward AI velocity, hand-crafted coding becomes prohibitively expensive, affordable only to the wealthy or the fiercely dedicated.
Both arguments hold truth, yet both sidestep the core issue: If the path of incidental learning is cut off, how far out of their way must new developers go to reach the level of expertise previous generations gained simply by doing the work?
No one in the thread offered a complete solution. But framing the question clearly is already far more valuable than any product PR copy.
References:
- Lobsters: On AI (114△, 71 comments) (item?id=zljfgp/on_ai)
- Joshua Stein: On AI (jcs.org)
- Hacker News: On AI discussion
- Bjork & Bjork (2011): Desirable Difficulties in Theory and Practice
- Anthropic: ChatGPT as a Cognitive Crutch
- arXiv 2607.06101: Agents That Teach
- Bjork (1994): Memory and Metamemory Considerations in the Training of Human Beings
- GitHub Research: Quantifying GitHub Copilot’s Impact on Developer Productivity and Happiness
