AI doesn’t generate working products, that’s still your job

AI 无法生成可用的产品，那依然是你的工作

Building software has never felt this accessible. You describe an idea in plain English, and within minutes, a working prototype appears on your screen. It has a UI. It connects to a database. It does the thing you imagined. For someone who has never written a line of code, that moment feels like magic. For someone who has spent years wrestling with compilers and stack traces, it’s genuinely astonishing. 构建软件从未像现在这样触手可及。你用简单的语言描述一个想法，几分钟内，一个可运行的原型就会出现在屏幕上。它有用户界面，能连接数据库，实现了你构想的功能。对于从未写过代码的人来说，那一刻感觉就像魔法；而对于那些多年来一直在与编译器和堆栈跟踪搏斗的人来说，这确实令人震惊。

The prototype runs on your laptop. It breaks under load. It has no error handling. You find out that it may be leaking your API tokens. The data model made sense for the demo but falls apart the moment you add a second user. The authentication is held together with assumptions. There’s a nagging worry whether everything is secure. You want to deploy it, and suddenly you’re staring at a chasm between “this works” and “this is ready.” 这个原型可以在你的笔记本电脑上运行，但在高负载下会崩溃，且没有错误处理机制。你发现它可能泄露了你的 API 令牌。数据模型在演示时看起来没问题，但一旦增加第二个用户，它就分崩离析了。身份验证机制建立在各种假设之上，你不得不担心系统的安全性。当你想要部署它时，突然发现“能运行”和“准备就绪”之间存在着巨大的鸿沟。

Getting to a prototype was never the hard part. Software engineers have always been able to get something running quickly. What took time was everything else: designing systems that hold up at scale, handling the cases users weren’t supposed to encounter but inevitably do, building in observability so you know when things break, making deliberate decisions about data architecture that you’ll regret less three years from now. None of that has changed. 做出原型从来都不是难点。软件工程师一直都能快速让程序跑起来。真正耗时的是其他工作：设计能够支撑大规模运行的系统，处理用户本不该遇到但必然会遇到的边缘情况，构建可观测性以便在系统崩溃时及时发现，以及做出深思熟虑的数据架构决策，确保三年后你不会为此感到后悔。这些都没有改变。

AI has dramatically accelerated the path to a first working version. It has not shortened the distance between a first working version and something production-grade. The confusion arises because the feedback loop for the early part of the journey has become so fast and so rewarding. You ask, you receive, you see results. That cycle is genuinely exciting, and it creates the impression that the rest of software development must be similarly compressed. It isn’t. AI 极大地加速了通往第一个可用版本的路径，但它并没有缩短从“第一个可用版本”到“生产级产品”之间的距离。困惑之所以产生，是因为开发初期的反馈循环变得如此迅速且令人满足——你提问，你得到，你看到结果。这个循环确实令人兴奋，并让人产生一种错觉，认为软件开发的其余部分也应该同样被压缩。事实并非如此。

The hard problems of building software were never primarily about writing syntax. They were about judgment: what to build, how to structure it, what to defer, when to say no. That judgement is what turns a vibe-coder into a sculptor, and an artisan. It is also what differentiates a prototype from a production-grade system. 构建软件的难题从来不在于编写语法，而在于判断力：构建什么、如何构建、什么可以推迟、何时说“不”。这种判断力将一个“凭感觉写代码的人”转变为雕塑家和工匠。这也是原型与生产级系统之间的本质区别。

The misguided case against learning computer science

反对学习计算机科学的错误观点

Predictably, the accessibility of AI-generated code has sparked a wave of new entrants to the industry who are questioning whether it still makes sense to learn computer science. If you can describe your way to a working application, why spend years studying algorithms, data structures, operating systems, and theory? 不出所料，AI 生成代码的易用性引发了一波行业新人，他们质疑学习计算机科学是否还有意义。如果你可以通过描述需求来获得一个可用的应用程序，为什么还要花几年时间学习算法、数据结构、操作系统和理论呢？

The value of a computer science education was never purely in the ability to produce code. It was in developing a mental model of how systems behave, how they fail, and why. That model is what allows you to look at AI-generated code and recognize that the query it wrote will cause a full table scan on a table with fifty million rows. It’s what allows you to see that the caching strategy it proposed will create a race condition under concurrent load. It’s what tells you that the architecture it suggested solves the problem you described but will make the next problem significantly harder. 计算机科学教育的价值从来不仅仅在于编写代码的能力，而在于建立一套关于系统如何运行、如何失败以及为何失败的思维模型。正是这套模型让你在审视 AI 生成的代码时，能意识到它写的查询语句会导致五千万行数据的全表扫描；能看出它提出的缓存策略在高并发下会产生竞态条件；能告诉你它建议的架构虽然解决了当前问题，却会让下一个问题变得更加棘手。

