This paper argues that excessive reliance on AI, particularly for tasks like code generation, paradoxically makes it harder to effectively utilize AI in the long run. The author contends that true proficiency in using AI lies in the ability to critically evaluate its output, identify flaws, and guide it towards superior results. This critical judgment, however, is undermined by over-dependence on AI, leading to a "stagnant growth" phenomenon among developers.

The core argument is supported by principles from brain science and cognitive psychology. The paper introduces Robert Bjork's concept of "desirable difficulty," which posits that appropriate levels of challenge and resistance during learning, though slowing short-term performance, enhance long-term memory retention and transfer. This is exemplified by the "retrieval practice" effect, demonstrated by Roediger & Karpicke (2006): actively recalling information leads to significantly better long-term retention than passive re-reading, despite immediate performance being similar. Neuroscientific findings show that active learning (retrieval) strengthens connectivity between the hippocampus (memory formation) and prefrontal cortex (higher-order thinking), activating the sensorimotor network and insula, indicating a deeper, context-rich encoding. Conversely, passive learning primarily activates connections between the hippocampus and fusiform gyrus (visual pattern recognition), suggesting superficial processing.

The "generation effect" (Slamecka & Graf, 1978) further supports this: actively generating information (e.g., filling in blanks) leads to better memory than passively reading complete information. This is because generation activates meaning processing, retrieval pathways, and executive control regions in the brain, creating richer memory encoding. The paper warns against the "fluency illusion," where the ease of processing information (e.g., reading well-structured AI-generated code) creates a false sense of deep understanding and retention, similar to the short-term benefit but long-term decay seen in passive learning experiments.

The paper then applies these principles to coding judgment, which is largely rooted in procedural memory – the "how-to" knowledge that becomes automatic, like recognizing code smells or identifying appropriate abstraction levels. This contrasts with explicit knowledge (e.g., reciting SOLID principles). Procedural memory formation is explained by Anderson's Adaptive Control of Thought-Rational (ACT-R) model, which describes three stages:

1. Cognitive Stage: Conscious, step-by-step execution, high cognitive load on working memory.
2. Associative Stage: Individual procedures integrate, errors decrease, and processing speeds up.
3. Autonomous Stage: Tasks become automatic, consuming minimal working memory, allowing cognitive resources for higher-level thinking.

Transition between these stages requires repeated performance, involving the basal ganglia (habit formation, procedural learning) and cerebellum (action refinement, automation). Synaptic connections in these areas strengthen through long-term potentiation, leading to neural efficiency – experts activate fewer brain regions for the same task. This "intuition" is the neurological reality of extensive effort and repetition.

Another critical concept is chunking. While working memory capacity is limited (approx. 3-4 chunks), experts can encode more information into each chunk. Chase & Simon's chess study showed grandmasters' superior recall of meaningful board configurations, not random piece placements. Similarly, skilled developers recognize code patterns (e.g., "filtering pattern") as single chunks, freeing up working memory for higher-level architectural decisions. Chunk formation occurs through repeated coding, debugging, and refactoring, involving the prefrontal cortex and basal ganglia.

AI hinders this process by reducing cognitive load, specifically the germane load (the cognitive effort directly involved in schema construction), not just extraneous load (e.g., boilerplate). When AI implements core logic, it makes decisions on data structures, processing order, and error handling, which are integral to the essential cognitive burden. This bypasses the necessary "struggle" in the cognitive stage, delaying the formation of procedural memory and chunks. For junior developers, this is particularly problematic as it prevents the foundational "how-to" knowledge from being established. Reading AI-generated code, while seemingly efficient, is analogous to passively reading in the generation effect experiment – it provides a sense of understanding (fluency illusion) but lacks the deep encoding from active creation and the crucial feedback loop of prediction and correction.

The paper likens this to pre-AI issues like copy-pasting from Stack Overflow or only working within framework abstractions, which also limited cognitive load and growth. AI drastically reduces the "friction" of these paths to stagnation, making it easier to gain "working code" without the effort required for deep learning. This applies to both junior and senior developers; new technologies always require a return to the cognitive stage for new chunk formation.

To counter this, the paper recommends strategies to reintroduce desirable difficulty and germane load:

4. Attempt solutions independently before consulting AI: This activates the generation effect, allowing comparison and evaluation of AI's output against one's own, engaging deeper processing.
5. Engage in serious code reviews: Beyond mere functionality, question architectural choices and long-term implications. This "annoyance" is the desired difficulty.
6. Prioritize direct coding: Hands-on implementation is irreplaceable for procedural memory formation.
7. Use AI for hints, not full solutions: Seek minimal information when stuck, maintaining enough cognitive load to solve the problem independently.

The paper concludes that while AI is an excellent tool for productivity, its impact on learning and long-term skill development must be managed. Growth requires imposing cognitive load, a fundamental structural constraint of the brain that AI makes easier to avoid. True mastery in the AI era comes from the ability to judge and correct AI's output, a skill developed through the "pain" of direct engagement, not through convenience.