Coding expertise is going to collapse from AI reliance

Coding expertise is going to collapse from AI reliance

对人工智能的依赖将导致编程专业能力的崩塌

AI Coding will Prevent Expertise AI 编程将阻碍专业能力的形成

The need for ongoing friction in long-term skill formation. 长期技能培养需要持续的“摩擦力”。

“We see a future where intelligence is a utility like electricity or water and people buy it from us on a meter and use it for whatever they want to use it for” - Sam Altman of OpenAI “我们预见未来智能将像电力或水一样成为一种公用事业,人们按需购买,并将其用于任何他们想做的事情。”——OpenAI 的萨姆·奥特曼(Sam Altman)

In my previous article, Agentic Coding is a Trap, I discussed the “skilled orchestrator paradox”, where the skills required to manage AI agents for coding are the same ones that can be diminished through the continued use of said AI agents. Expertise was largely the differentiator; the more experienced a developer is, the less likely it is that they might experience skill atrophy, as the knowledge has had a chance to ossify after years of experience. 在我之前的文章《代理式编程是一个陷阱》(Agentic Coding is a Trap)中,我讨论了“熟练编排者悖论”:管理 AI 编程代理所需的技能,恰恰是那些通过持续使用这些 AI 代理而可能退化的技能。专业知识在很大程度上是区分的关键;开发者经验越丰富,就越不容易出现技能萎缩,因为这些知识经过多年的积累已经变得根深蒂固。

If you look around right now, you’ll find the vast majority of those that are seeing the most benefits from these models are those that have had years, if not decades, of experience in the field (which predates AI tooling, of course). And any industry veteran will tell you the same: the bedrock of this knowledge comes from doing the work. 环顾四周,你会发现目前从这些模型中获益最多的人,绝大多数都是在该领域拥有多年甚至数十年经验的人(当然,这些经验是在 AI 工具出现之前积累的)。任何行业老手都会告诉你同样的事情:知识的基石来自于亲手实践。

Developers who’ve entered the field around the time of LLMs are placed in a position where they don’t have the benefit of longevity, but they are being guided (and sometimes mandated) to accelerate their efforts using coding assistants that require a history of expertise to wield effectively and responsibly. 在大型语言模型(LLM)时代进入该领域的开发者,处于一种尴尬的境地:他们没有长期积累的优势,却被引导(有时甚至是强制要求)使用编程助手来加速工作,而这些助手恰恰需要深厚的专业背景才能有效且负责任地使用。

It’s an awkward place to be for that demographic, as it creates a scenario where a novice needs expert-level skills to leverage the tools and keep pace in the industry. 对于这一群体来说,这是一种尴尬的处境,因为它创造了一种局面:新手需要具备专家级的技能,才能利用这些工具并跟上行业步伐。

The “Expert Novice” “专家型新手”

We’re currently sending very mixed signals to people across the industry. We’re hammering in that if you’re not using AI tools, you will be “left behind” by your peers who are using them. “AI won’t replace you, someone using AI will” has been on repeat since 2023. 我们目前向整个行业传递着非常矛盾的信号。我们不断强调,如果你不使用 AI 工具,你就会被使用它们的同行“甩在后面”。自 2023 年以来,“AI 不会取代你,但使用 AI 的人会”这句话一直在被反复提及。

And in the same breath, it’s also said that the way to get the best results from these models is to apply higher-order thinking; “vibe coding” is a dead end; you need to “move up the stack” and create robust specs, architect with good design patterns, and always review the outputs diligently so you never ship something you don’t understand. 与此同时,人们又说从这些模型中获得最佳结果的方法是运用高阶思维;“凭感觉编程”(vibe coding)是死胡同;你需要“向上层堆栈移动”,创建稳健的规范,利用良好的设计模式进行架构,并始终勤勉地审查输出结果,确保你永远不会发布自己不理解的代码。

The skills to do so, however, are a function of someone who has experienced the friction and challenges over time that culminate in “good taste”. 然而,做到这些所需的技能,是一个人长期经历摩擦和挑战后,最终形成“良好品味”的产物。

This leads to another situational paradox: If these tools demand expertise, yet the tools can actively circumvent the friction that cultivates expertise, then what is the path for one to become an expert so they can effectively use these tools? 这导致了另一个情境悖论:如果这些工具需要专业知识,但它们又能主动规避培养专业知识所需的摩擦,那么一个人该如何成为专家,从而有效地使用这些工具呢?

Confidence without Comprehension 没有理解的自信

One hope is that these models will end up accelerating learning as they are used for code generation. Junior developers can work with the same gravitas and confidence as industry veterans with their “personal AI tutor”. Knowing syntax is increasingly less important, and any knowledge or ambiguity gaps are filled by the AI tool. The deeper mechanics of the code stay abstracted away, since the developer sits higher in the stack. 一种希望是,这些模型在用于代码生成时最终会加速学习。初级开发者可以借助他们的“个人 AI 导师”,像行业老手一样从容自信地工作。语法知识变得越来越不重要,任何知识或模糊的缺口都由 AI 工具填补。由于开发者处于更高的堆栈层级,代码的深层机制被抽象化了。