Without that foundation, you are entirely dependent on the model’s judgment. And models don’t have judgment. They have pattern matching, with an eagerness to produce code that it believes matches your intent. They will confidently generate code that looks right, follows convention, and fails in production in ways that take days to diagnose if you don’t know what you’re looking for. 没有这个基础，你将完全依赖于模型的判断。但模型没有判断力，它们只有模式匹配，并急于生成它认为符合你意图的代码。它们会自信地生成看起来正确、符合惯例的代码，但这些代码在生产环境中可能会以一种让你难以排查的方式失败，如果你不知道自己在找什么，可能需要几天时间才能诊断出问题。

Now is arguably the best time in history to learn computer science, because the gap between understanding and output has collapsed. A student who genuinely grasps how a distributed system works can now build one in a fraction of the time it would have taken a decade ago. 现在可以说是学习计算机科学的最佳时机，因为理解与产出之间的鸿沟已经消失。一个真正掌握分布式系统原理的学生，现在构建一个系统所需的时间仅为十年前的一小部分。

What changes, and what doesn’t

什么是改变的，什么是不变的

The demand for engineers who can only write code mechanically, and who translates requirements into implementations line by line, are genuinely declining. That part of the job is being automated. What’s happening is a compression of the lower end of the productivity distribution and an expansion of the ceiling for those at the top. An experienced engineer using modern AI tools can move at a pace that would have been unimaginable five years ago. Not because the hard problems have disappeared, but because the mechanical work that consumed so much time and attention is largely handled. More hours in the day for the work that actually requires expertise. 那些只会机械地编写代码、逐行将需求翻译成实现方案的工程师，其需求量确实在下降。这部分工作正在被自动化。目前发生的是生产力分布底部的压缩和顶部的上限扩张。一个使用现代 AI 工具的资深工程师，其工作速度在五年前是无法想象的。这并不是因为难题消失了，而是因为那些消耗大量时间和精力的机械性工作大部分被处理掉了。这让你有更多时间去处理真正需要专业知识的工作。

The engineers who will be left behind are not those who lack AI skills. They’re the ones who use AI as a substitute for understanding, who vibe-code their way through systems they can’t reason about, and then find themselves unable to fix what breaks, unable to scale what grows, unable to explain what they built to anyone who needs to maintain it. 会被淘汰的工程师不是那些缺乏 AI 技能的人，而是那些将 AI 作为“理解”替代品的人。他们通过“凭感觉写代码”来构建自己无法理解的系统，结果发现自己无法修复故障、无法扩展系统，也无法向任何需要维护的人解释他们构建的东西。

Learning to operate at a different level

学会在更高的层面运作

The shift required isn’t about adopting a new set of tools. It’s about operating at a higher level of abstraction while keeping your roots in the fundamentals. That combination is genuinely powerful and genuinely rare. The engineers who will leapfrog their peers in the next few years are the ones who treat AI as a force multiplier on deep knowledge rather than a replacement for it. 所需的转变不在于采用一套新工具，而在于在保持基础扎实的同时，在更高的抽象层面进行运作。这种结合既强大又罕见。在未来几年里，那些能够超越同行的工程师，是将 AI 视为深厚知识的“倍增器”而非“替代品”的人。

They understand what they’re asking the model to produce. They review generated code with the same critical eye they’d apply to a junior engineer’s pull request. They bring architectural thinking to the conversation, not just feature descriptions. They know when to push back on what the model suggests. It’s the old skill set, applied to a new context, with dramatically higher leverage. 他们清楚自己要求模型生成什么。他们以审视初级工程师代码提交（Pull Request）的批判眼光来审查生成的代码。他们带入对话的是架构思维，而不仅仅是功能描述。他们知道何时该拒绝模型的建议。这是旧技能在新的背景下的应用，且具有极高的杠杆效应。

The prototype is the easy part. The difference now is that everyone can see that clearly. What comes after the prototype is still hard, still requires real engineering judgment, and still separates the builders who ship reliable software from the ones who ship demos. Learn the fundamentals. Then learn the new tools. In that order. 原型只是简单部分。现在的区别在于，每个人都能清楚地看到这一点。原型之后的工作依然艰难，依然需要真正的工程判断力，并且依然将那些交付可靠软件的构建者与那些只会交付演示产品的开发者区分开来。先学习基础知识，再学习新工具。按这个顺序来。