JetBrains, a major player in developer tools, recently cited a study titled “The Widening Gap: The Benefits and Harms of Generative AI for Novice Programmers”, which painstakingly analyzed individual behaviors in live coding sessions, and tested their ability to learn coding with varying degrees of AI assistance. Their main takeaway was stark and counterintuitive: 开发者工具领域的巨头 JetBrains 最近引用了一项名为《不断扩大的鸿沟:生成式 AI 对编程新手的利与弊》的研究。该研究仔细分析了实时编程会话中的个人行为,并测试了他们在不同程度的 AI 辅助下学习编程的能力。他们的主要结论既严峻又反直觉:

“Participants thought it was like having a personal tutor. From the data in our study … we observed that they did not, in fact, use GenAI tools like a personal tutor. In fact, it was quite the opposite.” “参与者认为这就像拥有一个私人导师。但从我们的研究数据来看……我们观察到,他们实际上并没有像对待私人导师那样使用生成式 AI 工具。事实上,情况恰恰相反。”

The participants that leaned into heavier AI assistance: 那些过度依赖 AI 辅助的参与者:

  • “Often skipped crucial planning stages, finding that because they hadn’t reasoned themselves into this position, Copilot had.”
    • “经常跳过关键的规划阶段,因为他们发现自己并没有经过逻辑推理得出结论,而是 Copilot 代劳了。”
  • “Finished with an ‘illusion of competence’ rather than true understanding.”
    • “最终产生了一种‘能力错觉’,而非真正的理解。”

Counter to that, the participants that mitigated their usage of AI: 与此相反,那些减少 AI 使用量的参与者:

  • “Succeeded because they had developed ‘negative expertise’—which is ‘the ability to ignore incorrect or unhelpful GenAI suggestions’—allowing them to focus on writing their own solutions rather than being led astray.”
    • “之所以成功,是因为他们培养了‘负面专业知识’——即‘忽略错误或无用生成式 AI 建议的能力’——这使他们能够专注于编写自己的解决方案,而不是被误导。”
  • “Were able to use GenAI to accelerate, creating code they already intended to make.”
    • “能够利用生成式 AI 来加速,创建他们原本就打算编写的代码。”

The novice developers who were the most unrestricted and confident in their AI usage “had skipped crucial steps in the programming problem-solving process, and were now lost.” 那些在 AI 使用上最不受限制且最自信的新手开发者,“跳过了编程问题解决过程中的关键步骤,现在迷失了方向。”

Perhaps unsurprisingly, the novice developers who performed the best were the ones that greatly mitigated or outright ignored the AI coding assistance. 不出所料,表现最好的新手开发者,恰恰是那些大幅减少甚至完全忽略 AI 编程辅助的人。

Inverted Learning 倒置的学习

Due to the self-directed nature of LLMs, the more experience you have, the more benefit they provide since you can accurately steer, audit, and verify the outputs. The less knowledge you have, the more they can mislead you. Interacting with LLMs for learning new skills takes the shape of an “inverted learning” model, a role reversal where the student is initially guiding the mentor, the mentor responds, and then the student, again, steers the mentor. 由于 LLM 的自导向特性,你的经验越丰富,它们提供的帮助就越大,因为你可以准确地引导、审计和验证输出结果。你拥有的知识越少,它们就越容易误导你。与 LLM 交互以学习新技能呈现出一种“倒置学习”模式,这是一种角色反转:学生最初引导导师,导师做出回应,然后学生再次引导导师。

The process is precarious; LLMs are incredibly sensitive to the shape of the prompt. When you’re exploring new domains, you don’t know what you don’t know, and the malleable and accommodating design of an LLM can lead you to believe you know more than you actually do. 这个过程非常危险;LLM 对提示词的形式极其敏感。当你探索新领域时,你不知道自己不知道什么,而 LLM 灵活且顺从的设计可能会让你误以为自己比实际知道的更多。

If you’re exploring territory that is even somewhat unfamiliar, you often don’t even know the questions that you need to ask that could properly guide the model to providing the best answers. It begins to feel like a compass that always points north, wherever you suggest north might be. 如果你正在探索一个即使有些陌生的领域,你往往甚至不知道该问什么问题才能正确引导模型提供最佳答案。这开始感觉像是一个指南针,无论你认为北方在哪里,它总是指向你所指的方向。

From the same study that JetBrains highlights, even the most prepared students were derailed by the AI assistance due to this type of learning model: One participant demonstrated good fundamental planning and habits, but suddenly “skipped crucial problem-solving planning stages, jumping directly to coding and was enticed by Copilot into quickly producing code” and had to rely on the LLM to fix the error that the LLM introduced. 在 JetBrains 强调的同一项研究中,即使是准备最充分的学生,也因为这种学习模式而被 AI 辅助带偏了:一名参与者展示了良好的基础规划和习惯,但突然“跳过了关键的问题解决规划阶段,直接进入编码,并被 Copilot 诱导快速生成代码”,最终不得不依赖 LLM 来修复由 LLM 自己引入的错误。