发表于 | 分类于

AI Coding 的反脆弱：为什么追求完美 Prompt 的人注定失败

I. 脆弱性的伪装

现代技术工作者中流行着一种特别危险的幻觉：他们相信，只要找到一个足够聪明的 AI 模型，再配上一条足够精巧的 prompt，就能一次性得到正确的代码。

这种信仰和赌场里相信”必胜公式”的赌徒没有本质区别。他们都犯了同一个错误：把一个根本上不确定的系统当作确定性系统来对待。

OpenAI 自己的文档都白纸黑字地写着：生成式 AI 是可变的，同样的输入有时会得到不同的输出。换言之，你面对的是一个非确定性过程。你能做的不是消灭波动，而是学会在波动中存活。

但大多数工程师不愿意面对这个事实。他们更愿意相信”模型的下一个版本会解决这个问题”。这就像暴风雨前加固房屋和祈祷明天放晴的区别——前者是工程，后者是迷信。

II. 三副透镜

在中文学术圈，人们把系统论、控制论、信息论合称”三论”。这个并称粗糙，钱学森批评过它，学界对此有争议。但这不妨碍我使用它们。我不关心学科划界的政治，我关心的是：这三套理论是否能帮我们看清 AI coding 中的脆弱性来源。

答案是肯定的。

系统论揭示结构性脆弱：你的系统由哪些部件组成？部件之间有没有隐藏的耦合？边界是不是模糊到任何部件都可以越界？

信息论揭示传输性脆弱：你的意图在传递给模型的过程中丢了多少？噪声从哪些缝隙钻进来的？模型”理解”的那个东西，和你脑子里的那个东西，距离有多远？

控制论揭示动态脆弱：当系统开始偏离目标——它一定会偏离——你有没有机制去发现、去量化、去修正？还是说你只有在灾难发生后才知道出了问题？

脆弱的 AI coding 系统，通常在这三个维度上同时失守。而那些看起来”很先进”的系统——多 agent、长 prompt chain、花哨的编排层——往往恰恰是最脆弱的，因为复杂度本身就是脆弱性的温床。

III. 系统脆弱性：为什么更强的模型可能让你更脆弱

这是一个大多数人不愿意听的论点：在一个结构糟糕的系统中，模型越强，你越危险。

为什么？因为强模型会产出看起来极其专业的代码。它的语法完美，注释详尽，命名规范。你看了以后会觉得”太好了”，然后合并进主干。两周后你发现架构被无声地破坏了——异常处理链路断了，日志格式被改了，一个关键的不变式被违反了。

弱模型犯的错误是显性的：编译不过、测试挂了、语法有问题。你一眼就能看出来。强模型犯的错误是隐性的：代码能跑、测试能过、review 时看着很顺眼，但系统的长期一致性正在被侵蚀。

这和 Nassim Taleb 在《反脆弱》中的核心论点完全一致：真正的风险不是那些波动很大的东西，而是那些看起来很稳定、实际上在暗处积累偏差的东西。 大波动你会注意到，小偏移你不会——直到它们突然以灾难的形式爆发。

系统论在这里的启示很明确：不要把精力花在选”最强模型”上。花在定义清晰的边界上。花在划清可改区域与不可改区域上。花在让接口契约不可绕过上。OpenAI 的 agent 指南说得很对：先用最强模型建立性能基线，再逐步替换成更小模型。这是因为在好的系统结构中，模型是可替换的部件——而如果你的系统只有在搭配最强模型时才能工作，那你的系统就是脆弱的。

IV. 信息脆弱性：你的信号在到达模型之前就已经面目全非

Shannon 的信息论从来不关心”意义”。它只关心一件事：信号在经过有噪声的信道之后，还剩下多少可以被正确解码的内容。

把这个模型套到 AI coding 上：你脑子里有一个需求（信源）；你把它写成 prompt 和文档（编码）；这些材料经过上下文窗口、工具调用链、检索管道（信道）到达模型；在这个过程中，模糊措辞、缺失约束、矛盾文档、过长上下文都在注入噪声；模型根据收到的信号进行”解码”并输出代码。

问题是：大多数工程师根本不知道自己的编码质量有多差。

他们写了一句”重构这个模块”，脑子里有五十个隐含假设——保持接口不变、不破坏下游、不改日志格式、不碰那个丑但正确的 hack、输出格式跟之前一致。这五十个假设一个都没写出来，全靠默会知识。然后模型做了一个”重构”，破坏了其中十五个假设，他们却怪模型蠢。

模型不蠢。你的信号蠢。

Anthropic 有一条原则说得极其精准：把 prompt 给一个对任务没有背景的同事看，如果他困惑了，Claude 也会困惑。这其实是信息论的工程化表述：如果你的编码连同类型解码器（人类同事）都解不对，凭什么指望异类型解码器（LLM）能解对？

信息论还暴露了一个被所有 multi-agent 爱好者忽视的问题：每多一跳 handoff，信号就多衰减一次。

你的 manager agent 给 specialist agent 传达了一个任务。传达的过程本身就是一次编码-信道-解码。如果描述不够精确，specialist 理解的东西就已经偏了。它做完以后把结果传回来，又是一次编码-信道-解码。两跳之后，原始信号可能已经走样得不成样子了。

所以，多 agent 系统成功的前提不是”角色分工看起来合理”。前提是每一跳的信息协议必须极其清楚——清楚到你在人类之间做 handoff 时都不需要这么清楚的程度。如果做不到这一点，多 agent 只是在用架构复杂度换来了信息衰减。你不是在解决问题，你是在把问题藏进了一个更难调试的结构里。

V. 动态脆弱性：没有反馈回路的系统注定崩溃

控制论的核心洞见只有一个：任何会运动的系统都会偏离目标，所以你需要的不是完美的初始条件，而是持续的修正机制。

恒温器不需要第一次就把温度设对。它只需要：（1）知道目标温度是多少，（2）能测到当前温度是多少，（3）能根据偏差决定加热还是制冷。

导弹不需要一开始就对准靶心。它只需要反馈够快、修正够及时，就能在飞行过程中不断逼近目标。

AI coding 也一样。你不需要一次 prompt 说清一切。你需要的是：

  1. 一个明确的目标定义（什么算”正确”——测试用例、验收标准）
  2. 一个快速的测量机制（跑测试、lint、trace）
  3. 一个及时的修正手段（再提示、补约束、换策略、人工介入）

TDD 之所以在 AI 时代焕发第二春，不是因为工程师们突然变保守了。而是因为 TDD 恰好就是一个控制回路：

  • 写一个 fail 的测试 = 设定参考值
  • 让 AI 写实现 = 让系统运行
  • 跑测试 = 测量
  • 红变绿 = 偏差归零

这比”请帮我把这整个功能写完”高明得多。后者把控制回路的周期拉到了极长——你要等整个功能写完才能知道它对不对。而在这段时间里，偏差在高速累积。前者把回路缩短到了函数级、行为级，偏差刚出现就被捕获。

反馈回路的速度是系统存活率的决定性因素。 这是控制论的铁律，没有例外。

在 AI coding 中，这意味着反馈应该层层前置：lint 在本地拦，单测在提交前跑，契约测试在 CI 里拦，smoke test 在部署前做，trace grading 在运行时监控。把反馈点放在”PR 合并后线上出事故”的工程师，和把体检放在”进 ICU 以后”的人，犯的是同一种错误。

VI. 反脆弱的 AI Coding

脆弱的系统害怕波动。鲁棒的系统承受波动。反脆弱的系统从波动中获益。

大多数 AI coding 实践还停留在”脆弱”阶段：一次 prompt 赌一次结果，赌赢了沾沾自喜，赌输了怪模型。

少数实践达到了”鲁棒”阶段：有测试、有 CI、有 review，模型波动了也能兜住。

极少数实践触及了”反脆弱”：

  • 每次模型犯的错都被捕获、分类、转化为新的测试用例或文档约束——系统因为失败而变得更强。
  • 每次 prompt 失效都触发一次信息编码的优化——文档越来越精确，默会知识加速外显化。
  • 每次控制回路发现的偏差都反馈到系统设计中——边界越来越清晰，接口越来越严格。

在反脆弱的 AI coding 系统中，模型的每一次”犯错”都不是纯损耗，而是一次免费的压力测试。它暴露了系统的薄弱环节，给你改进的机会。你应该感谢这些错误——前提是你有足够的传感器来捕获它们，有足够的结构来消化它们。

这就是三论合在一起的真正力量：

  • 系统论告诉你在哪里布防线（结构）
  • 信息论告诉你在哪里防衰减（信号）
  • 控制论告诉你在哪里装传感器（反馈）

三者合力，你就能把一个脆弱的”生成 + 祈祷”流程，变成一个反脆弱的工程系统——它不只是”抗住”波动，而是利用波动变得更好。

VII. Guardrails 不是官僚主义，是保险丝

很多工程师讨厌限制。他们觉得 guardrails、review gates、部署门禁是”管理层加的官僚主义”。

这种想法非常脆弱。

在电路里，保险丝不是”对电流的不信任”，而是”对过载的现实主义”。你不知道过载什么时候来，但你知道它一定会来。保险丝是便宜的、局部的、快速的失败点——它烧断自己来保护整个系统。

AI coding 中的 guardrails 也一样：

  • 禁止直接改主干分支：一根保险丝。
  • 高风险文件必须人工 review：一根保险丝。
  • 数据库迁移前生成回滚脚本：一根保险丝。
  • 部署前 smoke test 不通过则阻断：一根保险丝。
  • Trace 显示 agent 在仓库里反复打转则暂停：一根保险丝。

没有保险丝的系统不是”更自由”的系统，而是”更脆弱”的系统。自由和脆弱之间，中间只隔着一层缺失的约束。

OpenAI 的 agent 指南建议给工具按风险分级——根据是否可逆、是否写入、权限等级和财务影响，决定是自动执行、暂停确认还是升级到人工。这不是过度谨慎，这是工程师对现实的尊重。

凡是你不愿意为之设置保险丝的地方，就是你最终会为之付出灾难性代价的地方。

VIII. 对”多 Agent”的怀疑

当前技术圈有一种倾向：一谈 AI coding 就要上 multi-agent。好像代理越多，系统越高级。

这让我想起金融领域的一个经典陷阱：把一个简单产品层层打包成复杂衍生品，每层打包都有”合理理由”，但最终没有人能说清风险在哪里。2008 年的金融危机就是这么来的。

多 agent 不是免费午餐。每多一个 agent 就多一次编码-解码，多一个可能失真的信道，多一组需要管理的状态。你获得了”概念分离”的好感，但你支付了”信息衰减 + 调试难度 + 同步复杂度”的代价。

OpenAI 自己的建议其实很克制：先把单 agent 能力用满，只有当 prompt 条件分支太多、工具选择持续出错时，才考虑拆分。

这是对的。复杂度不是成就，是负债。 每一层复杂度都需要用等量的结构清晰度来偿还，否则它就会变成脆弱性的温床。

好的多 agent 系统不是因为”分了很多角色”而好，而是因为每一跳的信息协议极其清楚、每个节点都有独立的反馈回路、故障可以被定位到具体环节。做到这些极其困难。如果做不到，你的多 agent 系统就只是一个”分布式的混乱”——比集中式的混乱更难修。

IX. 五条原则

  1. 假设模型会犯错——然后据此设计系统。 不是因为模型差，而是因为非确定性系统不可能不犯错。你的工作不是消灭错误，而是确保错误被快速捕获、廉价修正。

  2. 投资信号质量，而非 prompt 技巧。 花哨的 prompt engineering 是在末端做优化。真正的杠杆在上游：清晰的需求定义、完整的接口契约、无歧义的验收标准。信息论告诉你：输出的质量上限取决于输入的信噪比。

  3. 把反馈回路做到极短。 每一层反馈——lint、单测、契约测试、trace——都在缩短偏差的累积时间。反馈越快，系统越反脆弱。

  4. 对复杂度持怀疑态度。 多 agent、长 chain、花哨的编排——它们是不是真的必要？能不能用更简单的结构达到同样的效果？复杂度是需要被证明的奢侈品，不是彰显技术力的装饰品。

  5. 把每一次失败变成系统改进。 脆弱的团队复盘时说”模型今天状态不好”。反脆弱的团队复盘时问：是边界没划清（系统问题）？是文档失真了（信息问题）？还是测试没覆盖（反馈问题）？然后把答案变成新的约束、新的测试、新的文档。

X. 结语

软件工程正在发生一次深层的范式转移：从”制造代码”到”治理生成”。

治理什么？治理一个高能力但高波动的非确定性系统。

用什么治理？用系统论的结构思维来划边界、定接口；用信息论的信号思维来降噪声、保真；用控制论的反馈思维来测偏差、做修正。

那些追求”一条完美 prompt 解决一切”的人，犯的是和追求”一次完美预测解决一切”的金融分析师同样的错误。他们不理解不确定性的本质——不确定性不是一个可以被消灭的障碍，而是系统运行的永恒背景音。

真正的工程智慧不是消灭波动。是在波动中建立秩序。是让系统因为暴露于压力而变得更强，而不是更脆弱。

这就是三论给 AI coding 的终极启示：

别做预言家。做舵手。

舵手不预测风浪。舵手面对风浪。舵手有罗盘（目标）、有传感器（反馈）、有舵（执行修正的能力）。风浪越大，好舵手与坏舵手的差距越明显。

AI 时代最稀缺的，不是生成代码的能力——这个能力正在变得像电一样廉价。最稀缺的，是让生成收敛为可靠产物的能力。而这种能力的底层逻辑，恰恰就是七十多年前那三个理论家所奠定的：看清结构、守住信号、闭合回路。

发表于 | 分类于

AI Coding 的真正难题不是 AI

大多数人对 AI coding 的理解是错的。

他们以为难题是”让模型写出正确的代码”。好像只要模型再聪明一点，context window 再长一点，事情就会自然变好。

但真正在生产环境里大量使用 AI coding 的人都知道，瓶颈从来不在那里。模型已经足够聪明了。问题是：聪明的模型在一个糟糕的系统里，只会更快地制造高质量的混乱。

这听起来像悖论，但它不是。理解这一点，是理解 AI coding 的起点。

有三个很老的理论——系统论、控制论、信息论——恰好能帮你理解这件事。它们各自问了一个不同的问题：

系统论问：整体是怎么组织的？
信息论问：信号是怎么失真的？
控制论问：跑偏了怎么拉回来？

你不需要读过这三个领域的原始文献。你只需要理解，AI coding 的几乎所有难题，最终都能归到这三个问题中的某一个。

系统问题

先说系统论。

人们讨论 AI coding 时最常犯的错误，是把它当成一个模型选型问题。”用 GPT-4 还是 Claude？””这个模型 SWE-bench 多少分？”这些问题不是无意义，但它们遮蔽了一个更重要的事实：模型只是系统的一个部件。

一个 AI coding 系统至少包含：用户的目标、代码库的现状、文档、prompt、工具链、测试套件、CI 流程、review 机制、部署管道和监控。这些部件之间的关系，比任何单个部件的性能更能决定最终结果。

这就像足球。你可以买世界上最贵的前锋，但如果中场传不出球，后防线乱成一锅粥，门将又不和防线沟通，这个前锋只会变成一个很贵的摆设。

OpenAI 的 agent 指南有一个很精确的表述：agent = 模型 + 工具 + 指令。三者必须协同。如果指令模糊，再强的模型也只是在猜；如果工具不对，再清晰的指令也执行不了。

这引出了系统论最重要的洞见：局部强不等于整体强。

我见过太多这样的案例：一个很强的模型放进一个没有测试、没有文档、没有 CI、没有人工审查的项目里，产出的代码看起来很专业，但一周后你发现架构被悄悄破坏了、命名被偷偷改了、异常处理链路断了。模型不是故意的——它只是在一个没有约束的空间里做了局部最优化。

反过来，我也见过用一个中等模型、但系统结构极好的团队：目标明确、上下文干净、测试充分、反馈快速。他们的产出反而更稳定、更可预测、更少翻车。

教训很清楚：不要投资在找最好的模型上。投资在建最好的系统上。

信号问题

再说信息论。

Shannon 在 1948 年提出了一个模型：信号从信源出发，经过编码，通过有噪声的信道，到达解码器，最后被信宿接收。他关心的核心问题是：信号在这个过程中损失了多少？

把这个模型搬到 AI coding 上，你会发现一个让人不安的对应关系：

你脑子里的需求是信源。你写的 prompt 是编码器。上下文窗口是信道。所有模糊的措辞、缺失的约束、矛盾的文档、无关的日志，都是噪声。模型的内部处理是解码器。最后生成的代码是信宿接收到的结果。

这个类比能解释一个让工程师们反复挫败的现象：你明明说得很清楚了，模型还是做错了。

但你真的说清楚了吗？

Anthropic 有一条建议特别好：把你的 prompt 给一个对任务完全没有背景的同事看，如果他会困惑，Claude 也会困惑。

大多数时候，工程师以为自己在”下达指令”，其实他们在做的事情更接近”在一个有损信道上传输一个编码质量很差的信号”。你的需求里有大量隐含假设，你的 prompt 里有大量歧义，你扔给模型的上下文里有大量噪声。模型不是不聪明，是你的信号到达它时已经面目全非了。

信息论还揭示了另一个被低估的事实：文档在 AI 时代变成了一等公民。

为什么？因为 LLM 不继承默会知识。人类高手可以靠直觉和经验补齐文档里没写的东西，模型做不到。它只能消费外显材料。所以，你的需求文档、设计文档、接口契约、样例输入输出——这些不只是给人看的说明书，它们同时也是给模型看的编码协议。

写好文档从来就重要。但在 AI coding 时代，写好文档从”应该做”变成了”不做就会翻车”。

纠偏问题

最后说控制论。

控制论的核心非常简单：定目标，测状态，算偏差，做修正。循环往复。

在 AI coding 里，这意味着什么？

意味着 AI coding 的核心能力不是生成，而是纠偏。

这个判断和大多数人的直觉相反。人们看到 LLM 能秒出一整个文件的代码，会觉得”生成”才是核心价值。但生成是便宜的——而且越来越便宜。真正昂贵的是判断生成结果对不对。

这就是为什么 TDD 在 AI 时代突然变得合理了。

很多工程师以前不喜欢 TDD，不是因为不知道测试重要，而是因为在人工时代，写实现已经够痛苦了，测试被当成额外负担。但 AI 时代翻转了这个等式：实现的成本塌陷了，验证的价值就相对飙升了。

TDD 本质上不是”先写测试”。它是先把”什么算正确”用机器可判定的形式写出来，然后才允许系统去搜索实现。用控制论的术语说，就是先设定参考值，再打开反馈回路。

控制论还有一条关键原则：反馈必须快。

反馈太慢的控制系统，和没有控制差不多。导弹如果每十秒才测一次位置，它就会飞到不知道哪里去。

AI coding 也一样。模型生成的速度极快，如果唯一的反馈点是”PR 合并后线上出故障”，那中间的所有偏差都在高速累积。更好的做法是把反馈层层前置：lint 在本地拦，单测在提交前跑，契约测试在 CI 里拦，trace grading 在部署前做，人工 review 作为最后一道门。

每多一层反馈，偏差就少累积一步。

真正的竞争力

把这三个视角合在一起，你会得到一个关于 AI coding 的统一认识：

AI coding 的真正操作对象不是代码，而是一个生成的可能性空间。系统论决定这个空间的形状，信息论决定空间里的信号质量，控制论决定空间的收敛速度。

一个模型很强但系统很差的项目，就像一台高马力发动机装在一辆没有方向盘的车上——跑得越快，偏得越远。

一个系统很好但模型一般的项目，就像一辆底盘扎实的车装了一台够用的发动机——不会飙出最高速度，但能稳定地到达目的地。

你应该选哪个？

如果你是在做 demo，选前者。如果你是在做工程，选后者。

方法论的重心迁移

这篇文章真正想说的，其实是一个更大的判断：

软件工程的方法论重心正在从”实现”迁移到”治理”。

传统时代的工程师是实现者：理解需求，手写代码，调试发布。AI 时代的工程师更接近于系统设计者、信息架构师和反馈回路工程师。

这不意味着写代码能力不重要了。它意味着写代码能力被纳入了一个更高阶的框架。最终，最有价值的工程师不是那个手写最多代码的人，而是那个能——

  • 把复杂目标变成清晰的系统结构
  • 把模糊意图变成高保真的信号
  • 把不稳定的生成纳入可控制的反馈回路

的人。

你可能觉得这些话太抽象。那我给你五个明天就能做的具体动作：

  1. 在让 AI 写代码之前，先写测试。不是因为测试高尚，而是因为它能让你更快地知道 AI 写的东西对不对。

  2. 写 prompt 之前，先把它给一个对任务没有背景的同事看。如果他困惑了，改 prompt，不要改同事。

  3. 反馈做短。能在本地验证的别等 CI，能在单测里抓的别等联调。

  4. 文档当工程资产写，不当行政材料写。因为模型真的在读它。

  5. 复盘 AI coding 失败时，区分三类原因：系统问题（边界没划清）、信号问题（信息失真）、反馈问题（测试没覆盖）。别只说”模型不行”——这句话几乎没有信息量。

结尾

三论不是老知识。它们是理解 AI coding 的底层语法。

系统论告诉你：别只看模型，看整体。
信息论告诉你：别只怪模型蠢，先看你的信号有多脏。
控制论告诉你：别指望一次说清，建反馈回路。

AI coding 的真正难题不是 AI。是你围绕 AI 建的那个系统。

发表于 | 分类于

三副眼镜看 AI 编程：为什么你的代码”看起来对了”却总出事

一、一个被低估了六十年的老工具箱

1948 年，Claude Shannon 发表了信息论的奠基论文。同一年，Norbert Wiener 出版了《控制论》。再往前几年，Ludwig von Bertalanffy 已经在推销他的一般系统论。这三个人各干各的，互相之间未必认同，但后来被中文学术圈捆在一起，称为”三论”。

这个并称其实有争议——钱学森就批评过，说这种并列太粗糙。但争议本身不重要。重要的是：这三套理论，恰好提供了三副不同焦距的眼镜，而 AI coding 碰巧需要你同时戴上这三副。

你可能会想：1948 年的东西，跟我今天用 Claude Code 写项目有什么关系？

关系大了。而且不是那种”知识分子硬拗”的关系，是那种”不理解这三个视角，你在 AI coding 里踩的坑就会一直踩下去”的关系。

二、先用三十秒把三论讲清楚

系统论问的是：这东西整体是怎么组织起来的？哪些部件在互相影响？边界画在哪？

信息论问的是：信号从发出到接收，中间丢了什么？噪声从哪儿混进来的？

控制论问的是：事情开始跑了以后，怎么发现它跑偏了，又怎么把它拉回来？

就这么简单。但这三个问题一旦叠加到 AI coding 上，杀伤力极大。

因为 AI coding 偏偏同时具备三个特征：它是一个复杂系统（不只是模型，而是人 + 模型 + 工具 + 代码库 + 测试 + 部署的整体）；它天然有信息失真（你说的话模型未必懂，模型做的事你未必察觉）；它非确定性地波动（同样的输入，今天能跑，明天可能翻车）。

这就是为什么三论突然变得有现实感。不是你去找它，是 AI coding 把你推到了它面前。

三、系统论：别只盯着模型——那只是冰山一角

很多人理解 AI coding，起点是”哪个模型最强”。

这不能说错，但太窄了。就好像问”哪个发动机最好”，却不看底盘、变速箱、悬挂、轮胎和路况。

系统论会逼你把镜头拉远。一个 AI coding 系统至少包含：用户目标、代码库、文档、提示词、工具链、测试、CI、review 流程、部署管道、监控机制，以及人和模型之间那个微妙的交互契约。真正决定结果的，往往不是某个点最强，而是这些部件之间的接缝有没有漏风。

OpenAI 的 agent 指南把 agent 的基本形态概括成三样东西：模型、工具、指令。你看，这已经很系统论了。一个 agent 能不能工作，不在于其中哪一项单独有多猛，而在于三者有没有咬合成一个整体。

这里有一个反直觉的结论：一个 90 分的模型放进 60 分的系统，不如一个 75 分的模型放进 85 分的系统。

为什么？因为强模型在弱系统里只会更快地产出高质量的错觉。它把函数写得漂亮极了，但破坏了架构；把 bug 修掉了，但引入了回归；帮你加了功能，但顺手改坏了日志链路。没有清晰的边界定义，没有完备的测试，没有人工审查，模型越强，翻车越隐蔽。

所以系统论给 AI coding 的第一课是：别搞模型崇拜，去搞系统设计。

问自己：这个系统的部件如何协同？知识如何沉淀？故障如何暴露？出错后如何恢复？一旦这样提问，你就已经站在了正确的地面上。

四、信息论：你以为你在下指令，其实你在做编码

这是我觉得三论里对 AI coding 最有穿透力的一个视角。

Shannon 模型里有六个环节：信源、编码器、信道、噪声、解码器、信宿。把它类比到 AI coding——

  • 你脑子里的需求，是信源。
  • 你写的 prompt、文档、示例，是编码器。
  • 上下文窗口、工具调用、检索结果，是信道。
  • 模糊措辞、缺失约束、冲突文档、无关日志、过长上下文，全是噪声。
  • 模型的内部处理，是解码器。
  • 最后吐出来的代码，是信宿收到的结果。

这当然是类比，不是 Shannon 原意。但它能解释一个让人抓狂的现象：你明明讲过了，模型还是做错。

为什么？因为你不是在”下命令”，你是在做”编码”。你的意图要经过语言表述、上下文组装、信道容量限制、噪声干扰，才能到达模型的”解码器”。中间任何一环出问题，结果就失真。

Anthropic 的 prompt 最佳实践里有一句话特别到位：把你的 prompt 给一个对任务几乎没背景的同事看，如果他会困惑，Claude 也会困惑。

这句话的信息论翻译是：你的编码器输出的信号，连人类解码器都解不对，凭什么指望 LLM 解码器能行？

这个视角还能解释另一件事：为什么文档在 AI 时代突然变重要了？

过去很多高手靠默会知识工作——架构意图在脑子里，隐含规范在经验里，边界条件靠直觉兜。LLM 不继承默会知识。它吃的是外显材料。所以，需求文档、设计文档、ADR、接口契约、样例输入输出、错误码说明——这些不只是给人看的说明书，它们也是给模型看的编码协议。

谁能把默会知识转成高保真、低歧义、可复用的表达，谁就掌握了信息论意义上的优势。

再补一个容易踩的坑：上下文不是越多越好，而是信噪比越高越好。 Anthropic 建议编码任务一开始就提供完整上下文，把相关代码片段一次性给全——但”完整”不等于”把仓库垃圾一股脑扔进去”。关键是让模型在最少噪声下接触到最关键的信息。过量且无组织的信息，会把信号淹没。

所以信息论给 AI coding 的第二课是：结果之所以乱，常常不是末端的问题，而是信号在前面就已经失真了。 工程师最该升级的，不是”写更花哨的 prompt”，而是设计更高质量的编码结构。

五、控制论：既然拦不住波动，那就别拦——去设计纠偏回路

这是三论里最实用的一副眼镜。

控制论的核心操作只有四步：定目标、测状态、算偏差、做修正。恒温器是这样工作的，导弹制导是这样工作的，自动驾驶也是这样工作的。

把它翻译到 AI coding：先定义”正确”长什么样（测试、验收标准）；再测量模型实际产出（跑测试、review 代码）；识别偏差（哪些测试挂了、哪些风格不对）；然后通过再提示、重跑、补约束、人工介入等方式修正。

这就是为什么 TDD、eval、review、CI、回归测试、trace，本质上都是控制论装置。它们不是”附加管理”，而是系统稳定性的核心硬件。

这里有一个特别关键的洞见：AI 时代，实现的边际成本在暴跌，而验证的边际价值在暴涨。

想想看：过去人工写代码，实现是最痛苦的部分，测试容易被当成拖后腿的成本。现在 LLM 可以秒出代码，真正贵的不是生成，而是确认。TDD 之所以在 AI 时代突然变得顺理成章，不是因为工程师突然变保守了，而是因为经济学翻转了——生产便宜了，质检就值钱了。

控制论还会提醒你一个容易忽略的点：反馈必须足够快。

反馈太慢，系统就会在错误轨道上跑很远。AI coding 时代尤其如此——模型生成速度极快，如果你把唯一反馈点放在”集成测试结束后”或”PR 合并前”，那你其实是在允许错误高速累积。更好的做法是把反馈层层前置：lint 是一层，类型检查是一层，单测是一层，契约测试是一层，trace grading 是一层，人工 review 又是一层。多层反馈的目的不是苛刻，而是降低单次偏离的代价。

所以控制论给 AI coding 的第三课是：不要妄图靠一次 prompt 把一切说死，去设计一套能持续修正的反馈结构。

六、三副眼镜合在一起看：你管理的不是代码，是”可能性空间”

单独戴任何一副眼镜，你都只能看到一部分。三副一起戴，画面就完整了：

系统论决定了这个空间的边界和部件——有哪些工具、文档、规则、角色、回路。
信息论决定了空间里的信号质量——目标有没有传清、约束有没有丢、上下文有没有被污染。
控制论决定了空间的收敛机制——当输出偏离目标时，系统如何把它拉回来。

一个模型非常会生成，但只要系统边界模糊、信息编码糟糕、反馈回路稀薄，它就会在错误方向上高效前进。反过来，一个不是榜单冠军的模型，如果系统结构清楚、信号高保真、控制回路密实，它反而能持续产出稳定价值。

这就引出了一个更大的判断——

七、时代判断：从”制造代码”到”治理生成”

传统时代，工程师的核心形象是”实现者”——理解需求，亲手编码，调试发布。

AI 时代，这个形象在变。工程师越来越像一个系统设计者 + 信息架构师 + 反馈回路工程师。

软件工程的重心，正在从”如何制造代码”转向”如何治理生成”。

治理什么？

  • 治理部件关系——系统论。
  • 治理语义传输——信息论。
  • 治理偏差收敛——控制论。

你对 TDD、评测、工作流、验证这些词越来越有感觉，不是因为你变保守了，而是因为你在直觉上抓到了 AI 时代最稀缺的东西：不是生成能力，而是让生成收敛为可靠产物的能力。

八、五个你明天就能做的事

理论再好，不落地就是空转。收缩成五个动作：

第一，把 TDD 扩展成广义测试驱动。 验收清单、API 样例、错误码断言、边界 case、回归场景表，都是”先定义正确，再驱动生成”。

第二，设计阶段优先考虑可测性。 你的模块如果副作用太重、输入输出不可观察，后面 AI 再强也难合作。

第三，把文档当编码协议。 需求文档、设计文档、ADR 不是项目装饰品，它们是减少信息失真的工具。谁先把默会知识写成模型能理解的材料，谁先建立优势。

第四，把反馈回路做短。 能在本地检查的不等 CI，能在单测发现的不等联调，能在 eval 复现的不靠线上事故学习。

第五，复盘时用三论分类。 别只说”模型今天状态不好”。问自己：这是结构问题（边界没划清）？信息问题（文档失真）？还是反馈问题（测试没覆盖）？一旦这样分类，抱怨就变成了工程改进项。

九、一句话收尾

如果把整篇压缩成一句话：

AI 时代的软件工程，就是在一个高能力、高波动的生成系统中，通过好的系统结构、清晰的信息编码和密实的反馈回路，把”可能正确”不断压缩成”稳定正确”。

三论不是老知识。它是 AI 时代的工程母语——只不过你今天才有了足够的实感去听懂它。

发表于 | 分类于

从 Shannon 到 AI Coding：信息、控制与系统的工程之美

引子

在技术史上，有些理论诞生时看起来离实践很远，但过了几十年，工程世界的演化反而把它们推到了舞台中央。系统论、控制论和信息论就是这样的例子。

这三套理论在中文语境里常被合称为”三论”。这个称呼本身有争议——钱学森后来批评过，认为把三者简单并列不够严谨，系统科学应当把控制与信息吸纳到更大的框架中去。不过，争议归争议，如果我们不纠缠于学科分类的精确性，而是把它们当作三种不同的观察复杂问题的方法论，那么它们在今天的 AI coding 实践中确实各有不可替代的解释力。

这篇文章不打算做思想史梳理。我想做的事情更具体：从工程角度说清楚，为什么一个现代软件工程师在使用 AI 辅助开发时，会自然地遇到这三套理论所关心的核心问题。而理解这些问题，能帮助我们更理性地看待 AI coding 的能力与局限。

第一章 三论各自在解决什么问题

让我们先回到每一套理论的原始关切。

系统论：部分如何组成整体

系统论的核心命题可以用一句话概括：整体不等于部分的简单相加。 它关心的是结构、边界、层级和关系——一组相互关联的部件，如何通过特定的组织方式涌现出单个部件所不具备的性质。

这个思想今天看来平淡无奇，但它在方法论上的意义很深：当你面对一个复杂对象时，不应该只看局部性能，而要看局部之间的关系和约束。一个由优秀零件组成的系统未必优秀，一个由普通零件组成的系统只要结构得当，可能运行得非常稳定。

控制论：运动中的系统如何不跑偏

控制论关心的不是静态结构，而是动态行为。用 Britannica 的经典概括来说，它研究的是：一个监测者如何把系统当前状态与某个标准进行比较，再由控制者根据偏差来调整系统行为。

这个定义里有四个关键角色：目标（参考值）、传感器（测量当前状态）、比较器（计算偏差）、执行器（实施修正）。恒温器是最简单的例子：设定温度是目标，温度计是传感器，温差是偏差，加热器是执行器。导弹制导、自动驾驶、工业过程控制，都是同一个逻辑的不同实现。

控制论不试图一次把事情做对。它假设系统一定会偏离，然后研究如何通过反馈持续地把偏差压回可接受的范围。

信息论：信号如何在噪声中保真

Shannon 在 1948 年发表的那篇论文，刻意把”意义”排除在理论核心之外。他关心的不是一条消息说了什么，而是一条消息在从信源到信宿的传输过程中，如何被编码、通过有噪信道传输、并尽可能正确地被解码。

Shannon 模型的几个环节——信源、编码器、信道、噪声、解码器、信宿——构成了一个非常普适的分析框架。它的核心洞见是：任何通信系统的可靠性，都受限于信道容量和噪声水平，而好的编码方案可以在物理极限内最大化传输的保真度。

把这三者摆在一起，它们的分工就清楚了：

理论 核心问题
系统论 部件如何组织成有效的整体？
控制论 动态系统如何持续纠偏？
信息论 信号在传输中如何保真？

接下来，我要说明为什么 AI coding 恰好需要同时回答这三个问题。

第二章 AI Coding 为什么是一个复杂系统

理解 AI coding 的本质，首先要摆脱一个简单化的认知：它不只是”代码补全”。

Anthropic 的 Claude Code 文档把这类工具定义为 agentic coding tool——它不仅生成代码片段，还会读取代码库、编辑文件、运行命令、与开发工具集成。常见工作流包括理解陌生代码库、调试、重构、写测试、生成 Pull Request。换言之，现代 AI coding 工具的操作对象已经从”单个函数”升级到了”整个仓库”。

其次，AI coding 具有本质上的非确定性。OpenAI 的评测文档明确指出，生成式 AI 是可变的——同样的输入有时会得到不同的输出。这意味着传统软件测试方法并不足以覆盖这种架构，必须引入专门的评测框架（evals）来持续度量性能和稳定性。

最后，SWE-bench 等基准测试揭示了真实任务的复杂度。它把问题定义为”给定一个代码库和一个 issue，让模型去修改代码并通过仓库测试”。这些问题常常要求跨多个函数、类乃至文件进行协调，还要与执行环境交互、处理很长的上下文。

这三个特征——仓库级操作范围、非确定性波动、真实工程复杂度——叠加起来，使 AI coding 成为一个典型的复杂系统。它不是一个可以用输入输出函数完整描述的黑箱，而是一个由人、模型、工具、代码、测试、流程共同构成的动态整体。

第三章 系统论视角下的 AI Coding

从系统论的角度看 AI coding，最重要的认知转变是：决定产出质量的不是模型这个单点，而是整个系统的结构。

OpenAI 的 agent 指南把 agent 的基本形态概括为三个要素：模型、工具、指令。这三者需要协同工作。模型负责推理与决策，工具负责与外部系统交互，指令负责定义行为边界。它们之间的匹配程度决定了 agent 的实际效能。

在此之上，还有更高层次的系统设计问题：单 agent 还是多 agent？循环何时终止？何时移交（handoff）？何时触发防护机制（guardrail）？这些都属于编排（orchestration）层的决策。

系统论在这里提供了一个非常重要的警示：局部最优不等于整体最优。 一个能力极强的模型，如果放进一个没有明确边界、缺乏测试、没有审查流程的环境里，往往会快速产出表面正确但深层有害的结果——函数级代码可能很精致，但架构级一致性已经被破坏了。

反过来，一个中上水平的模型，放进目标明确、上下文清晰、测试完备、回滚方便的系统里，产出的可靠性反而更高。OpenAI 的 agent 指南建议先用最强模型建立性能基线，再逐步替换成更小模型以优化成本——这正是系统论思维的体现：模型是系统的一个可替换部件，而不是不可动摇的核心。

从系统论出发，工程师需要关心的问题包括：

  • 系统的边界在哪里？哪些文件可改，哪些不可改？
  • 各部件之间的接口是否清晰？模型、工具、指令之间是否有模糊地带？
  • 知识如何在系统中沉淀？是停留在个人经验里，还是已经固化到文档和测试中？
  • 故障如何暴露？有没有机制让错误在早期就变得可见？

这些问题看起来朴素，但它们决定了 AI coding 系统的真实产能上限。

第四章 信息论视角下的 AI Coding

如果系统论解决的是”结构”问题，那么信息论解决的是”传输”问题——更准确地说，是人的意图在传递给模型的过程中如何失真的问题。

这是一个非常值得仔细思考的类比。Shannon 模型中的六个环节可以这样对应到 AI coding 场景：

Shannon 模型 AI Coding 对应
信源 用户头脑中的需求
编码器 需求文档、prompt、示例、接口约定
信道 上下文窗口、工具调用、检索结果
噪声 模糊措辞、缺失约束、冲突文档、过长上下文
解码器 模型的内部表征与推理过程
信宿 生成的代码、改动和答复

这个类比当然不是 Shannon 原意的严格应用，但它有很强的解释力。它帮助我们理解为什么”你明明讲过了，模型还是做错”——问题往往不在解码端（模型智力不足），而在编码端（你的表述引入了歧义）或信道端（上下文组装引入了噪声）。

从信息论的角度，有三个工程启示值得重视。

第一，写 prompt 本质上是在做编码。 Anthropic 的最佳实践明确建议：清晰、直接、具体；把 prompt 给一个对任务没有背景的同事看，如果他会困惑，模型也会困惑。这不是修辞建议，而是编码质量要求。

第二，上下文的价值取决于信噪比，而不是绝对量。 Anthropic 建议编码任务一开始就提供完整上下文，但”完整”指的是”所有关键信息到位”，不是”所有能找到的材料都扔进去”。无组织的海量信息会降低信噪比，反而损害输出质量。

第三，文档在 AI 时代获得了新的工程角色。 传统开发中，很多知识以默会形式存在于工程师的经验中。LLM 无法继承默会知识，它依赖外显材料。因此，需求文档、设计文档、ADR、接口契约、样例输入输出不再只是”人看的说明书”，它们同时也是”模型读的编码协议”。

从信息论的角度看，一个工程团队在 AI coding 中的效能上限，很大程度上取决于它把隐性知识转化为显性、可机器消费的材料的能力。这一点的重要性在今天被严重低估了。

第五章 控制论视角下的 AI Coding

信息论帮助我们理解信号失真的问题，但信号即使传输完美，系统也不一定能稳定运行——因为模型本身是非确定性的。这时候就需要控制论。

控制论的核心逻辑很直接：定义目标 → 测量实际状态 → 计算偏差 → 执行修正。在 AI coding 中，这个回路对应的是：

  1. 定义正确性标准（测试用例、验收清单、评分标准）
  2. 让模型生成产物
  3. 通过自动化或人工手段检测产物是否符合标准
  4. 根据检测结果修正（再提示、补约束、换策略、人工介入）

OpenAI 的评测文档把这个过程说得很清楚：eval 的基本流程是定义目标、收集数据、定义指标、运行并比较、再迭代。另一篇关于测试 agent skills 的文章更进一步，把 eval 描述为”prompt → captured run → checks → score”，并强调要把 outcome、process、style、efficiency 分开检查。这几乎就是经典控制系统的工程化实现。

控制论视角带来的一个特别重要的工程认知是：TDD 在 AI 时代获得了新的合理性。

在纯人工编程时代，很多工程师不爱 TDD，是因为写实现已经够痛苦了，测试容易被当作拖慢速度的成本项。但 AI 改变了这个经济等式：当实现的边际成本因 LLM 而大幅下降时，验证的边际价值就相对大幅上升。TDD 本质上不是”先写测试”，而是”先把目标函数外显化”。用控制论的术语说，就是先设定参考值，再允许系统运行。

控制论还强调一点：反馈回路的速度决定了控制的精度。 反馈越快，偏差累积越少。在 AI coding 中，这意味着应该把反馈层层前置——lint 和类型检查在本地就做，单测在提交前就跑，契约测试和 smoke test 在 CI 中拦截，人工 review 作为最后一道防线。如果唯一的反馈点是”PR 合并后线上出事故”，那控制回路就太长了，偏差会在无形中放大到难以收拾的程度。

第六章 三论合一：可能性空间与收敛

把三个视角合在一起，我们可以获得一个更完整的认识框架：

AI coding 的真正操作对象，不是代码文本本身，而是一个由结构、信号和反馈共同塑造的”生成可能性空间”。

  • 系统论决定这个空间的边界与拓扑——有哪些部件、哪些接口、哪些约束。
  • 信息论决定空间内的信号质量——目标是否传达到位、约束是否完整、上下文是否干净。
  • 控制论决定空间的收敛机制——当产出偏离目标时，系统如何检测到偏差并实施修正。

一个高能力的模型在一个边界模糊、信号嘈杂、缺乏反馈的系统中工作，就像一台高性能发动机装在一辆没有方向盘和仪表盘的车上——速度越快，偏离越远。反过来，一个结构清晰、信号干净、反馈密实的系统，即使搭载的模型算不上顶尖，也能在多数实际工作中产出稳定而可靠的结果。

SWE-bench 这类基准之所以有价值，恰恰是因为它测量的不只是”模型能否写出一段正确的代码”，而是”模型能否在复杂仓库中完成任务并通过既有测试”。后者是一个系统级的度量，不是模型级的度量。

第七章 工程启示与实践建议

把以上分析收敛为具体的工程实践，以下五点值得特别重视。

一、把测试驱动从技术习惯升级为系统基础设施。 不要只把测试理解为单元测试。验收清单、API 契约、边界样例、回归场景表，都是”先定义目标，再驱动生成”的方法。在控制论意义上，它们就是系统的参考值。

二、在设计阶段就为可测性和可观测性预留接口。 一个模块如果副作用太重、边界模糊、输入输出不可观察，那么无论搭配多强的 AI，也很难建立有效的控制回路。

三、把文档视为降低信息失真的工程手段。 需求文档、设计文档、ADR、接口契约不是形式主义的附属品，而是把默会知识外显化、降低编码歧义的核心工具。在 AI 参与开发的团队中，文档质量直接决定了人机协作的信噪比。

四、把反馈回路做短、做密。 能在本地检查的不等 CI，能在单测发现的不等集成联调，能在 eval 数据集中复现的不靠线上事故学习。控制论最忌讳的就是回路太长——长回路意味着偏差在暗处累积。

五、复盘时按三论分类定位问题。 遇到 AI coding 的失败，不要笼统归因为”模型不行”。有针对性地问：是系统结构问题（边界没划清、部件没协同）？还是信息问题（文档失真、上下文噪声太大）？还是反馈问题（测试没覆盖、trace 没监控）？分类越精确，改进越高效。

结语：三论作为工程思维的底层语法

回到文章开头的判断：有些理论诞生时离实践很远，但时代演化会把它们推到实践的中央。

在传统软件工程时代，工程师的核心身份是”实现者”——理解需求，亲手编码，调试发布。在 AI 参与开发的时代，工程师的身份正在演变为”系统的设计者与治理者”。他需要设计部件关系（系统论），需要管理语义传输的保真度（信息论），需要构建偏差检测与修正的闭环（控制论）。

这不是说编码能力不重要了，而是说编码能力被纳入了一个更高阶的能力层次。最终，优秀工程师的竞争力将体现在三个方面：

  • 系统设计能力：知道如何布置部件、划定边界、定义接口。
  • 信息架构能力：知道如何把隐性知识转化为模型能正确吸收的显性材料。
  • 反馈工程能力：知道如何把测试、评测、审查、trace、监控组织成可持续纠偏的闭环。

如果用一句话来概括这篇文章的核心观点：

AI 时代的软件工程，本质上是在一个高能力、高波动的生成系统中，通过良好的系统结构、清晰的信息编码和密实的反馈回路，把”可能正确”持续压缩为”稳定正确”。

这是三论在 AI coding 时代焕发活力的根本原因——不是旧理论被硬套到了新场景，而是新场景的内在结构恰好与旧理论的核心命题高度吻合。从 Shannon 到 AI Coding，中间隔了七十多年，但工程之美的底层逻辑从未改变：面对复杂性与不确定性，好的工程永远是结构、信号与反馈的协奏。

发表于 | 分类于

主权

大多数人对 AI 编程的理解，停留在一个很表层的画面：你打字更快了，搜索更快了，写代码更快了。就好像你原来骑自行车上班，现在换了辆电动车。速度是变了，但你走的还是同一条路，干的还是同一件事。

但真正发生的事情不是这个。

真正发生的事情更像是——你原来自己一个人搬砖，现在突然有一百个人可以帮你搬。问题不再是“怎么搬得更快”，而是“到底该搬去哪”。

我注意到这个变化，是从一个很小的体验开始的。

有一天我发现，我手上几个平台的强模型额度，怎么都用不完。以前我会精心组织一个 prompt，想尽办法一次性把问题问清楚，像在跟一个按小时收费的律师谈话，每一分钟都不想浪费。但突然有一天，我发现这个律师不怎么收费了。或者说，他的费用低到我根本不用想“值不值得问”这个问题。

这个变化看起来很小，但它改变了一切。

因为当你不用再犹豫“要不要调一次模型”的时候，你的工作方式会悄悄发生一个根本性的转变。你不再是先自己想半天，实在想不通再去问。你开始变成：先让模型跑一轮，出三个方案，然后你从三个方案里选一个。你不再小心翼翼地节省每一次调用，而是开始把模型当成自来水——拧开就用，想用就用。

以前的心态是：“这个问题值不值得动用 AI？”
现在的心态变成了：“这个问题我为什么不先让 AI 看一眼？”

你可能觉得这只是效率提升。不是。这是范式变化。

要理解为什么这是范式变化，想想工业革命。

蒸汽机的意义不是让马车跑得更快。蒸汽机的意义是让能源变得便宜到一个程度，使得整个生产组织方式都必须重新设计。以前太贵所以不做的事——质量检查、冗余设计、大规模试错——突然之间都可以做了。不是因为人变聪明了，而是因为能源变便宜了。

AI 对认知劳动做的，就是蒸汽机对体力劳动做的事。

以前很多认知动作太贵了——让人反复审查一段代码、让人从十个角度分析一个设计、让人把每个边界条件都想一遍、让人写完代码再从安全和并发的角度各检查一遍。不是不知道这些事情应该做，而是做不起。一个人一天只有那么多小时，注意力只有那么多，脑子会累，情绪会烦。

现在不一样了。这些认知动作的边际成本正在迅速下降。你可以让模型跑十个方案，可以让模型从三个角度审查同一段代码，可以让模型把测试用例铺到以前你连想都不敢想的密度。原来舍不得做的事，现在都可以做了。

所以，我们面对的核心问题，已经不是“AI 太贵，能不能少用点”，而是“AI 已经这么便宜了，我们整个工作方式该怎么重新设计”。

大多数人对 AI 的定位是“一个聪明的助手”。这个定位太窄了。

把 AI 往抽象了看，它其实是一种新型生产要素。它最本质的特征不是“聪明”，而是便宜、可复制、可并发。

一个人一天只有二十四小时，注意力只有一份，做完 A 才能做 B。但 AI 可以同时跑十个任务，一百个任务。你不用等它做完这个再做那个。它天然就是并行的。

一个人做到第九遍会烦，会走神，会偷工减料。AI 不会。它不会因为重复就变得敷衍。这让它特别适合那些高重复、需要铺量、需要长时间巡检的活。

一个人犯了错，可能职业生涯就拐弯了。AI 犯了错，你让它重来就行。它的试错成本几乎为零。所以它特别适合探索，适合把搜索空间摊开，适合同时给你五种方案让你挑。

把这些特征加在一起，你会发现 AI 最擅长的事情，不是“替你写代码”，而是替你把世界摊开来看。它是认知世界里的廉价能源。不是单次神来之笔，而是大规模、低成本地执行那些以前你舍不得做的认知动作。

但这里有一个很多人搞错的事情。

很多人把 AI 和人类看成同一个刻度上的高低之分：AI 是低配版的人，人是高配版的 AI。AI 笨一点但便宜，人聪明一点但贵。所以问题就变成了“AI 什么时候聪明到能替代人”。

这个理解是错的。AI 和人类根本不是一种东西。

关键区别不在于谁更聪明。关键区别在于谁有 stake。

什么意思？AI 可以给你十个方案，每个方案看起来都挺有道理。但它不需要为其中任何一个方案承担后果。它不会因为选错方案而丢工作，不会因为上线出事故而失眠，不会因为一个糟糕的架构决定而在未来三年里天天给自己擦屁股。

人不一样。人的每一个决定都绑着代价——名誉、时间、关系、职业路径、情绪。你做的决定不是悬浮在空中的，它会回到你自己身上。你要解释，要承担，要复盘，要消化后果。

这就是为什么 AI 天然适合扩张可能性，而人天然适合压缩可能性。

AI 可以帮你看到十条路。但最终选哪一条，只能你来走。因为只有你会真正活在那个选择的后果里。

如果要我用一句话概括人和 AI 的分工，我会这样说：

AI 负责扩张可能性，人负责把可能性压缩成命运。

“扩张”和“压缩”，是两个完全不同的动作。

AI 的活儿是发散。帮你看十种方案、二十种边界条件、三十种失败模式。它从多个角度读需求，从多个角色审设计，从大量组合里生成测试。它天生适合把一个模糊问题的搜索空间铺开，让你看到更多你原本看不到的东西。

人的活儿是收敛。你要在这些可能性里决定什么进入现实，什么被过滤掉，什么虽然可行但不值得，什么虽然漂亮但代价太高，什么虽然技术上正确但时机不对。AI 给你一百条路，你要选一条，然后走下去。

这不是“AI 做简单的，人做难的”。这种分法太粗糙了。今天看起来很难的事，明天 AI 可能做得比你好。但有一类事情始终天然更接近人：定义目标、排序价值、做出取舍、承担后果。这些事情不是因为计算复杂才留给人，而是因为它们和“谁来负责、谁来承受、谁要把这件事纳入自己的人生”有关。

想想看：你到底想成为什么样的人？你觉得什么值得，什么不值得？你愿意为什么承受痛苦？你在一堆路径里为什么选了这条？

这些问题没有“正确答案”。它们需要一个有限的、会死的、不能同时活一万种人生的存在来回答。恰恰因为你不能无限复制自己，你的选择才有分量。恰恰因为你的时间有限，你的注意力才是最贵的货币。

人的有限性不是缺陷。它是承诺的前提。

在 AI 时代，有一个非常重要但很少有人讲清楚的区分：死摩擦和活摩擦。

我们当然希望 AI 帮我们减少痛苦，提升效率。但不是所有痛苦都应该被消除。有些痛苦只是在浪费你的生命，有些痛苦却是在塑造你。

死摩擦，就是那些不会让你成长、只会消耗你注意力的东西。写大量样板代码，机械性地整理格式，反复搜索同一类信息，批量改名，补充重复性的注释，搭测试骨架，翻十几个文件只为了确认一个简单的调用关系。这些事情当然需要被正确完成，但它们本身不会让你变得更好。AI 越能把这些消灭掉，你就越应该高兴，因为这些东西只是在烧你的生命。

活摩擦就不一样了。比如你纠结“这个设计到底够不够好”的那种折磨，你权衡“长期架构和短期交付到底怎么平衡”的那种痛苦，你面对不完整信息必须做判断时的那种焦虑，你检视自己是不是在因为懒惰或者虚荣而做出某个决定时的那种不舒服。这些摩擦看起来效率很低，但它们是你变成你自己的过程。你的判断力、你的边界感、你对风险的直觉，都是从这些痛苦里长出来的。

所以 AI 最有价值的用法，不是帮你消灭一切不舒服，而是：帮你拿走那些没有成长价值的痛苦，把真正塑造你的痛苦保留下来。

落到具体工作里，这个原则特别实用。批量生成 DTO、扫调用链、整理变更说明、补测试骨架——这些是死摩擦，尽管交出去。设计取舍、风险定义、抽象边界、上线标准、关键逻辑是否可信——这些是活摩擦，你得自己穿过去。

一旦你接受了“AI 是廉价可扩展的智能”这个前提，软件工程的重心就会发生一个根本性的迁移。

以前的瓶颈是写代码。程序员的自我想象是：想清楚、写出来、调通、提交。“写”是核心动作。

但当 AI 能大量写代码的时候，“写”就不再是瓶颈了。真正开始变贵的，是另外几样东西：需求到底定义清楚了没有？设计有没有被比较和证伪？实现有没有被验证？测试有没有杀伤力？上线有没有可控性？事故经验有没有变成约束？

换句话说，“写出来”越来越不值钱，“证明它值得信”越来越值钱。

未来的优秀开发者不会长得像一个手艺精湛的木匠。他更像一个控制系统的设计师——设目标，放出候选方案，建测试网，做对抗审查，根据反馈修正，反复让系统收敛到一个足够可信的状态。

以前工程质量靠什么？靠一个经验丰富的人“看一眼就知道哪里不对”。这种直觉当然仍然珍贵，但它太依赖个人了。未来更稳定的路线是建立系统化的验证结构：多方案竞争、独立实现、差分测试、红队 review、回归回放、文档和实现一致性检查。

当智能稀缺的时候，你舍不得做这些。当智能丰裕的时候，你应该默认去做这些。

软件工程的未来，不是让一个程序员变成超人，而是让每一行代码都被一群廉价但强大的智能体反复挑战、验证、解释、重放。

说到具体的工具，很多人陷入一个低层次的问题里出不来：“到底哪个模型最好用？”

这个问题本身就问错了。就像问“到底锤子好用还是螺丝刀好用”一样。它们不是互相替代的，它们应该放在不同的环节。

便宜模型的价值在于铺量。它的单次判断未必最准，但它可以大量调用。适合拉全局地图、列风险清单、扫仓库、扫 diff、补文档、生成骨架、做第一轮分类。它的优势不是“最对”，而是“最广”。就像一支侦察部队，你派出去不是为了它能打赢仗，而是为了它能帮你看清战场。

贵的模型的价值在于压缩不确定性。它应该只在真正难、真正模糊、真正一旦出错代价很高的环节出手：架构方案仲裁、事务边界、一致性语义、幂等设计、权限风险、疑难 bug 根因分析、上线前红队审查。它的价值不是铺量，而是高风险判断。

所以我特别反对两种浪费。

第一种，让强模型去干廉价活。你用最贵的智能去扫文件、补样板代码、写机械注释，就像请一个顶级律师去帮你复印文件，这是在浪费最稀缺的资源。

第二种，让便宜模型直接终审。便宜模型适合大规模探索，但你不能让侦察兵直接拍板战略决策。否则你会把大量“看起来有道理”的半成品直接带进主干。

好的分工是：便宜模型负责多做，强模型负责少错。

这个原则不只适用于不同工具之间，它也适用于 AI 和人之间。AI 负责多做，人负责少错。

把这个思路铺到整个开发流程上，每一个阶段都应该重新分工。

需求阶段最怕什么？不是没想法，而是大家以为自己理解一致，实际上理解完全不一致。我见过太多线上事故，根因不是代码写错了，而是需求本身就有模糊地带——成功到底怎么定义？失败怎么回滚？重试算不算新请求？部分成功部分失败怎么办？权限的边界在哪里？

便宜模型在这个阶段最该做的，不是急着给方案，而是帮你把雾拨开。读现有代码，拉调用链，列出所有你没想到的歧义点和失败场景。强模型则该扮演挑刺者：这个词定义清楚了吗？这个边界会不会炸？这个场景出了错解释成本有多高？

而你必须裁决的是：这次到底做不做？做到哪里？哪些明确不做？验收标准是什么？哪些风险不能接受？

需求阶段，人定义业务真相，AI 只是帮你把真相周围的迷雾拨开。

设计阶段最大的误区是急着追求“一个看起来完整的方案”。智能丰裕时代的正确做法是默认生成多个互相竞争的设计：最小改动版、最可测试版、最长期可维护版、最强调回滚版。让不同方案各自暴露代价，然后你再选。

设计阶段重要的不是“更漂亮”，而是“更可收敛”。

实现阶段最容易犯的错是浪费强模型。绝大多数低风险、高重复的实现工作——DTO、VO、controller 骨架、参数校验、注释、文档——都应该下放给便宜模型。强模型只在少数关键点出手：金额计算、状态转换、权限校验、幂等逻辑、事务和锁。

而你在实现阶段的角色不是生产者，是收敛者。你要防止系统发散——判断某个抽象是不是过头了，某个 diff 是不是需要逐行审，某次小重构会不会稀释主线。

测试阶段，在智能丰裕时代，很可能是变化最大的环节。过去很多团队测试做得薄，不是因为不知道测试重要，而是因为做不起。现在大量便宜智能意味着你终于可以默认去做那些原本觉得太奢侈的验证动作。边界矩阵、权限矩阵、状态转移矩阵、异常路径集合、回归测试、文档和实现一致性检查。

测试阶段的核心不是让灯都变绿，而是建立一种你真正愿意相信的确定性。

上线阶段是所有哲学都会显形的地方。因为到了这里，事情不再只是代码质量，而是“谁来承担结果”。AI 可以帮你生成影响范围图、发布清单、回滚方案、监控建议。它可以做上线前的红队审查：最坏会出什么事故？最先看哪几个指标？哪种情况必须回滚？

但最后那个 go/no-go 的决定——谁来盯盘、出了问题是回滚还是热修、灰度策略怎么定——这些事情没有任何模型能替你承担。AI 只能给建议，发令权必须在你。

说到这里，最底层的问题就浮出来了。

在智能越来越丰裕的时代，一个人到底该保留什么？

我越想越觉得，答案不是“我要坚持自己敲多少行代码”，也不是“我必须手写每一个文档”。如果把亲力亲为本身当成价值，你很容易滑回低效和防御。

真正该保留的是主权。

什么是主权？不是凡事都自己做。而是你有能力、也有意识地决定什么交出去、什么必须自己来——而且这个决定是清醒的，不是顺着便利性滑过去的。

具体来说，有四样东西必须留在自己手里。

第一，目标定义权。这件事为什么值得做？做到什么边界算完成？什么明确不做？这些不是 AI 帮你定义的。

第二，价值排序权。速度和质量怎么平衡？短期收益和长期债务怎么权衡？哪类风险不能接受？这些本质上都是“你愿意为哪种结果负责”的问题。

第三，关键判断拍板权。尤其在高爆炸半径的环节——权限模型、金额逻辑、状态机、不可逆迁移、上线回滚。可以让模型给你一百条建议，但“就这么做”必须由你亲自说出来，而且你知道为什么。

第四，后果承担权。出了事谁解释？谁复盘？谁背结果？谁决定下次怎么防止？AI 可以分析，但不能替你承担后果。凡是最终回到责任结构上的事情，都必须有人在场。

这四样东西一旦也交出去了，你获得的可能是一个极高效的流程，但你可能已经不再是自己工作和人生的主人了。

过去很多年，我们训练自己的方式，本质上都是匮乏时代的训练。学会记忆，学会计算，学会搜索，学会组织材料——因为资源有限，外援很少，智能昂贵。

但现在世界开始翻转了。智能供给越来越多，建议越来越多，草稿越来越多，路径越来越多。这个时候，真正稀缺的能力反而变成了另一种东西：

你能不能在很多建议里形成自己的标准？
你能不能在很多草稿里做出真正属于你的终稿？
你能不能在很多路径里选一条，然后长期走下去？
你能不能在很多优化机会面前知道何时该停？
你能不能在大量 AI 产出面前，不让自己的判断肌肉萎缩？

这是一种全新的训练。不是匮乏时代那种“多做一点就赢了”的训练，而是丰裕时代的训练——靠少迷失一点、少发散一点、少把主权外包一点来取胜。

我越来越觉得，未来一个人最重要的能力，不是生产力，而是收束力。不是谁能调更多模型，不是谁能让系统生成更多东西，而是谁能在海量可能性面前仍然保持方向感。

这个方向感不是 AI 给你的。它是你通过长期的价值排序、风险承担、实践复盘和自我诚实，一点一点长出来的。

这也解释了为什么“自己安静想一想”在 AI 时代反而更重要了。AI 太会给答案了。你很容易在还没真正形成自己理解的时候，就满意于一个表达很漂亮的外部答案。你以为自己想通了，实际上只是借用了一个看起来完整的结论。所以你至少要给自己保留一些不靠 AI 的思考时间：自己写一版判断，自己做一版复盘，自己走完最后一公里的表达。不是反技术，而是给自己的认知肌肉留训练场。

如果把这整篇文章压成几句话，我想说的是：

AI 是廉价的可能性，人是昂贵的承诺。可逆的事让 AI 多试，不可逆的事由人来定。便宜模型负责多做，强模型负责少错，而你负责裁决。该被 AI 消灭的是死摩擦，不该被外包的是活摩擦。软件工程的未来不是更会写，而是更会让系统不容易写错。在智能丰裕的时代，人的核心任务是守住主权。

如果还要再压成一句话：

未来不属于最会调用智能的人，而属于最会治理智能的人。

不属于最会生成内容的人，而属于最会在海量可能性面前做出承诺、把事情带入现实的人。不属于拥有最多外部智能的人，而属于在巨大外部智能加持下，仍然没有丢掉自己中心的人。

AI 会越来越像一种基础资源。但人必须决定，资源为什么而用。AI 越来越擅长展开世界。但人必须把世界压缩成自己愿意承担的一条路。

在智能丰裕的时代，真正的修炼不是怎样拥有更多外部智能，而是在拥有巨大外部智能之后，仍然保有自己的主权、判断和承诺能力。

这大概是未来很多年里，最值得反复提醒自己的一件事。

发表于 | 分类于

技术想要丰裕：当廉价智能涌入软件世界

在技术演化的长河中，有些变化是渐进的，像潮水涨了半寸，你几乎注意不到；有些变化是不可逆的相变，像冰忽然化成水，形态彻底改写。我们正身处后一种变化之中。

如果要用一个生态学的类比来理解当下正在发生的事，我会说：一种新的基础资源正在从稀缺走向丰裕，就像阳光照进了一片原本幽暗的森林——整个生态系统的物种构成、能量流动和竞争格局，都将因此重新排列。

这种基础资源，就是可扩展的机器智能。

很多人把这个变化理解为“AI 辅助编程”——好像只是给程序员配了一个更聪明的搜索引擎，或者一个不知疲倦的实习生。这个理解太窄了。真正发生的事情，是软件生产的底层能量结构正在改变。原本极其昂贵、高度稀缺、无法并行的认知劳动，正在变得便宜、可复制、可并发、可持续调用。这不是效率的量变，而是范式的质变。

在技术史上，每一次基础资源的丰裕化，都引发了类似的范式迁移。而每一次，人们都低估了变化的深度，高估了自己适应的速度。

这篇文章想讨论的，就是当智能开始丰裕之后，什么东西真正变得稀缺了——以及一个软件开发者如何在丰裕中守住自己的位置。

一、从稀缺到丰裕：一条贯穿文明史的古老曲线

技术演化有一条反复出现的弧线：一种关键资源从昂贵走向廉价，从稀缺走向丰裕，而围绕这种资源建立的整套社会结构随之被重塑。

五百年前，书写和复制文本是一种稀缺的认知行为。一个中世纪的抄写员用鹅毛笔抄完一本《圣经》需要整整一年。古登堡印刷术把这个成本压低了几百倍。但真正重要的不是书变便宜了——而是围绕“谁有权传播知识”的整个权力结构被打碎了。教会不再是信息的唯一瓶颈。新教改革、科学革命、现代大学——这些都不是印刷术的“功能”，而是信息丰裕之后涌现出来的生态后果。

一百五十年前，能源经历了同样的变迁。蒸汽机和电力让体力劳动的边际成本暴跌。工厂不再围绕水车选址，铁路把距离压缩成时刻表上的数字。但更深层的变化是：那些原本因为“太贵所以不做”的事情——质量检测、冗余设计、大规模试错——忽然都可以做了。不是人变聪明了，而是能量变便宜了。

今天，同样的弧线正在认知劳动的领域展开。

对一个真实的开发者来说，这个变化的体感可能是这样的：有一天你忽然发现，手里几个平台的强模型额度怎么都用不完了。以前你组织一个 prompt 像在跟一个按小时收费的律师谈话，每一分钟都不想浪费；现在你发现这个律师几乎不收费了——或者说，它的费用低到你根本不用想“值不值得问”这件事。

这个变化看起来很小，但它的生态效应是巨大的。当你不再犹豫“要不要调一次模型”的时候，你的工作流会悄然发生一个根本性的物种替代：你不再先自己想半天、实在想不通再去问；你开始默认先让模型跑一轮，出三个方案，然后从中选一个。你不再小心翼翼地节省每一次调用，而是把模型当成自来水——拧开就用，想用就用。

以前的心态是：“这个问题值不值得动用 AI？”
现在的心态变成了：“这个问题为什么不先让 AI 看一眼？”

这不是效率的提升。这是从“按滴购买”到“接上管道”的基础设施跃迁。正如电力从工厂的奢侈品变成墙上的插座一样，可扩展智能正在从一种按次计费的稀缺服务，变成一种默认开启的环境条件。

而每当一种基础资源丰裕化，真正稀缺的东西就会被重新照亮。

二、机器智能的四种生态特性

要理解这种新的丰裕资源，我们需要像生态学家观察一个新物种那样，辨认它的核心生态位——它擅长什么，它的竞争优势在哪里，它在系统中会占据什么位置。

机器智能有四个根本性的生态特征，这些特征决定了它在技术生态系统中的角色。

第一，它可以复制。 一个人的判断力无法复制给另一个人。但一个模型的能力可以被无限次调用，可以被同时部署在一万个节点上。这让它天然适合那些需要大规模铺开的认知任务。就像蒲公英的种子随风飘散到每一片空地——不追求每一颗都扎根，而是追求覆盖面积。

第二，它可以持续运转。 一个人做到第九遍会疲倦、会走神、会偷工减料。机器智能不会因为重复而变得敷衍。这让它特别适合那些高重复、需要长时间巡检、需要不间断值守的工作——就像珊瑚虫日夜不停地沉积钙质，最终建起整座礁石。

第三，它天然适合探索和展开。 一个人犯了错，可能职业生涯就拐弯了。但机器智能的试错成本接近于零。你让它重来就行。它可以同时生成五种方案、十种变体，把搜索空间摊开来给你看。就像一片草原上同时萌发一百颗种子——不是为了每颗都长成大树，而是为了让你看清哪片土壤最适合生长。

第四，它的单次失败没有生命代价。 机器智能可以犯错，被纠正，重新开始，不留伤疤。这与人类截然不同。人类的每一次重大失误都可能刻入简历、改变轨迹、留下心理阴影。

把这四个特征叠加在一起，你会看到一个清晰的生态画像：机器智能最擅长的，不是“替你写代码”，而是替你把世界摊开来看。它是认知领域的廉价能源——不是单次神来之笔，而是大规模、低成本地执行那些你以前舍不得做的认知动作。

这像极了几亿年前蓝藻对地球做的事情。蓝藻不聪明，不灵活，不具备任何高级策略。但它能廉价地、大规模地、不知疲倦地进行光合作用，日复一日地向大气中释放氧气。最终，整个地球的大气层被改写了，所有后来的复杂生命都建立在蓝藻创造的这个新基底之上。

机器智能正在做类似的事——它在改写认知劳动的基底环境。

三、人类智能：一种不可替代的稀缺物种

这里有一个很多人搞错的事情。他们把 AI 和人类看成同一个刻度上的高低之分——AI 是低配版的人，人是高配版的 AI。就像两种鸟，一种飞得低但翅膀便宜，一种飞得高但翅膀贵。所以问题似乎只是“AI 什么时候飞得跟人一样高”。

这个类比是错的。AI 和人类的关系，不是同一物种的强弱之分。它们更像是鱼和鸟——分属完全不同的生态位，有着根本不同的存在方式。

关键的分界线不在于谁更聪明。在于谁有 stake。

什么是 stake？就是利害关系、切身后果、不可逆的代价。

AI 可以生成十个方案，每个看起来都言之成理。但它不需要为其中任何一个方案承担后果。它不会因为选错方案而丢掉职业，不会因为上线事故而失眠三天，不会因为一个糟糕的架构决定而在未来三年里日日为此擦拭善后。

人不一样。人是有限的、有死的、不可复制的存在。你的每一个决定都绑着代价——名誉、时间、关系、职业路径、情绪消耗。你做的决定不是悬浮在真空中的逻辑推演，它会落地，它会回到你自己身上。你要解释，要承担，要复盘，要消化后果。

正是这种有限性，赋予了人类选择以分量。

在演化论中有一个基本原理：生物信号之所以可信，恰恰是因为它付出了代价。雄孔雀拖着巨大的尾羽，那是一个代价高昂的诚实信号——正因为它用自己的生存概率为美丽“签了名”，这个信号才可信。同样，人类的判断之所以有分量，不是因为人类比 AI 算得更快，而是因为人类用自己有限的生命为那个判断“签了名”。

这就解释了为什么人类天然适合做某一类特定的认知工作——不是因为这些工作“更难”（很多看起来困难的任务 AI 也能做得不错），而是因为这些工作的本质与“谁来负责、谁来承受、谁要把这个决定纳入自己的人生”有关。

目标定义、价值排序、取舍决策、后果承担——这些不是“更高级的计算”，而是一种完全不同类型的行为。它们需要一个有限的、会死的、不能同时活一万种人生的存在来执行。恰恰因为你不能无限复制自己，你的选择才有重量。恰恰因为你的时间有限，你的注意力才是最贵的货币。

人的有限性不是缺陷。它是承诺的前提条件——就像稀缺性是价值的前提条件一样。

四、扩张与收敛：智能生态系统的两个基本功能

每一个健康的生态系统都同时需要两种力量：一种力量负责生成多样性，另一种力量负责选择和收敛。

在生物演化中，基因突变和重组负责不断制造变异——大多数变异是无用的，甚至有害的，但没有这种“过度生产”，就不会有演化的原材料。自然选择则负责筛选——把那些不适应环境的变异淘汰掉，让有用的特征沉淀下来。生成是廉价的、冗余的、过量的；选择是昂贵的、严苛的、不可逆的。

AI 和人类的分工，正好映射到这两种力量上。

AI 是技术生态系统中的变异引擎。 它帮你看十种方案、二十种边界条件、三十种失败模式。它从多个角度读需求，从多个角色审设计，从大量组合里生成测试。它天生适合把一个模糊问题的搜索空间铺开，让你看到更多你原本看不到的东西。它是丰裕的函数。

人类是技术生态系统中的选择压力。 你要在这些可能性中决定什么进入现实，什么被过滤掉，什么虽然可行但不值得，什么虽然漂亮但代价太高，什么虽然技术上正确但时机不对。AI 给你一百条路，你要选一条，然后走下去。你是稀缺的函数。

这不是“AI 做简单的，人做难的”——这种分法太粗糙了。今天看起来很难的事，明天 AI 可能做得比你好。但有一类事情天然更接近人的生态位：为一个项目设定方向、决定什么值得做什么不值得、在不完整信息面前做出承诺、为最终的后果负责。这些事情不是因为计算复杂才留给人，而是因为它们的本质与“谁来签名、谁来承受”有关。

想想看：你到底想成为什么样的开发者？你觉得什么样的软件值得花生命去构建？你愿意为什么样的技术选择承受长期后果？你在一堆同样可行的路径里为什么选了这一条？

这些问题没有“正确答案”。它们需要一个有限的、不可复制的存在来回答。

AI 负责扩张可能性，人类负责把可能性压缩成命运。 这是智能丰裕时代最基本的分工格局，就像光合作用和呼吸作用构成生态系统中最基本的能量循环一样。

五、死摩擦与活摩擦：技术演化的两种阻力

在生态学中，并非所有阻力都是坏的。有些阻力只是在浪费能量——寄生虫消耗宿主的体力但不带来任何适应优势。而有些阻力是塑造性的——高山的严寒和缺氧迫使物种演化出更高效的心肺系统，逆风使树木长出更深的根系。

在软件开发中，同样存在这两种阻力。我把它们叫做“死摩擦”和“活摩擦”。

死摩擦，是那些不会让你成长、只会消耗你生命的认知负担。写大量样板代码、机械性地整理格式、反复搜索同一类信息、批量改名、补充重复性注释、搭测试骨架、翻十几个文件只为了确认一个简单的调用关系。这些事情需要被正确完成，但它们本身不含任何演化信息——做完一万次，你不会因此变得更好。就像生物体消耗能量去对抗寄生虫，这些能量并没有让生物体变得更强壮。AI 越能把这些死摩擦消灭掉，整个系统就越健康。

活摩擦则完全不同。那些你纠结“这个设计到底够不够好”的折磨，你权衡“长期架构和短期交付到底怎么平衡”的痛苦，你面对不完整信息必须拍板时的焦虑，你检视自己是不是因为懒惰或虚荣而做出某个决定时的不舒服——这些摩擦看起来效率很低，但它们是你被塑造的过程。你的判断力、你的边界感、你对风险的直觉，都是从这些痛苦里长出来的。就像骨骼在承受压力时才会变得更致密，肌肉在撕裂后才会变得更强壮。

所以技术的正确演化方向，不是消灭一切摩擦，而是精确地消灭死摩擦、保留活摩擦。

让 AI 拿走那些没有成长价值的痛苦，把真正塑造你的痛苦保留下来。

落到具体工作中，这条原则特别清晰：批量生成 DTO、扫调用链、整理变更说明、补测试骨架——这些是死摩擦，尽管交出去。设计取舍、风险评估、抽象边界、上线标准、关键逻辑的可信度判断——这些是活摩擦，你得自己穿过去。

这不是一条关于效率的原则。这是一条关于你想成为什么样的人的原则。

六、从手工匠人到生态系统管理者：软件工程的范式迁移

每一次基础资源的丰裕化，都会引发专业角色的重新定义。

想想电力普及之前的工厂。那时候一个好的工匠意味着“手艺精湛”——他能用锤子和锉刀把一个零件做到精确的尺寸。但电力和机床普及之后，好的制造者不再是手最巧的人，而是最懂得设计流水线、安排质量检测、管理冗余和反馈的人。核心能力从“做”迁移到了“确保做出来的东西可信”。

软件工程正在经历同样的迁移。

过去几十年，程序员的自我想象是手艺人：想清楚、写出来、调通、提交。“写”是核心动作，“写出漂亮的代码”是最高赞美。但当 AI 能大量写代码的时候，“写”就不再是瓶颈了。代码是廉价的产出物，就像电力时代的标准零件一样。

真正开始变贵的，是另外一组东西：需求到底定义清楚了没有？设计有没有被对比和证伪？实现有没有被独立验证？测试有没有杀伤力？上线有没有可控性？事故经验有没有变成系统约束？

换句话说，“写出来”越来越不值钱，“证明值得信”越来越值钱。

未来的优秀开发者不会看起来像一个手艺精湛的木匠。他更像一个生态系统的管理者——设定目标、释放多个候选方案、建立测试网络、组织红队审查、根据反馈修正、反复让系统收敛到一个足够可信的状态。这与控制论（cybernetics）的精神一脉相承：通过反馈回路和冗余验证来驾驭复杂系统，而非试图用单次天才设计来征服不确定性。

以前工程质量靠什么？靠一个经验丰富的人“看一眼就知道哪里不对”。这种直觉当然仍然珍贵，但它太依赖个体了，不可扩展，不可传承。未来更稳健的路线是建立系统化的验证结构：多方案竞争、独立实现、差分测试、红队审查、回归回放、文档和实现的一致性检查。

当智能稀缺时，你做不起这些。当智能丰裕时，你应该默认做这些。

就像污水处理在水资源稀缺的时代是奢侈品，在水资源丰裕的城市则是基础设施——多层验证在智能稀缺的时代是理想化的教科书建议，在智能丰裕的时代则应该成为默认配置。

软件工程的未来，不是让一个程序员变成超人，而是让每一行代码都被一群廉价但强大的智能体反复挑战、验证、解释、重放。像雨林中每一棵树都被菌根网络、昆虫、鸟类和微生物共同“审查”一样——系统的健康不依赖于任何单一天才物种，而依赖于整个生态网络的冗余和互相制衡。

七、生态位分化：便宜智能与昂贵智能各安其所

在任何成熟的生态系统中，你都不会看到一个物种做所有的事。你会看到精细的生态位分化——每个物种占据自己最擅长的位置，彼此互补而非互相替代。

同样的原理适用于不同级别的 AI 模型。

很多人陷在一个低层次的问题里：“到底哪个模型最好用？”这个问题就像问“到底老鹰厉害还是蚂蚁厉害”——答案取决于你在问什么场景。它们不是互相替代的物种，它们应该占据不同的生态位。

便宜模型的生态位是“侦察与铺量”。 它的单次判断未必最精准，但它可以大量、低成本地部署。适合拉全局地图、列风险清单、扫仓库、扫 diff、补文档、生成骨架、做第一轮分类筛选。它的优势不是“最对”，而是“最广”。就像一群侦察蚂蚁——你派它们出去不是为了打仗，而是为了帮你搞清楚整个地形。

昂贵模型的生态位是“关键判断与压缩不确定性”。 它应该只在真正难、真正模糊、真正一旦出错代价极高的环节出场：架构方案的仲裁、事务边界、一致性语义、幂等设计、权限风险、疑难 bug 根因分析、上线前的红队审查。它的价值不是铺量，而是在高风险关头压缩不确定性。就像生态系统中的顶级捕食者——数量稀少，但在关键位置上维持着整个系统的平衡。

因此，有两种浪费是必须避免的。

第一种浪费：让强模型去干廉价活。你用最贵的智能去扫文件、补样板代码、写机械注释——就像驱使老鹰去搬运树叶，这是对最稀缺资源的严重错配。

第二种浪费：让便宜模型直接终审。便宜模型适合大规模探索，但你不能让侦察蚁群来拍板战略方向。否则你会把大量“看起来有道理”的半成品直接带进主干，像一个没有免疫系统的身体，什么都往里放。

好的分工是：便宜模型负责多做，强模型负责少错。

这个原则不只适用于不同模型之间，它也适用于 AI 和人类之间。AI 负责多做，人负责少错。变异是廉价的，选择是昂贵的——这正是演化的基本经济学。

八、工具的生态分化：每种工具的演化方向

如果我们把当前的 AI 编程工具放进这个生态位的框架里观察，它们各自的角色就很清晰了。

编辑器内置的自动补全和即时建议，像共生菌——它们嵌入在你日常工作的每一个瞬间，低成本、高频率、随时可用。它们处理的是最细粒度的死摩擦：补全一行代码、提示一个函数签名、自动格式化。它们的价值不在于单次判断的深度，而在于无处不在的持续减负。

强推理模型则像生态系统中的大型捕食者。它们不应该被滥用在日常巡逻上，而应该被保留给那些真正需要深度推理的时刻：复杂的架构决策、多步骤的逻辑推演、关键系统的设计审查。它们的数量应该少，但每次出手都应该在最关键的位置上。

异步自主编码代理，像自动化的生态修复系统。你给它一个目标——“修复这个 bug”“实现这个功能”——然后它在后台自主运行，探索、实现、测试，最后给你一个结果。它特别适合那些可以独立、异步完成的任务：修复已知 bug、实现明确规格的功能、生成测试套件。它的节奏不是实时的，而是“设定-释放-收获”。

需求驱动的规格化开发工具，则像建筑行业的标准和规范体系。它们不从代码出发，而是从需求出发——先生成设计文档、测试标准、验收条件，然后再生成实现。它们的价值在于前置收敛：在代码写出来之前就把模糊的需求变成可检验的规格。

每种工具都有自己的演化方向，就像生态系统中每个物种都有自己的适应路径。把它们混用、错配，就像把深海鱼放到沙漠里——不是工具不好，是你把它放错了位置。

九、软件交付的五个生态层：重新分配智能

如果把整个软件交付过程想象成一个分层的生态系统——每一层都有自己的能量流动和物种分布——那么在智能丰裕时代，每一层都需要重新分配角色。

第一层：需求——从迷雾中辨认地形。

需求阶段最危险的不是“没想法”，而是“所有人都以为自己理解一致，实际上理解完全不同”。这就像一群探险者各自以为在往同一座山走，其实他们看到的是不同的山。

我见过太多线上事故，根因不是代码写错了，而是需求本身就留着未被发现的模糊地带——“成功”到底怎么定义？失败怎么回滚？重试算不算新请求？部分成功部分失败怎么办？权限的边界在哪里？

在这个阶段，便宜模型最该做的不是急着给方案，而是帮你把迷雾拨开——读现有代码，拉调用链，列出所有你没想到的歧义点和失败场景。强模型则应该扮演质疑者：这个词定义清楚了吗？这个边界会不会在某个极端情况下爆炸？这个场景出了错，向用户解释的成本有多高？

而你必须亲自裁决的是：这次到底做不做？做到什么边界？哪些明确不做？验收标准是什么？哪些风险不能接受？

需求阶段，人定义业务真相。AI 只是帮你把真相周围的迷雾拨开。

第二层：设计——生成多样性，然后选择。

设计阶段最大的误区是急着追求“一个看起来完整的方案”。这就像演化只产生一个变异体就宣布完成——没有竞争，没有比较，也就没有真正的选择。

智能丰裕时代的正确做法，是默认生成多个互相竞争的设计方案：最小改动版、最可测试版、最长期可维护版、最强调回滚能力版。让不同方案各自暴露代价和弱点，形成一个真正的“选择压力环境”，然后你再选。

设计阶段重要的不是“更漂亮”，而是“更可收敛”。

第三层：实现——让廉价智能铺底，昂贵智能把关。

实现阶段最容易犯的错误是浪费强模型。绝大多数低风险、高重复的实现工作——数据传输对象、控制器骨架、参数校验、注释、文档——都应该下放给便宜模型去完成。强模型只在少数关键节点出场：金额计算、状态转换、权限校验、幂等逻辑、事务和锁。

而你在实现阶段的角色不是生产者，是收敛者。你要防止系统发散——判断某个抽象是不是过度了，某个改动是不是需要逐行审查，某次小重构会不会偏离主线。

第四层：测试——智能丰裕时代变化最剧烈的生态层。

测试可能是这场变革中受影响最大的环节。过去很多团队测试做得薄，不是因为不知道测试重要，而是因为做不起——就像一个贫瘠的生态系统养不起复杂的免疫网络。

现在不同了。大量廉价智能意味着你终于可以默认去做那些原本觉得“太奢侈”的验证动作。边界矩阵、权限矩阵、状态转移矩阵、异常路径集合、回归测试、文档和实现的一致性检查——所有这些原本在教科书里显得理想化的实践，在智能丰裕时代都应该成为标准配置。

测试阶段的核心不是“让所有灯都变绿”，而是建立一种你真正愿意相信的确定性。

第五层：上线——所有哲学都在此刻显形。

上线是整个生态系统的临界时刻——代码离开温室，进入真实世界。到了这里，事情不再只是技术质量，而是“谁来承担结果”。

AI 可以帮你生成影响范围图、发布清单、回滚方案、监控建议。它可以做上线前的红队审查：最坏会出什么事故？最先看哪几个指标？哪种情况必须回滚？

但最后那个 go 或 no-go 的决定——谁来盯盘、出了问题是回滚还是热修、灰度策略怎么定——这些事情没有任何模型能替你承担。AI 只能给建议，发令权必须在你。

这正如整个文明史反复告诉我们的：技术可以制造武器，但开火的命令必须由人来下达。技术可以设计核电站，但按下启动按钮的决定必须由能承担后果的人来做出。

十、主权：智能丰裕时代最稀缺的财产

当我们把目光从具体流程抬高到全局视野，一个更根本的问题浮出水面：在智能越来越丰裕的时代，一个人到底该保留什么？

我越想越觉得，答案不是“坚持自己敲多少行代码”，也不是“必须手写每一个文档”。如果把亲力亲为本身当成目的，你很容易滑回低效和防御——就像马车夫坚持不坐汽车，以此证明自己的价值。

真正该保留的，是主权。

主权不是凡事都自己做。主权是你有能力、也有意识地决定什么交出去、什么必须自己来——而且这个决定是清醒的、深思熟虑的，而非顺着技术的便利性无意识地滑过去的。

具体来说，有四项主权必须留在自己手里。它们是丰裕时代中最不可被自动化的人类能力。

第一，目标定义权。 这件事为什么值得做？做到什么边界算完成？什么明确不做？这不是 AI 帮你回答的问题。就像一个生态系统可以自组织出丰富的物种，但“这片土地应该是雨林还是农田”的决定，必须由能承担长期后果的人来做出。

第二，价值排序权。 速度和质量怎么平衡？短期收益和长期债务怎么权衡？哪类风险绝对不能接受？这些本质上都是“你愿意为哪种结果负责”的问题。没有任何算法能替你回答“什么对你最重要”。

第三，关键判断拍板权。 尤其在高爆炸半径的环节——权限模型、金额逻辑、状态机、不可逆迁移、上线回滚。可以让模型给你一百条建议，但“就按这个来”必须由你亲自说出来，而且你清楚知道为什么。

第四，后果承担权。 出了事谁解释？谁复盘？谁背结果？谁决定下次怎么防止？AI 可以分析原因，但不能替你承担后果。凡是最终回到责任结构上的事情，都必须有人在场——一个有名字、有面孔、会因此失眠的人。

这四项主权，合在一起，构成了一个人在智能丰裕时代的不可替代性。它们不是“暂时还没被自动化的残余工作”，而是与人类有限性本身深度绑定的能力——正因为你有限，你的选择才有分量；正因为你会承受后果，你的判断才可信。

一旦这四项主权也被无意识地交出去——你获得的可能是一个极高效的流程，但你可能已经不再是自己工作和人生的主人了。技术想要自动化一切。但人必须有意识地为某些事情保留手动挡。

十一、在丰裕中修炼收束力

过去几千年，人类训练自己的方式，本质上都是匮乏时代的训练。学会记忆——因为书籍稀缺。学会计算——因为工具有限。学会搜索和组织材料——因为信息分散且昂贵。所有这些能力的核心逻辑都是：资源有限，所以你需要更强的获取能力。

但现在世界开始翻转了。

这个翻转让我想起一个农业史上的类比。在旱地农业时代，农民最重要的技能是找水、蓄水、节水——一切围绕稀缺性展开。但当灌溉系统建成、水变得丰裕之后，最重要的技能变成了排水、防涝、控制盐碱化——你需要学会应对丰裕带来的新问题。

智能的丰裕正在制造一个类似的翻转。建议越来越多，草稿越来越多，方案越来越多，路径越来越多。这时候真正稀缺的能力变成了一种截然不同的东西：

你能不能在很多建议里形成自己的标准？
你能不能在很多草稿里做出真正属于你的终稿？
你能不能在很多路径里选一条，然后长期走下去？
你能不能在很多优化机会面前知道何时该停？
你能不能在大量 AI 产出面前，不让自己的判断肌肉萎缩？

我越来越觉得，未来一个人最重要的能力，不是生产力，而是收束力。不是谁能调更多模型，不是谁能让系统生成更多东西，而是谁能在海量可能性面前仍然保持方向感。

这个方向感不是 AI 给你的。它是你通过长期的价值排序、风险承担、实践复盘和自我诚实，一点一点长出来的——就像一棵树的年轮，每一圈都记录着一年的干旱和风暴，都是从真实的承受中沉积下来的。

这也解释了为什么“自己安静想一想”在 AI 时代反而变得更重要了。AI 太擅长给答案了。你很容易在还没真正形成自己理解的时候，就满足于一个表达漂亮的外部结论。你以为自己想通了，其实只是借用了一个看起来完整的答案——就像一个从不自己走路的人，看了很多关于走路的视频，以为自己会走路了。

所以你至少要给自己保留一些不靠 AI 的思考时间：自己写一版判断，自己做一版复盘，自己走完最后一公里的推理。这不是反技术——这是给自己的认知肌肉留训练场。就像即使有了汽车，你仍然需要步行来保持腿部肌肉的功能。

十二、长期原则：智能丰裕时代的七条生态法则

在观察了技术演化的长期趋势之后，我总结出几条在智能丰裕时代可以反复依赖的原则。它们不是策略建议——策略会随环境变化。它们更像是生态学中的基本法则——在不同的环境条件下都保持成立。

第一条：AI 是廉价的可能性，人是昂贵的承诺。 可逆的事让 AI 多试，不可逆的事由人来定。这是最基本的分工原则。

第二条：便宜模型负责多做，强模型负责少错，而你负责裁决。 像生态系统的三个营养级一样——基层大量生产，中层精确筛选，顶层做出不可逆的决定。

第三条：该被消灭的是死摩擦，该被保留的是活摩擦。 分辨两者的标准很简单：这个痛苦经历之后，你是只变得更疲惫了，还是变得更强了？

第四条：写出来不值钱，证明值得信才值钱。 在智能丰裕时代，代码的生产不再是瓶颈，代码的可信度才是。你的核心工作从“生产”转向“验证”。

第五条：目标定义权、价值排序权、关键判断拍板权、后果承担权——这四项主权不可外包。 它们是你作为一个有限的、真实的人在技术系统中不可替代的锚点。

第六条：在丰裕中训练收束力，比在匮乏中训练生产力更重要。 未来最稀缺的不是“能做更多”的人，而是“能在更多面前保持清醒”的人。

第七条：定期给自己留一段不依赖外部智能的思考时间。 不是反技术，而是维护你最不可替代的器官——你自己的判断力。就像定期断食是为了维护消化系统的敏感度，定期“断 AI”是为了维护认知系统的独立性。

结语：技术想要丰裕，而人必须学会治理丰裕

站在更长的时间尺度上看，我们今天经历的这场变化，不过是技术演化那条古老弧线的又一次展开。

五百年前，印刷术让信息丰裕了。人类学会了在信息的海洋中建立大学、图书馆和同行评审制度——这些都是“治理信息丰裕”的技术。

一百五十年前，工业革命让能源丰裕了。人类学会了在能量的洪流中建立安全标准、环境法规和质量管理体系——这些都是“治理能源丰裕”的技术。

今天，机器智能正在让认知劳动丰裕。我们需要学会的，是“治理智能丰裕”的技术——不是拒绝丰裕，也不是沉溺于丰裕，而是在丰裕中建立秩序。

未来不属于最会调用智能的人，而属于最会治理智能的人。

不属于最会生成内容的人，而属于最会在海量可能性面前做出承诺、把事情带入现实的人。不属于拥有最多外部智能的人，而属于在巨大外部智能的加持下，仍然没有丢掉自己中心的人。

技术想要丰裕——这是它的演化方向，不可逆转。但人必须决定，丰裕为什么而用。技术想要展开一切可能性——这是它的内在冲动。但人必须把可能性压缩成自己愿意承担的一条路。

在智能丰裕的时代，真正的修炼不是如何拥有更多外部智能，而是在拥有了巨大外部智能之后，仍然保有自己的主权、判断和承诺能力。

这大概是未来很多年里，文明需要反复学习的一课。就像每一次基础资源的丰裕化一样——技术赋予我们的力量越大，我们越需要学会什么时候不使用它。

而这，恰恰是技术自身无法教给我们的事情。

发表于 | 分类于

软件如何学习：当廉价智能重塑编程的层次结构

一份关于速度分层、系统演化与人类主权的田野笔记

从建筑到软件：一个关于适应性的老问题

我在《建筑如何学习》里花了很多年研究一个问题：一栋建筑，哪些部分应该变得快，哪些部分应该变得慢？场地几乎不变，结构可以撑一百年，外皮每二十年翻新一次，空间布局每七年调一次，内部设备三五年一换，家具和物品天天在动。这就是速度分层（pace layers）——不同层次以不同速率运转，快层创新试错，慢层稳定约束，整个系统因此既能适应变化又不会崩溃。

软件工程正在经历一场与此高度同构的结构性变化。只不过这一次，改变的不是建筑材料的价格，而是认知劳动的价格。

过去一年里，我注意到一件不起眼但意义深远的事：认知劳动的边际成本正在暴跌。以前调用一次强模型，你会像跟按小时计费的律师谈话一样字斟句酌。现在，额度多到用不完。这个变化看起来很小，但它改变了一切——就像廉价电力不只是让灯泡更亮，而是让整个工业组织方式必须重新设计。

这不是效率的线性提升。这是系统的相变。

相变：从稀缺认知到丰裕认知

要理解今天发生的事，最好的类比仍然是工业革命。

蒸汽机的意义不在于让马车跑得更快。蒸汽机把能源的价格降到了一个阈值以下，使得原来“太贵所以不做”的事情突然变得可行。质量检查、冗余设计、大规模试错——这些做法早就有人知道应该做，只是做不起。廉价能源改变了经济约束，经济约束的改变重组了整个生产系统。

AI 对认知劳动做的事情，结构上完全一样。

以前很多认知动作太贵了：让人反复审查一段代码，让人从十个角度分析一个设计，让人把每个边界条件都走一遍，让人写完代码再从安全和并发的角度各查一遍。不是没人知道这些事该做——而是一个人一天只有那么多小时，注意力只有那么多，脑子会累，情绪会烦。认知劳动的稀缺性，是过去半个世纪软件工程一切妥协和捷径的根本原因。

现在，这个约束正在松动。你可以让模型跑十个方案，可以让模型从三个角度审查同一段代码，可以让模型把测试用例铺到以前你连想都不敢想的密度。

当一种关键资源从稀缺变成丰裕，整个系统的组织方式都必须重新设计。问题不再是“怎么省着用智能”，而是“智能已经这么便宜了，整个工作方式该怎么重新设计”。

这是一场相变。相变意味着旧的最优解不再是最优解。

AI 的系统特征：一种新型生产要素的田野观察

把 AI 从抽象的“聪明助手”拉回到具体的系统特征上来看，它本质上是四样东西的叠加：

可复制。 一个人一天只有二十四小时，注意力只有一份。AI 可以同时跑十个、一百个任务，天然并行。

持续运转。 一个人做到第九遍会烦，会走神，会偷工减料。AI 不会因为重复而变得敷衍。这使它特别适合高重复、需要铺量、需要长时间巡检的工作。

适合搜索展开。 一个人犯了错，职业生涯可能就拐弯了。AI 犯了错，重来就行，试错成本几乎为零。所以它天然适合探索——把搜索空间摊开，同时给你五种方案让你挑。

单次错误无生命代价。 这一点经常被忽视。AI 的错误是可回滚的、可丢弃的。它在系统中扮演的角色，更接近于侦察兵而不是指挥官。

把这四个特征加在一起，你会看到一个清晰的图景：AI 最擅长的事情不是“替你写代码”，而是替你把世界摊开来看。它是认知世界里的廉价能源——不是单次神来之笔，而是大规模、低成本地执行那些以前你舍不得做的认知动作。

两种智能的速度分层

这里需要引入速度分层的框架。

在我的分层模型里，快层负责创新和试错，慢层负责稳定和约束。快层的活力来自它可以大量犯错而代价很低；慢层的力量来自它不轻易改变，因此为整个系统提供连续性和方向。快层如果没有慢层的约束，系统会失控发散；慢层如果没有快层的输入，系统会僵化死亡。

AI 和人类智能的关系，恰好就是一个速度分层系统。

AI 是快层。 它便宜、可复制、可并发、不怕犯错。它天然适合发散——帮你看十种方案、二十种边界条件、三十种失败模式。它可以从多个角度读需求，从多个角色审设计，从大量组合里生成测试。它的功能是把搜索空间摊开，把可能性展开，让你看到更多原本看不到的东西。

人类是慢层。 人的每一个决定都绑着代价——名誉、时间、关系、职业路径、情绪。你做的决定不是悬浮在空中的，它会回到你身上。你要解释、要承担、要复盘、要消化后果。人的智能不是“高配版的AI”——它是一种完全不同性质的存在。它的核心特征不是计算能力，而是有 stake。

什么是 stake？AI 可以给你十个方案，每个看起来都有道理。但它不需要为其中任何一个承担后果。它不会因为选错方案而丢工作，不会因为上线事故而失眠，不会因为一个糟糕的架构决定而在未来三年里反复擦屁股。

人不一样。恰恰因为你不能无限复制自己，你的选择才有分量。恰恰因为你的时间有限，你的注意力才是最贵的货币。人的有限性不是缺陷，而是承诺的前提。

所以，AI 负责扩张可能性，人负责把可能性压缩成命运。

这两个层次必须以不同的速度运转，承担不同的功能。快层（AI）大量试错、广泛搜索、持续生成；慢层（人类）定义目标、排序价值、做出取舍、承担后果。试图用快层替代慢层，或者用慢层去干快层的活，都会破坏系统的适应性。

死摩擦与活摩擦：系统中该消除什么，该保留什么

每个系统里都有摩擦。但摩擦不是一种东西，它至少分两种。

死摩擦是不带来成长的消耗。写大量样板代码，机械性地整理格式，反复搜索同一类信息，批量改名，补充重复性注释，搭测试骨架，翻十几个文件只为确认一个调用关系。这些事情需要被正确完成，但它们本身不会让你变得更好。它们相当于建筑里的临时脚手架——用完就该拆掉。AI 越能消灭这些，你就越应该高兴。

活摩擦是塑造判断力的过程。你纠结一个设计到底够不够好，你权衡长期架构和短期交付的平衡，你面对不完整信息必须做判断时的焦虑，你检视自己是不是在因为懒惰或虚荣而做出某个决定时的不适。这些摩擦看起来效率很低，但它们是你变成你自己的过程。你的判断力、边界感、对风险的直觉，都是从这些痛苦里长出来的。这相当于建筑里的结构层——它不能被轻易替换，因为整个系统的完整性依赖于它。

用速度分层的语言来说：死摩擦存在于快层，应该被快速消除和替代；活摩擦存在于慢层，应该被保留和尊重。

落到实践里，这个区分非常具体。批量生成 DTO、扫调用链、整理变更说明、补测试骨架——死摩擦，交出去。设计取舍、风险定义、抽象边界、上线标准、关键逻辑的可信度判断——活摩擦，自己穿过去。

从手工艺到控制论：软件工程的重心迁移

一旦接受“认知劳动正在变得廉价”这个前提，软件工程的重心就会发生一个根本性的迁移。

以前的瓶颈是写代码。程序员的自我想象是：想清楚，写出来，调通，提交。“写”是核心动作。这就像一个木匠，手艺就是一切。

但当 AI 能大量写代码的时候，“写”就不再是瓶颈了。真正开始变贵的是另外几样东西：需求到底定义清楚了没有？设计有没有被比较和证伪？实现有没有被验证？测试有没有杀伤力？上线有没有可控性？事故经验有没有变成约束？

“写出来”越来越不值钱，“证明它值得信”越来越值钱。

这个转变，本质上是从手工艺模式转向控制论模式。未来的优秀开发者不会像一个手艺精湛的木匠，而更像一个控制系统的设计师——设目标，放出候选方案，建测试网，做对抗审查，根据反馈修正，反复让系统收敛到一个足够可信的状态。

过去工程质量靠什么？靠一个经验丰富的人“看一眼就知道哪里不对”。这种直觉仍然珍贵，但它太依赖个人，不可复制，不可持续。未来更稳定的路线是建立系统化的验证结构：多方案竞争、独立实现、差分测试、红队审查、回归回放、文档和实现一致性检查。

当智能稀缺时，你舍不得做这些。当智能丰裕时，你应该默认去做。

用建筑的类比来说：过去的软件像是一个人凭手感砌的墙，质量完全取决于匠人。未来的软件更像是一栋经过结构工程师计算、多轮检验、冗余设计的建筑——质量来自系统，而不只是来自个人。

工具的速度分层：便宜模型铺量，强模型深判

工具本身也服从速度分层。

很多人陷在一个低层次的问题里出不来：“到底哪个模型最好用？”这就像问“锤子好用还是螺丝刀好用”。它们不是互相替代的，它们属于不同的层次。

便宜模型是快层。 它的单次判断未必最准，但可以大量调用。适合拉全局地图、列风险清单、扫仓库、扫 diff、补文档、生成骨架、做第一轮分类。它的优势不是“最对”，而是“最广”。就像一支侦察部队——你派出去不是为了它能打赢仗，而是为了它能帮你看清战场。

强模型是慢层。 它应该只在真正难、真正模糊、真正一旦出错代价很高的环节出手：架构方案仲裁、事务边界、一致性语义、幂等设计、权限风险、疑难 bug 根因分析、上线前红队审查。它的价值不是铺量，而是高风险判断——压缩不确定性。

两种浪费都要警惕。

第一种：让强模型干快层的活。用最贵的智能去扫文件、补样板代码、写机械注释——这就像请一个结构工程师去搬砖，浪费了系统中最稀缺的资源。

第二种：让便宜模型直接做慢层的决策。便宜模型适合大规模探索，但你不能让侦察兵直接拍板战略决策。否则你会把大量“看起来有道理”的半成品直接带进主干。

原则很简单：便宜模型负责多做，强模型负责少错。

这个原则同样适用于 AI 和人之间的分工。AI 负责多做，人负责少错。

把这个分层推广到具体工具上：

  • Cursor Auto 扮演的是廉价认知劳动力池——快层中的快层，适合大量铺开、批量处理。
  • Opus 扮演的是首席架构师兼检察官——慢层中的慢层，用于深度判断和对抗审查。
  • Codex 是并行执行中心——在快层中把任务展开到最大并发。
  • Kiro 是规格化与约束中枢——把慢层的决策冻结为机器可执行的约束。

每个工具在系统中的位置不一样。好的工程实践不是选“最好”的工具，而是把每个工具放到它该在的层次上。

重新分工：五个阶段的速度分层

把分层思维铺到整个开发流程上，每一个阶段都呈现出清晰的快层/慢层结构。

需求阶段。 最怕什么？不是没想法，而是参与者以为自己理解一致，实际上理解完全不同。我见过太多线上事故，根因不是代码写错了，而是需求本身有模糊地带——成功怎么定义？失败怎么回滚？重试算不算新请求？部分成功部分失败怎么办？权限的边界在哪？

快层的工作：便宜模型帮你把雾拨开——读现有代码，拉调用链，列出所有你没想到的歧义点和失败场景。先铺地图，再冻结规格。

慢层的工作：你来裁决——这次到底做不做？做到哪里？哪些明确不做？验收标准是什么？哪些风险不能接受？需求阶段，人定义业务真相，AI 帮你把真相周围的迷雾拨开。

设计阶段。 最大的误区是急着追求“一个看起来完整的方案”。丰裕时代的正确做法是默认生成多个互相竞争的设计：最小改动版、最可测试版、最长期可维护版、最强调回滚版。让不同方案各自暴露代价。

快层：多版并行生成，竞争比较。
慢层：你来选择，选择本身就是判断和承诺。设计阶段重要的不是“更漂亮”，而是“更可收敛”。

实现阶段。 最容易犯的错是浪费强模型。绝大多数低风险、高重复的实现工作——DTO、VO、controller 骨架、参数校验、注释、文档——都应该下放给便宜模型。强模型只在少数关键点出手：金额计算、状态转换、权限校验、幂等逻辑、事务和锁。

快层：AI 当生产线，大量铺开。
慢层：你当收敛者——判断某个抽象是不是过头了，某个 diff 是不是需要逐行审，某次小重构会不会稀释主线。

测试阶段。 这可能是智能丰裕时代变化最大的环节。过去很多团队测试做得薄，不是因为不知道重要，而是做不起。现在大量便宜智能意味着你终于可以默认去做那些原本觉得太奢侈的验证动作：边界矩阵、权限矩阵、状态转移矩阵、异常路径集合、回归测试、文档和实现一致性检查。

快层：测试是最值得铺张浪费的环节。让 AI 把验证铺到前所未有的密度。
慢层：测试的核心不是让灯都变绿，而是建立一种你真正愿意相信的确定性。判断“什么叫够了”，只有人能做。

上线阶段。 所有哲学都会在这里显形。到了这里，事情不再只是代码质量，而是“谁来承担结果”。

快层：AI 生成影响范围图、发布清单、回滚方案、监控建议。做上线前的红队审查：最坏会出什么事故？最先看哪几个指标？哪种情况必须回滚？
慢层：最后那个 go/no-go 的决定——谁来盯盘、出了问题是回滚还是热修、灰度策略怎么定——这些事情没有任何模型能替你承担。AI 只能给建议，发令权必须在你。

主权：慢层中最慢的那一层

在速度分层模型里，最慢的那一层定义了整个系统的身份。场地（site）定义了一栋建筑是什么。文化定义了一个文明是什么。

在智能丰裕的时代，一个人最慢、最不该轻易变动的那一层是什么？

是主权。

主权不是凡事都自己做。而是你有能力、也有意识地决定什么交出去、什么必须自己来——而且这个决定是清醒的，不是顺着便利性滑过去的。

四样东西必须留在这一层：

目标定义权。 这件事为什么值得做？做到什么边界算完成？什么明确不做？AI 可以帮你分析，但不能替你定义目的。

价值排序权。 速度和质量怎么平衡？短期收益和长期债务怎么权衡？哪类风险不能接受？这些本质上都是“你愿意为哪种结果负责”的问题。

关键判断拍板权。 尤其在高爆炸半径的环节——权限模型、金额逻辑、状态机、不可逆迁移、上线回滚。可以让模型给一百条建议，但“就这么做”必须由你亲自说出来，而且你知道为什么。一个有效的实践原则是：可逆的事交给 AI 多试，不可逆的事由人来定。

后果承担权。 出了事谁解释？谁复盘？谁背结果？谁决定下次怎么防止？AI 可以分析，但不能替你承担后果。凡是最终回到责任结构上的事情，都必须有人在场。

这四样东西一旦也交出去，你获得的可能是一个极高效的流程，但你已经不再是自己工作和人生的主人了。在速度分层的框架里说，你把最慢层也交给了快层来决定——这是系统崩溃的前兆。

在丰裕中训练收束力

过去很多年，我们训练自己的方式是匮乏时代的训练——学会记忆、计算、搜索、组织材料，因为资源有限，外援很少，智能昂贵。

现在世界开始翻转。智能供给越来越多，建议越来越多，草稿越来越多，路径越来越多。快层在以前所未有的速度运转。这个时候，真正稀缺的能力变成了另一种东西：

你能不能在很多建议里形成自己的标准？
你能不能在很多草稿里做出真正属于你的终稿？
你能不能在很多路径里选一条，然后长期走下去？
你能不能在很多优化机会面前知道何时该停？
你能不能在大量 AI 产出面前，不让自己的判断肌肉萎缩？

未来一个人最重要的能力，不是生产力，而是收束力。不是谁能调更多模型，不是谁能让系统生成更多东西，而是谁能在海量可能性面前仍然保持方向感。

这个方向感不是 AI 给你的。它是你通过长期的价值排序、风险承担、实践复盘和自我诚实，一点一点长出来的。

这也解释了为什么“自己安静想一想”在 AI 时代反而更重要了。AI 太会给答案了。你很容易在还没真正形成自己理解的时候，就满意于一个表达漂亮的外部答案。你以为自己想通了，实际上只是借用了一个看起来完整的结论。所以你至少要给自己保留一些不靠 AI 的思考时间：自己写一版判断，自己做一版复盘，自己走完最后一公里的表达。

这不是反技术。这是给慢层留出它自身的运转空间。快层运转得越快，慢层的独立性就越重要。一栋建筑的家具可以天天换，但结构不能跟着家具的节奏走——否则整栋楼会塌。

七条长期原则：写给十年后的自己

如果把上面所有讨论压缩成可操作的原则，以下七条是我认为在十年尺度上仍然成立的：

一、AI 是廉价的可能性，人是昂贵的承诺。 快层生成选项，慢层做出选择。不要混淆这两种功能。

二、可逆的事交给 AI，不可逆的事由人来定。 可逆性是判断一件事该放在哪个层次的最可靠指标。

三、便宜模型铺量，强模型深判，自己裁决。 三个层次，三种功能，不可互相替代。

四、不让强模型干廉价活，不让便宜模型做终审。 每个工具放到它该在的层次上。层次错位是系统效率最大的敌人。

五、消灭死摩擦，保留活摩擦。 死摩擦是快层应该消除的噪声；活摩擦是慢层不可或缺的训练。

六、未来不是更会写，而是更会让系统不容易写错。 从手工艺到控制论。质量来自验证结构，不只来自个人技艺。

七、守住主权。 这是最慢的那一层。快层运转得越快，慢层的稳定性就越关键。主权一旦丢掉，所有效率都失去了意义。

结语：长期思维下的系统演化

在长今基金会（Long Now Foundation），我们谈论的是万年尺度的思考。但长期思维的核心不是预测遥远的未来，而是理解系统演化的基本规律：什么会变，什么不会变，变化以什么速度发生，不同速度之间如何耦合。

软件工程正处在一个典型的快层剧变期。AI 带来的廉价认知正在重塑快层的一切——工具、流程、分工、生产方式。这些变化是真实的、深刻的、不可逆的。

但慢层的规律没有变。目标定义、价值排序、后果承担、承诺——这些属于人类智能中最慢、最深的那一层。它们不会因为快层的加速而变得不重要，恰恰相反，快层越快，慢层的锚定作用就越关键。

未来不属于最会调用智能的人，而属于最会治理智能的人。

不属于最会生成内容的人，而属于最会在海量可能性面前做出承诺、把事情带入现实的人。

不属于拥有最多外部智能的人，而属于在巨大外部智能加持下，仍然没有丢掉自己中心的人。

AI 会越来越像一种基础资源——就像电力、自来水、互联网曾经变成的那样。但人必须决定，资源为什么而用。AI 越来越擅长展开世界，但人必须把世界压缩成自己愿意承担的一条路。

在智能丰裕的时代，真正的修炼不是怎样拥有更多外部智能，而是在拥有巨大外部智能之后，仍然保有自己的主权、判断和承诺能力。

一栋好的建筑，不是永远不变的建筑，而是知道哪些该变、哪些不该变的建筑。一个好的工程师也是如此。

这大概是未来很多年里，最值得反复提醒自己的一件事。

发表于 | 分类于

廉价智能的反脆弱：为什么没有 Skin in the Game 的人不配谈编程的未来

I. 一个被所有人误读的范式转移

让我先摧毁一个幻觉。

绝大多数人——包括那些在社交媒体上侃侃而谈“AI 辅助编程”的意见领袖——对当下正在发生的事情存在一种根本性的误读。他们认为我们进入了一个“AI 辅助编程时代”，就好像 AI 是一把更锋利的刀，而程序员还是那个厨师，只是切菜更快了。

不。这不是刀变锋利了。这是厨房里突然涌进来一百个厨师，每个人只收一块钱日薪，而且永远不会累。

“AI 辅助编程”这个说法暴露了使用者的脆弱：他仍然把智能看成稀缺品，看成自己手上一把金贵的瑞士军刀，小心翼翼，每次使用前都要掂量一下“值不值”。但真正发生的事情是——智能的供给结构变了。原本极其昂贵、稀缺、不可并行的认知劳动，开始变得廉价、可复制、可并发、可持续调用。

这不是效率变化。这是范式变化。两者的区别，就像“马车跑得更快”和“铁路被发明”的区别。

II. 百倍降本不是统计学事件，而是心理学事件

那些在会议上讨论“模型成本到底降了多少”的人，多半从来没有真正大量调用过模型。

我来告诉你真实发生了什么。不是某个 API 的 token 价格整齐划一地降了一百倍——那是经济学家在白板上画的曲线。真正发生的是一种体感的跃迁：你突然发现，强模型的配额用不完了；某些自动路由几乎无限；某些公司的工具让你在极低心理成本下反复调用接近顶级的能力。

价格表上降了多少不重要，你心里降了多少才重要。

当你不再犹豫“这个问题值不值得问 AI”的时候，分水岭就已经过了。

过去的心智模式是稀缺时代的产物：先自己想，实在不行再问；把 prompt 写得尽量满，争取一次命中；每次调用都当成正式消费。这就像一个中世纪农民对待蜡烛的态度——天黑了才舍得点，而且要把灯芯捻小。

但一旦电灯发明了，你还捻个什么灯芯？

丰裕时代的心智完全不同：“这个问题我为什么不先让模型跑一轮？这个边界场景能不能多生成几版？这个设计是不是应该先出三套候选方案？这个 PR 为什么不让模型从安全、并发、回滚三个视角各看一遍？”

你看到这个变化了吗？从“舍不得做”到“默认去做”。从“省着用智能”到“铺张地用智能”。

这正是我在《反脆弱》里反复论证的模式：系统层面的变革，几乎从来不是由那些在会议室里分析报告的人首先察觉的。它总是由那些有 skin in the game、天天在一线干活的人率先体感到。而那些从不自己写代码、却天天发表“AI 将如何改变编程”的专栏作家和咨询师——他们是最后一批理解这件事的人。

III. AI 是什么？不是聊天机器人。不是助手。是廉价认知能源。

把 AI 定义为“聊天机器人”的人，和把蒸汽机定义为“会冒烟的水壶”的人，犯的是同一种认知错误。

AI 的本质不是“一个聪明的对话伙伴”。AI 是一种新型生产要素——廉价、可复制、可扩展的智能。

让我把它的几个核心特征列出来，像列一份资产负债表一样清晰：

可复制。 一个人一天只有二十四小时，注意力只有一份。一个模型可以同时实例化为十个、一百个、一千个执行体。它不是“另一个人”。它是一种可以横向无限扩张的认知资源池。大多数人根本不理解“可复制”这三个字的威力——这意味着你面对的不是一个帮手，而是一支军队。

无疲劳。 人做到第九遍会烦，会敷衍，会走神。AI 不会。它没有“熬夜成本”，没有“又是这种破活”的情绪负担。它会犯错，但绝不会因为枯燥而偷工减料。那些高重复、铺量型、需要长时间巡检的任务——恰恰是人类最脆弱、AI 最反脆弱的领域。

适合展开。 AI 天生擅长一件人类极不擅长的事：把搜索空间摊开。同时提出十种设计、列出三十种边界条件、从五个角度生成风险、给出大量候选——这种“铺开可能性”的能力，是 AI 最自然的优势。而人类在面对开放空间时往往会紧张、会锚定在第一个想到的方案上。

低试错代价。 这一条至关重要。AI 可以错，可以重来，可以在另一个线程再试一次。它不会因为一次判断失误损失职业机会，不会因为一次错误发布而失眠三夜。正因为如此，它天然适合探索——但也正因为如此，它天然不适合做最终承诺。

把这些特征综合起来，你得到一个清晰的画面：AI 最擅长的不是替你“活”，而是替你大规模地展开世界。 它是认知世界的廉价能源。不是单次神来之笔，而是大规模、低边际成本地执行无数你过去舍不得做的认知动作。

和工业革命的类比不是修辞。它是结构性同构。蒸汽、电力、石油的意义不是“马车跑得快一点”，而是让整套工业组织逻辑发生变化。以前很多事之所以不做，不是因为做不到，而是因为太贵。质量检查太贵，冗余设计太贵，广泛试错太贵。可一旦能源变廉价，“做出来”就不再是重点，“怎么更大规模、更稳定、更标准地做出来”才是。

AI 对认知世界做的，和蒸汽机对物理世界做的，是完全相同的事。

IV. 人类智能不是“贵一点的 AI”——这是一种危险的范畴错误

现在让我来摧毁另一个流行但脆弱的观点。

很多人——尤其是那些喜欢画“AI 能力曲线”的咨询师和分析师——把人类和 AI 放在同一个刻度尺上。在他们的幻灯片里，AI 是低配版的人，人是高配版的 AI。AI 便宜但笨，人贵但聪明。所以问题就变成了“AI 什么时候聪明到能替代人”。

这是一种范畴错误，和把鱼和鸟放在“移动速度”同一个刻度上比较一样荒唐。

AI 智能和人类智能不是一个连续刻度上的高低之分。它们是两种性质完全不同的存在。

AI 智能：可复制、可并发、无疲劳、低单次代价。
人类智能：具身的、有限的、带有生命时间的、会承担后果的。

关键区别不在于谁更聪明。关键区别在于——谁有 skin in the game。

AI 可以给你十个方案，每个看起来都头头是道。但它不需要为其中任何一个承担后果。它不会因为选错方案而丢掉工作，不会因为上线事故而失眠，不会因为一个糟糕的架构决定而在接下来三年里天天给自己擦屁股。

人不一样。人的每一个决定都绑着代价——名誉、关系、职业路径、情绪后果、责任结构、不可逆的生命时间。你做出的决定不是悬浮在空中的，它会回到你自己身上。你要解释、要承担、要复盘、要消化、要承受损失。

这使得人类智能天然带着一种 AI 永远不会拥有的东西：重量。

我在《Skin in the Game》里论证过一个核心论点：没有承担后果的人，他的判断天然不可信。不是因为他不够聪明，而是因为没有代价的判断会系统性地偏向那些“听起来漂亮但不用承受爆炸后果”的方向。AI 恰恰就处在这个位置——它永远不需要承受爆炸后果。

所以，人类真正稀缺的部分，不是算力，不是记忆，不是文字组织能力。是以下这些东西：

你到底想成为什么样的人。
你觉得什么值得，什么不值得。
你愿意为了什么承受痛苦。
你在众多路径里最终选择了哪一条。
你愿意为哪一种结果负责。

人的有限性不是缺陷。恰恰因为人不能同时活一万种人生，选择才有分量。恰恰因为一个人不能无限复制自己，承诺才有重量。恰恰因为生命时间有限，注意力才成为最贵的货币。

有限性是承诺的前提条件。 一个可以永远重来的存在，它的“选择”根本不是选择。

V. 扩张与压缩：人机分工的哲学公式

如果要我把人和 AI 的分工压成一个公式，我会这样写：

AI 负责扩张可能性，人负责把可能性压缩成命运。

这不是一个口号。这是一个具有操作性的哲学原则。

“扩张”意味着什么？让模型帮你看十种方案、二十种边界条件、三十种失败模式、五十种重构路径。从多视角读需求，从多角色审设计，从多种假设定位 bug，从大量组合里生成测试。AI 天生就是发散引擎。

“压缩”意味着什么？你要在这些可能性里决定什么值得进入现实，什么应该被过滤掉，什么虽然可行但不符合你的价值排序，什么虽然漂亮但不值得当前组织代价，什么虽然技术上正确却不适合当下阶段。

注意：这不是“AI 做简单的，人做难的”。这种划分愚蠢透顶。今天看起来复杂的事，明天可能被 AI 做得行云流水。但有一类事情始终天然更接近人：定义目标、排序价值、做出取舍、承担后果。 这些事情不是因为计算难度大才留给人，而是因为它们和“谁来负责、谁来承受、谁来把这件事纳入自己的人生叙事”有关。

用另一种方式表达：

AI 更接近“丰裕函数”——适合处理那些“越多越好”的事情：搜索、穷举、对比、批量生成、巡检、回归、补文档、模拟失败、提出异议、长期监控。

人更接近“稀缺函数”——适合处理那些必须由有限存在亲自完成的事情：定义目的、取舍边界、承担代价、下最终判断、决定何时停止、决定什么不能牺牲。

好的分工哲学不是“AI 替人做人类做不了的事”。好的分工哲学是：

让 AI 负责那些适合被无限放大的部分，让人负责那些必须由有限生命来承担的部分。

搞反了，你就完蛋了。让有限生命去干无限量的活，人会崩溃。让无 stake 的系统去做有 stake 的决定，系统会崩溃。

VI. 死摩擦与活摩擦：区分不了这两种痛苦的人，不配谈效率

现在让我引入一个极其重要的区分，一个我发现绝大多数技术管理者和效率狂人完全无法理解的区分：

死摩擦和活摩擦。

那些在推特上鼓吹“AI 将消灭一切低效”的人，犯了一个经典的医源性错误——他们假设所有痛苦都是病，所以一切痛苦都该被治疗。这就像那些把所有波动都当成风险、然后试图消灭一切波动的基金经理一样愚蠢。有些波动是噪音，有些波动是信号。有些痛苦只是在消耗你的生命，有些痛苦却是在塑造你。

死摩擦，是那些不会让你成长、只会耗尽你注意力的部分。大量样板代码。机械性的格式整理。重复搜索。低价值信息提纯。批量改名。重复性的注释补全。搭测试骨架。翻十几个文件只为确认一个简单关系。把一大堆 diff 整理成描述。这些事情需要被正确完成，但它们本身不构成你的训练。AI 越能把这些消灭掉，你越该高兴。因为这类劳动只是在烧你有限的生命。

活摩擦，是那些虽然痛苦、混乱、耗时，但构成你判断力和边界感形成过程的部分。你到底如何定义“质量够了”？你愿意接受怎样的风险？你如何权衡长期设计与短期交付？你在面对不完整信息时如何形成判断？你如何面对自己的保守、虚荣、焦虑和侥幸心理？你如何把一团混乱真正压缩成自己的观点？

这些摩擦看起来“效率低”。但效率低恰恰是重点——就像举重看起来“效率低”（你可以用叉车搬同样的重量），但那种低效正是肌肉生长的条件。

你外包了死摩擦，省下的是时间。你外包了活摩擦，省掉的是成长本身。

这个区分在软件工程中极其实用：

批量生成 DTO、扫调用链、整理变更说明、补测试骨架——死摩擦，尽管外包。
设计取舍、风险定义、抽象边界、上线标准、关键逻辑是否可信——活摩擦，必须亲自穿过。

不能区分这两者的人，要么会变成什么都不愿意交出去的卢德分子，要么会变成什么都外包出去的空壳。两者都是脆弱的。

VII. 软件工程的底层逻辑正在翻转

一旦 AI 变成廉价可扩展的智能，软件工程最深的变化，不是“写代码更快了”——说这种话的人暴露了他从未认真思考过工程的本质。

真正的变化是：“写代码”这件事本身不再构成主要瓶颈。

这就像印刷术发明之后，“抄写”不再是知识传播的瓶颈一样。瓶颈转移了。转移到了哪里？

需求有没有被定义清楚。
设计有没有被比较和证伪。
实现有没有被验证。
测试有没有杀伤力。
上线有没有可控性。
事故经验有没有真正沉淀成未来约束。

换句话说：“写出来”越来越不值钱，“证明它值得信”越来越值钱。

这是一个范式级别的翻转。过去的程序员像手工匠人——想清楚、写出来、调通、提交。未来的开发者更像控制系统设计师——设目标、放出候选方案、建测试网、做对抗审查、根据反馈修正、不断让系统收敛到一个足够可信的状态。

工程质量的来源，将越来越不是单次聪明，而是多轮冗余验证。

过去高质量依赖什么？依赖一个经验丰富的人“看一眼就知道哪里不对”。这种能力当然珍贵——我不否认直觉的价值，但我极度怀疑那些把整个系统可靠性押注在单一个体直觉上的组织。这和把你的退休金全部押在一只股票上没有本质区别。

未来更稳定、更反脆弱的路线，是建立系统化的验证结构：多方案竞争、独立实现、差分测试、红队 review、回归回放、文档与实现一致性检查、事故场景预演、变更影响分析。

当智能稀缺时，你做不起这些。
当智能丰裕时，你没有理由不做这些。

不做的人，就是在拿系统的命运赌博——而且赌的不是自己的钱。

所以，如果一定要概括未来软件工程的核心变化：

不是让一个程序员更像超人。而是让每一行代码都被一群廉价但强大的智能体反复挑战、验证、解释和重放。

从手工艺到控制论。从个体英雄到系统韧性。从“写得漂亮”到“证明它不容易出错”。

VIII. 便宜模型和昂贵模型：不是谁替代谁，而是谁该被部署在哪个战场

很多讨论陷入了一个我见过无数次的低层次陷阱：“到底哪个模型最好用？”

这个问题本身就暴露了提问者的无知——就像问“锤子好用还是螺丝刀好用”一样。答案取决于你到底要干什么。

不同模型应该扮演不同工种，而不是互相替代。

便宜模型的价值在于铺量。它的单次判断未必最准，但可以大量调用。拉全局地图，列风险清单，扫仓库、扫 diff、扫测试缺口，补文档，生成骨架，扩大边界集合，做第一轮分类。它的优势不是“最对”，而是“最广”。它像一支侦察部队——你派出去不是为了让它打赢仗，而是让它帮你看清战场全貌。

昂贵模型的价值在于压缩不确定性。它应该只在高风险环节出手：架构方案仲裁、事务边界、一致性语义、幂等设计、权限风险、状态机闭合性、疑难 bug 根因分析、上线前红队审查。它的优势不是铺量，而是在高风险赌注上少犯错。

我极其反对两种浪费——它们本质上都是 skin in the game 缺失的症状：

第一种浪费：让强模型去干廉价活。 用最贵的智能去扫文件、补样板、写机械注释。这就像请一个顶级外科医生去帮你量体温。你不是在“充分利用资源”，你是在浪费最稀缺的上下文窗口和最高质量的注意力。干这种事的人，多半是那种“反正公司出钱”的心态——典型的无 skin in the game 行为。

第二种浪费：让便宜模型直接终审。 便宜模型适合大规模探索，但不适合在没有更高层裁决的情况下直接定义高风险正确性。让侦察兵直接拍板战略决策，你就等着把大量“看起来有道理”的半成品带进主干吧。这和让实习生签合同、让见习医生主刀的风险是同一种。

所以，好的分工原则极其简洁：

便宜模型负责多做，强模型负责少错。

这句话不只适用于工具之间。它同样适用于 AI 与人之间——AI 负责多做，人负责少错。

IX. 具体工具不是“谁更聪明”的比赛，而是“谁该在什么位置上场”

让我把话说得更具体一些。如果你手上的几个工具是不同工种而不是几个聊天框，你的整个工作流会立刻清晰得多。

Cursor Auto 最适合扮演的角色是廉价认知劳动力池。读代码做全局摘要，拉调用链，列出相关类、接口、表、配置，找到类似实现，批量生成测试点，批量补文档，补样板代码，做初步风险扫描。它不是“低配强模型”。它是“无限实习生军团”。你对实习生的期望不是“一次做对”，而是“帮我把信息铺开”。

Opus 更像首席架构师兼首席检察官。它不应该天天去写普通胶水代码——那是暴殄天物。它应该只在高风险环节出手：含糊需求的边界澄清，设计里的事务与幂等审查，状态机和权限模型分析，金额与账务逻辑核查，疑难 bug 根因分析，上线前红队 review。它不是高价打字员。它是高风险仲裁者。把仲裁者派去打字，是组织层面的渎职。

Codex 最适合做并行执行中心。多个 worktree、多个任务线程并行推进：一边做主功能，一边做测试与 fixture，一边做文档与发布清单，一边做小规模 spike 或回归巡检。它的价值不在于“比别人更会答题”，而在于“更像一个并行施工现场”。

Kiro 更像规格化与约束中枢。承载需求规格、设计文档、任务拆分、项目 steering、长期约束沉淀。它是“把临时对话变成可持续项目记忆”的地方。

一旦你接受了“它们是不同工种”的框架，就不会再浪费时间去争论“谁更聪明”这种毫无意义的问题。

真正的问题永远是：谁该在什么时候上场？

X. 五个阶段，五种分工——没有一个环节可以偷懒

把整个开发过程拆成需求、设计、实现、测试、上线五个阶段。在智能丰裕时代，每个阶段都必须被重新组织。那些还在用稀缺时代思维组织工作流的人，就像拿着蜡烛走在已经通电的大楼里——不是不能用，而是蠢。

需求阶段：先拨雾，再冻结

需求阶段最致命的问题从来不是“没想法”，而是所有人以为自己理解一致——实际上理解完全不一致。我见过无数线上事故，根因不是代码写错了，而是需求本身就有模糊地带。成功到底怎么定义？失败怎么回滚？重试算不算新请求？部分成功部分失败怎么办？权限的边界在哪里？

在智能丰裕时代，便宜模型在这个阶段最该做的不是急着给方案，而是帮你把迷雾拨开。读现有代码，拉调用链，列出所有你没想到的歧义点和失败场景。强模型则该扮演挑刺者：这个词定义清楚了吗？这个边界会不会炸？这个场景出了错解释成本有多高？

而你——有 skin in the game 的那个人——必须裁决：这次到底做不做？做到哪里？哪些明确不做？验收标准是什么？哪些风险不能接受？

人定义业务真相，AI 只是帮你把真相周围的迷雾拨开。 把这个关系搞反的人，最终会发现自己在执行一个 AI 定义的需求——而 AI 不需要为这个需求的后果负任何责任。

设计阶段：不写一版，先比较多版

设计阶段最大的陷阱是追求“一个看起来完整的方案”。这种追求本质上是一种脆弱性——你把所有赌注押在了一个方案上，而且你甚至没有看过替代方案长什么样。

智能丰裕时代的正确做法是：默认生成多个互相竞争的设计。 最小改动版、最可测试版、最长期可维护版、最强调回滚版。让不同方案各自暴露代价，然后你再选。

这就是凸性策略——你把下行风险分散到多个方案中，同时保留了看到更好方案的上行空间。只看一个方案的人，不知道自己错过了什么。

设计阶段重要的不是“更漂亮”，而是“更可收敛”。

实现阶段：把 AI 当成生产线，不是当成一个写手

实现阶段最常见的浪费是让强模型干廉价活。绝大多数低风险、高重复的实现工作——DTO、VO、controller 骨架、参数校验、注释、文档——都应该下放给便宜模型。强模型只在少数关键点出手：金额计算、状态转换、权限校验、幂等逻辑、事务和锁。

而你在实现阶段的角色不是生产者，是收敛者。你要防止系统发散——判断某个抽象是不是过头了，某个 diff 是不是需要逐行审，某次小重构会不会稀释主线。

测试阶段：这里最值得铺张浪费

测试阶段可能是智能丰裕时代变化最大的环节。过去很多团队测试做得薄，不是因为不知道测试重要，而是因为做不起。

现在你做得起了。

边界矩阵、权限矩阵、状态转移矩阵、异常路径集合、回归测试、文档和实现一致性检查——大量便宜智能意味着你终于可以默认去做那些原本觉得太奢侈的验证动作。

测试阶段的核心不是让灯都变绿。而是建立一种你真正愿意相信的确定性。

那些因为“测试太费时间”而跳过系统测试的人，和那些因为“体检太费时间”而从不体检的人，最终的结局是一样的。

上线阶段：AI 当参谋，发令权在你

上线阶段是所有哲学都会显形的地方。因为到了这里，事情不再只是代码质量，而是“谁来承担结果”。

AI 可以帮你生成影响范围图、发布清单、回滚方案、监控建议。它可以做上线前的红队审查：最坏会出什么事故？最先看哪几个指标？哪种情况必须回滚？

但最后那个 go/no-go 的决定——谁来盯盘、出了问题是回滚还是热修、灰度策略怎么定——这些事情没有任何模型能替你承担。

AI 只能给建议。发令权必须在你。因为后果在你。

这就是 skin in the game 原则在工程中的终极体现：谁承担爆炸后果，谁拥有发令权。把发令权交给不承担后果的系统，是一种结构性的不道德——和让没有 skin in the game 的分析师替你做投资决策一样危险。

XI. 主权：真正必须保留的不是工作量，而是决定权

到这里，最底层的问题浮出水面了。

在智能越来越丰裕的时代，一个人到底该保留什么？

不是工作量。而是主权。

什么是主权？不是凡事都自己做。而是你有能力、也有意识地决定什么交出去、什么必须自己来——而且这个决定是清醒的，不是顺着便利性无意识滑过去的。

具体来说，至少四样东西必须留在自己手里：

第一，目标定义权。 这件事为什么值得做？做到什么边界算完成？什么明确不做？这些不是 AI 帮你定义的。让 AI 定义你的目标，就像让赌场帮你设定止损线一样荒谬。

第二，价值排序权。 速度和质量怎么平衡？短期收益和长期债务怎么权衡？哪类风险不能接受？这些本质上都是“你愿意为哪种结果负责”的问题。AI 可以列出所有选项，但排序必须由你来做——因为只有你需要活在排序的后果里。

第三，关键判断拍板权。 尤其在高爆炸半径的环节——权限模型、金额逻辑、状态机、不可逆迁移、上线回滚。可以让模型给你一百条建议，但“就这么做”必须由你亲自说出来，而且你知道为什么。不知道为什么就拍板的人，不是在做决策，是在掷骰子——而且用的是别人的骰子。

第四，后果承担权。 出了事谁解释？谁复盘？谁背结果？谁决定下次怎么防止？AI 可以分析，但不能替你承担后果。凡是最终回到责任结构上的事情，都必须有人在场——一个真实的、有名有姓、承受结果的人。

这四样东西一旦也交出去了，你获得的可能是一个极高效的流程，但你可能已经不再是自己工作和人生的主人了。

效率的奴隶仍然是奴隶。

XII. 丰裕时代最重要的训练不是“更会用工具”，而是“更会在丰裕中收束”

过去很多年，我们训练自己的方式，本质上都是匮乏时代的训练。学会记忆，学会计算，学会搜索，学会组织材料——因为资源有限，外援很少，智能昂贵。在匮乏时代，“多做一点就赢了”。

但现在世界翻转了。

智能供给越来越多。建议越来越多。草稿越来越多。路径越来越多。方案越来越多。可能性越来越多。

在丰裕时代，“多做一点”已经不构成优势了。谁都能多做一点——你只要多调几次模型就行。

真正稀缺的能力变成了另一种东西——收束力。

你能不能在很多建议里形成自己的标准？
你能不能在很多草稿里做出真正属于你的终稿？
你能不能在很多路径里选一条，然后长期走下去？
你能不能在很多优化机会面前知道何时该停？
你能不能在大量 AI 产出面前，不让自己的判断肌肉萎缩？

这是一种全新的训练。不是匮乏时代那种靠“多做”取胜的训练，而是丰裕时代的训练——靠少迷失、少发散、少把主权外包来取胜。

这也解释了为什么“自己安静想一想”在 AI 时代反而更重要了。AI 太会给答案了。你很容易在还没真正形成自己理解的时候，就满意于一个表达很漂亮的外部答案。你以为自己想通了，实际上只是借用了一个看起来完整的结论——就像那些从来不自己做分析、只看投行研报就做交易的基金经理。他们不知道自己不知道什么。

所以你至少要给自己保留一些不靠 AI 的思考时间：自己写一版判断，自己做一版复盘，自己走完最后一公里的表达。不是反技术。是给自己的认知肌肉留训练场。

不训练的肌肉会萎缩。认知肌肉也不例外。

XIII. 写给自己的几条长期戒律

以下是我给自己定的规则。不是给别人看的。是给自己在丰裕时代保持清醒用的。

一、AI 是廉价的可能性，人是昂贵的承诺。 可逆的事让 AI 多试，不可逆的事由人来定。

二、便宜模型负责多做，强模型负责少错，你负责裁决。 混淆这三者角色的人，要么浪费资源，要么制造灾难。

三、该被 AI 消灭的是死摩擦，不该被外包的是活摩擦。 分不清这两者的人，不是变成卢德分子就是变成空壳。

四、“写出来”越来越不值钱，“证明它值得信”越来越值钱。 能写的人到处都是。能证明的人才是稀缺品。

五、在所有高风险环节，坚持 skin in the game 原则。 不承担后果的人不应该拥有决策权。不承担后果的系统不应该拥有终审权。

六、保持独立思考的训练。 每天给自己留出不靠 AI 的思考时间。像运动员保持体能训练一样保持认知训练。肌肉不用会萎缩，判断力也一样。

七、在丰裕面前保持清醒。 最危险的不是拥有太少，而是拥有太多却失去了方向感。

XIV. 结语：治理智能的人，而非调用智能的人

让我用一个概率论的类比来结束这篇文章。

在赌场里，最危险的时刻不是你输钱的时候，而是你赢了很多、以为自己找到了“必胜公式”的时候。因为那个时刻你最可能加大赌注、放松警惕、把 skin in the game 的本能覆盖掉。

智能丰裕的时代就像一个突然开始不断“赢钱”的赌局。模型越来越强，产出越来越多，效率越来越高——你会觉得一切都在变好。但恰恰在这个时刻，你最容易犯一个致命错误：把主权交出去。

未来不属于最会调用智能的人。未来属于最会治理智能的人。

不属于最会生成内容的人，而属于最会在海量可能性面前做出承诺、把事情带入现实的人。不属于拥有最多外部智能的人，而属于在巨大外部智能加持下，仍然没有丢掉自己中心的人。

AI 会越来越像一种基础资源——像水、像电、像石油。但资源本身不会告诉你它该为什么而用。人必须决定这一点。

AI 越来越擅长展开世界。但人必须把世界压缩成自己愿意承担的一条路。

在智能丰裕的时代，真正的修炼不是如何拥有更多外部智能，而是在拥有巨大外部智能之后，仍然保有自己的主权、判断和承诺能力。

这大概就是反脆弱的终极形态：不是抵制变化，不是拥抱一切变化，而是在变化中保持那些不能被变化夺走的东西——你的判断，你的承诺，你的 stake。

其余的，让廉价智能去铺就好了。

发表于 | 分类于

当认知变得廉价，什么变得昂贵：智能丰裕时代的编程法则

大多数程序员以为 AI 编程的变革是速度——原来写一个函数要二十分钟，现在两分钟。这就像以为工业革命的意义是让马跑得更快。

但真实情况恰好相反。真正发生的变化不在速度，而在经济结构。

我来给这个变化一个精确的定义。我们进入的不是“AI 辅助编程时代”，而是“可扩展智能大量涌入软件生产过程的时代”。这两句话看上去很像，其实差了一个世界。前者意味着 AI 仍然是配角，人类流程不变，只是快了一点。后者意味着——原来极其昂贵、稀缺、不可并行的认知劳动，突然变得便宜、可复制、可并发、可持续调用。这不是效率变化，这是范式变化。

这篇文章想讨论的，就是这个范式变化带来的一系列连锁反应。当一种新的智能供给开始变得丰裕，哪些东西会贬值，哪些东西会被重新照亮——我认为这是每个做软件的人现在都应该认真想一想的问题。

一、主观百倍降本：从昂贵顾问到自来水

大多数人以为，技术成本下降是一个会计问题——账面价格降了多少，预算能省多少。但真正改变行为的，从来不是账面价格，而是心理价格。

经济学家有一个概念叫“心理账户”。丹尼尔·卡尼曼在《思考，快与慢》里讲过一个经典实验：同样是丢了十美元，人们对“丢了一张电影票”和“丢了一张十美元钞票”的反应完全不同。价格一样，但心理核算方式不同，行为就不同。

AI 调用成本的变化，正是这种心理账户的翻转。

半年前，我使用强模型的方式像在跟一个按小时收费的顶级律师谈话。每次提问之前都要精心组织 prompt，生怕浪费了一次调用。我会先自己想十分钟，实在想不通了，才“正式”问一次。心态是：“这个问题值不值得动用 AI？”

然后有一天，我发现几个平台的强模型配额怎么都用不完。有的工具甚至允许你在极低的心理成本下持续调用接近顶级的能力。我的心态悄悄变了：“这个问题我为什么不先让 AI 看一眼？”

这个变化的数字可能没有那么戏剧性——底层 token 定价不一定真的整齐划一降了一百倍。但在主观体验上，变化是百倍级的。因为当你不再犹豫“要不要调一次模型”的时候，工作流就被改写了。你不再是先自己想半天、实在想不通再去问，而是默认先让模型跑一轮、出三个方案、然后从中选一个。你开始把模型当成自来水——拧开就用，想用就用。

这就引出了一个关键的类比。

蒸汽机对体力劳动做的事情，AI 正在对认知劳动做。蒸汽机的意义不是让马车跑得更快——它的意义是让能源便宜到一个程度，使得整个生产组织方式必须重新设计。以前太贵所以不做的事——冗余设计、质量检查、大规模试错——突然之间都可以做了。不是因为人变聪明了，而是因为能源变便宜了。

同样的逻辑，以前让人反复审查一段代码、从十个角度分析一个设计、把每个边界条件都想一遍、写完代码再从安全和并发的角度各检查一遍——这些认知动作不是不知道应该做，而是做不起。一个人一天就那么多小时，注意力就那么多，脑子会累，情绪会烦。现在，这些动作的边际成本正在迅速下降。

所以这件事的 takeaway 是：我们面对的核心问题，已经不是“AI 太贵能不能少用点”，而是“AI 已经不再稀缺，整个工作方式该怎么重新设计”。从“如何多写代码”，转向“如何购买确定性”。

二、AI 的本质：不是聪明助手，而是廉价认知能源

大多数人对 AI 的定位是“一个聪明的助手”。这个定位太窄了，窄到会误导你的整个工作方式。

我来给 AI 一个更精确的定义。把 AI 往抽象了看，它本质上是一种新型认知生产要素。它最核心的特征不是“聪明”——聪明只是附带属性——而是四个更底层的特征。

第一，可复制。 一个人一天只有二十四小时，注意力只有一份，做完 A 才能做 B。但 AI 天然就是并行的。你可以同时让十个实例跑十个不同的任务。人类的认知资源池是固定大小的水缸，AI 的认知资源池更像自来水管网——你可以横向无限接水龙头。

第二，持续运转。 一个人做到第九遍会烦，会走神，会偷工减料。心理学研究表明，人的决策质量在连续工作四小时后显著下降——法官在午饭前批准假释的概率会从65%暴跌到接近0%。AI 不存在这个问题。它不会因为重复就变得敷衍，不会因为疲劳就降低标准。这让它特别适合那些高重复、需要铺量、需要长时间巡检的工作。

第三，适合搜索展开。 AI 可以在极短时间内把一个问题的可能性空间铺开。让它同时给你五种设计方案、列出二十个边界条件、生成三十个测试用例——这类“把模糊问题的搜索空间摊开”的活，恰好是它的强项。

第四，单次错误无生命代价。 一个人犯了重大错误，职业轨迹可能就拐弯了。AI 犯了错，你让它重来就行，试错成本几乎为零。所以它天然适合探索，适合试错，适合大规模地跑那些“万一行呢”的方案。

把这四个特征加在一起，结论就很清楚了。AI 最擅长的事情不是“替你写代码”——那是一种过于狭隘的理解——而是替你把世界摊开来看。它是认知世界里的廉价能源：不是靠单次的神来之笔取胜，而是靠大规模、低成本地执行那些以前你舍不得做的认知动作。

所以这件事的 takeaway 是：不要把 AI 当作一个更快的你，要把它当作一种可以大量廉价调用的认知基础设施。这个定位的差异，会决定你后续所有的用法。

三、人类智能：一种完全不同性质的存在

这里有一个很多人搞错的关键区分。

大多数人习惯性地把 AI 和人类放在同一把尺子上比较：AI 是低配版的人，人是高配版的 AI。AI 笨一点但便宜，人聪明一点但贵。于是问题就变成了“AI 什么时候聪明到能替代人”。

这个理解是错的。错在把两种性质完全不同的东西当成了同一种东西的高低配版。

这件事的本质其实是：AI 和人类的区别不在于谁更聪明，而在于谁有 stake。

什么是 stake？让我用一个具体场景来说明。

假设你让 AI 给你出十个架构方案，每个看起来都挺有道理。AI 可以毫无压力地生成这十个方案，因为它不需要为其中任何一个承担后果。它不会因为选错方案而丢工作，不会因为上线出了事故而凌晨三点被电话叫醒，不会因为一个糟糕的架构决定而在未来三年里天天给自己擦屁股。

人完全不一样。人的每一个重要决定都绑定着实实在在的代价——名誉、时间、关系、职业路径、情绪后果、责任结构、不可逆的生命时间。你做的决定不是悬浮在空中的逻辑推演，它会落地，会回到你自己身上。你得向团队解释，得自己承担后果，得在事后复盘时面对自己。

AI 有推理能力，但没有真正的 stakes。它可以给你十个答案，但它不需要选一个然后活在那个选择的结果里。

而人类真正稀缺的东西——如果你仔细想——不是算力，不是记忆容量，不是搜索速度。是这些：你想成为什么样的人？你觉得什么值得、什么不值得？你愿意为什么承受痛苦？你在一堆路径里为什么选了这一条？你准备为哪种结果负责？

这些问题没有“正确答案”。它们需要一个有限的、会死的、不能同时活一万种人生的存在来回答。恰恰因为你不能无限复制自己，你的选择才有分量。恰恰因为你的时间有限，你的承诺才有重量。

人的有限性不是缺陷，它是承诺的前提。

所以这件事的 takeaway 是：不要在“谁更聪明”的维度上比较 AI 和人类，这个比较没有意义。关键区分是——AI 有推理但没有 stakes，人类有限但正因为有限才能做出有分量的承诺。

四、扩张与压缩：一个精确的分工框架

如果要我用一个公式概括人和 AI 的分工，我会这样说：

AI 是丰裕函数，人是稀缺函数。

这里需要解释一下“丰裕函数”和“稀缺函数”分别是什么。

AI 适合做的事情，有一个共同特征：它们越多越好，而且多了不会出问题。搜索、穷举、对比、批量生成、巡检、回归测试——这些活动天然适合无限放大。让 AI 从十个角度读需求、从五个角色审设计、从大量组合里生成测试用例、同时生成三种实现方案让你比较——这就是丰裕函数在工作。AI 的价值在于把一个模糊问题的可能性空间铺开，让你看到更多原本看不到的东西。

人适合做的事情，恰好相反——它们必须少，必须收敛，必须由一个特定的、要承担后果的人来执行。定义目的、划定取舍边界、承担代价、做最终判断、决定何时停止。这些动作不是因为计算复杂才留给人——今天看起来很难的计算，明天 AI 可能做得比你好——而是因为它们和“谁来负责、谁来承受、谁要把这件事纳入自己的人生”有关。

用一个日常生活的类比：AI 像一个旅行社，可以帮你生成一百条旅行路线，每条都标好了景点、费用和时间。但最终你只能走一条。选哪条、为什么选这条、愿意为这条路线的遗憾负责——这是你的事。旅行社可以无限扩张选项，但你的假期只有七天。

所以正确的分工是：让 AI 负责适合无限放大的部分——搜索、穷举、对比、生成、巡检；让人负责必须由有限生命承担的部分——定义目标、排序价值、做出取舍、承担后果、决定何时停止。

AI 负责扩张可能性，人负责把可能性压缩成命运。

所以这件事的 takeaway 是：不要按“简单的给 AI，难的自己做”来分工。要按“适合发散的给 AI，必须收敛的自己做”来分工。这个区分比难度区分精确得多。

五、死摩擦与活摩擦：一个被忽视的关键区分

接下来要讲一个非常实用但很少有人讲清楚的概念。

大多数人对 AI 的期待是“帮我减少痛苦”。这个期待本身没问题，但它隐含了一个危险的假设——所有的痛苦都是坏的，都应该被消除。

事实恰好相反。有些痛苦只是在浪费你的生命，但有些痛苦却是在塑造你。我把前者叫做死摩擦，后者叫做活摩擦。

死摩擦是什么？就是那些不会让你成长、只会消耗注意力的工作。写大量样板代码、机械性地整理格式、反复搜索同一类信息、批量改名、补充重复性注释、搭测试骨架、翻十几个文件只为确认一个简单的调用关系。这些事情当然需要被正确完成，但它们本身不会让你变得更好。就好比你每天花两个小时在通勤路上——这段时间必须花，但它不会让你成为更好的工程师。AI 越能消灭这类摩擦，你就越应该高兴。

活摩擦则完全不同。比如你纠结“这个设计到底够不够好”的那种折磨，你权衡“长期架构和短期交付到底怎么平衡”的那种痛苦，你面对不完整信息必须做判断时的那种焦虑，你检视自己是不是因为懒惰或虚荣而做出某个决定时的那种不舒服。这些摩擦看起来效率很低，但它们是你的判断力、边界感和风险直觉生长的土壤。

安德斯·艾利克森（Anders Ericsson）在“刻意练习”理论中有一个核心发现：真正让人成长的，不是舒适的重复，而是在能力边缘的挣扎。死摩擦是舒适区里的无意义重复，活摩擦才是能力边缘的有效挣扎。

落到具体工作里，这个区分特别实用。

死摩擦（放心交给 AI）：批量生成 DTO、扫调用链、整理变更说明、补测试骨架、格式化代码、生成文档模板。

活摩擦（必须自己穿过去）：设计取舍、风险定义、抽象边界的划定、上线标准的制定、关键逻辑是否可信的判断。

所以这件事的 takeaway 是：AI 最有价值的用法不是帮你消灭一切不舒服，而是帮你拿走没有成长价值的痛苦，把真正塑造你的痛苦保留下来。区分死摩擦和活摩擦，是用好 AI 的第一个基本功。

六、从手艺人到控制系统设计师

这一节讲的是一个更深层的范式迁移，很多程序员可能还没有意识到。

传统上，程序员的自我想象是一个手艺人：想清楚、写出来、调通、提交。“写”是核心动作，工程质量的来源是个人手艺——一个经验丰富的人“看一眼就知道哪里不对”。

但当 AI 能大量写代码的时候，“写”就不再是瓶颈了。真正开始变贵的是另外几样东西：需求到底定义清楚了没有？设计有没有被比较和证伪？实现有没有被验证？测试有没有杀伤力？上线有没有可控性？

换句话说，“写出来”越来越不值钱，“证明它值得信”越来越值钱。

这个变化的类比是控制论（cybernetics）。诺伯特·维纳在1948年提出控制论的时候，核心思想就是：系统的质量不取决于某个单一天才部件的性能，而取决于整个系统的反馈和校正机制。

未来的优秀开发者不会像一个手艺精湛的木匠——靠个人手感和经验出活。他更像一个控制系统的设计师：设定目标，放出候选方案，建立测试网络，执行对抗性审查，根据反馈修正，反复让系统收敛到一个足够可信的状态。

以前工程质量靠个人直觉，这种直觉当然珍贵，但它太依赖个人了，不可复制、不可扩展。未来更稳定的路线是建立系统化的验证结构：多方案竞争、独立实现、差分测试、红队 review、回归回放、文档和实现一致性检查。

当智能稀缺的时候，你舍不得做这些。当智能丰裕的时候，你应该默认去做这些。

所以这件事的 takeaway 是：软件工程的未来，不是让一个程序员变成超人，而是让每一行代码都被一群廉价但强大的智能体反复挑战、验证、解释、重放。质量来自多轮冗余验证，不再来自单次聪明。

七、便宜模型铺量，强模型深判

讲完宏观框架，来讲一个非常具体的实操原则。

很多人陷在一个低层次的问题里出不来：“到底哪个模型最好用？”这个问题本身就问错了，就像问“锤子好用还是螺丝刀好用”——它们根本不是互相替代的关系，它们应该放在不同的环节。

便宜模型的价值在于铺量。它的单次判断未必最准，但它可以大量调用。适合拉全局地图、列风险清单、扫仓库、扫 diff、补文档、生成骨架、做第一轮分类。它的优势不是“最对”，而是“最广”。就像一支侦察部队——你派它出去不是为了让它打赢仗，而是为了让它帮你看清战场。

强模型的价值在于压缩不确定性。它应该只在真正难、真正模糊、真正一旦出错代价很高的环节出手：架构方案仲裁、事务边界、一致性语义、幂等设计、权限风险、疑难 bug 根因分析、上线前红队审查。它的价值不是铺量，而是在高风险节点做出高质量判断。

这里有两种常见的浪费，值得警惕。

第一种浪费：让强模型干廉价活。你用最贵的智能去扫文件、补样板代码、写机械注释——就像请一个顶级外科医生帮你贴创可贴，这是在浪费最稀缺的资源。

第二种浪费：让便宜模型直接终审。便宜模型适合大规模探索，但你不能让侦察兵直接拍板战略决策。否则你会把大量“看起来有道理”的半成品直接带进主干代码。

好的分工是一句话：便宜模型负责多做，强模型负责少错。

这个原则不只适用于不同模型之间，它也适用于 AI 和人之间——AI 负责多做，人负责少错。

所以这件事的 takeaway 是：不要追求“一个万能模型解决一切”，而要建立一个分层的智能调度结构。铺量和深判是两种完全不同的动作，需要不同的工具来完成。

八、四种工具，四种工种

上面的分层原则落到具体工具上，会长什么样？

当前的 AI 编程工具生态里，有几个代表性的角色。把它们理解为“谁更聪明”是错误的，正确的理解方式是——它们是不同的工种。

Cursor Auto 模式，相当于一支无限实习生军团。它们可以大量执行低风险、高重复的任务——写骨架、补注释、生成 DTO、整理格式。你不需要它们做出精确判断，你需要的是它们可以同时铺开大量工作。

Opus 级别的强模型，相当于首席架构师兼首席检察官。你不会让首席架构师去写样板代码，你让它做的是：审查关键设计决策、发现深层一致性问题、在高爆炸半径的环节做对抗性审查。它出手的频率应该远低于实习生军团，但每次出手都应该对准最关键的节点。

Codex 类的异步执行工具，相当于并行施工现场。它的价值在于可以同时开多条生产线——你可以同时让它跑三个不同模块的实现，然后回来比较结果。

Kiro 类的规格化工具，相当于规格化与约束中枢。它的核心价值不是写代码，而是维护项目的记忆层——需求规格、设计约束、验证标准。它确保项目不会在大量 AI 产出的冲击下丢失一致性。

把这些角色放在一起看，你会发现一个好的 AI 编程工作流，很像一个组织良好的工程团队：有人负责铺量，有人负责深判，有人负责并行施工，有人负责维护规范。它们不是互相替代的，而是互相配合的。

所以这件事的 takeaway 是：选工具不要问“哪个最聪明”，要问“这个环节需要什么工种”。不同的工具应该被放在不同的岗位上，让它们各自做最适合的事。

九、五个阶段的重新分工

把上述所有原则铺到整个软件开发流程上，每一个阶段都应该重新设计分工。

需求阶段：先铺地图，再冻结规格

需求阶段最怕什么？不是没想法，而是大家以为自己理解一致，实际上理解完全不一致。我见过太多线上事故，根因不是代码写错了，而是需求本身就有模糊地带——成功到底怎么定义？失败怎么回滚？重试算不算新请求？部分成功部分失败怎么办？权限的边界在哪里？

便宜模型在这个阶段最该做的，不是急着给方案，而是帮你把雾拨开。读现有代码，拉调用链，列出所有你没想到的歧义点和失败场景。强模型则该扮演挑刺者：这个词定义清楚了吗？这个边界会不会炸？这个场景出了错解释成本有多高？

而人必须裁决的是：这次到底做不做？做到哪里？哪些明确不做？验收标准是什么？哪些风险不能接受？

一句话：人定义业务真相，AI 帮你把真相周围的迷雾拨开。

设计阶段：不写一版，先比较多版

设计阶段最大的误区是急着追求“一个看起来完整的方案”。在智能丰裕时代，正确做法是默认生成多个互相竞争的设计——最小改动版、最可测试版、最长期可维护版、最强调回滚能力版。让不同方案各自暴露代价，然后你再选。

设计阶段重要的不是“更漂亮”，而是“更可收敛”。好的设计过程不是找到完美方案，而是通过多方案比较快速排除不可行的路径，让最终选择建立在充分的对比之上。

实现阶段：AI 是生产线，人是收敛者

实现阶段最容易犯的错是浪费强模型。绝大多数低风险、高重复的实现工作——DTO、VO、controller 骨架、参数校验、注释、文档——都应该下放给便宜模型。强模型只在少数关键点出手：金额计算、状态转换、权限校验、幂等逻辑、事务和锁。

你在实现阶段的角色不是生产者，是收敛者。你要防止系统发散——判断某个抽象是不是过度了，某个 diff 是不是需要逐行审查，某次小重构会不会稀释主线目标。

测试阶段：最值得铺张浪费的环节

测试阶段可能是智能丰裕时代变化最大的环节。过去很多团队测试做得薄，不是因为不知道测试重要，而是因为做不起——写测试太耗人力了。现在大量便宜智能意味着你终于可以默认去做那些原本觉得太奢侈的验证动作：边界矩阵、权限矩阵、状态转移矩阵、异常路径集合、回归测试、文档和实现一致性检查。

测试阶段的核心不是“让灯都变绿”，而是建立一种你真正愿意相信的确定性。

上线阶段：AI 当参谋，发令权在你

上线阶段是所有哲学都会显形的地方。因为到了这里，事情不再只是代码质量，而是“谁来承担结果”。

AI 可以帮你生成影响范围图、发布清单、回滚方案、监控建议。它可以做上线前的红队审查：最坏会出什么事故？最先看哪几个指标？哪种情况必须回滚？

但最后那个 go/no-go 的决定——谁来盯盘、出了问题是回滚还是热修、灰度策略怎么定——这些事没有任何模型能替你承担。AI 给建议，发令权必须在你手中。

所以这件事的 takeaway 是：五个阶段，AI 的角色都不同，但有一个不变的共同点——最终判断和最终责任始终在人这一边。

十、保留主权：四项不可外包的权力

讲到这里，最底层的问题就浮出来了。在智能越来越丰裕的时代，一个人到底该保留什么？

答案不是“我要坚持自己敲多少行代码”，也不是“我必须手写每一个文档”。如果把亲力亲为本身当成价值，你很容易滑回低效和防御心态。

真正该保留的是主权。

我来给主权一个精确的定义：主权不是凡事都自己做，而是你有能力、也有意识地决定什么交出去、什么必须自己来——而且这个决定是清醒的，不是顺着便利性不知不觉滑过去的。

具体来说，有四项权力必须留在自己手里。

第一，目标定义权。 这件事为什么值得做？做到什么边界算完成？什么明确不做？这些不是 AI 帮你定义的。AI 可以帮你展开选项，但“我们为什么出发”这个问题必须你来回答。

第二，价值排序权。 速度和质量怎么平衡？短期收益和长期债务怎么权衡？哪类风险不能接受？这些本质上都是“你愿意为哪种结果负责”的问题。价值排序是一个人最深层的判断，它不是逻辑推导的结果，而是你整个人生经验、价值观和风险偏好的表达。

第三，关键判断拍板权。 尤其在高爆炸半径的环节——权限模型、金额逻辑、状态机、不可逆迁移、上线回滚。可以让模型给你一百条建议，但“就这么做”必须由你亲自说出来，而且你知道为什么这么选。

第四，后果承担权。 出了事谁解释？谁复盘？谁背结果？谁决定下次怎么防止？AI 可以分析原因，但不能替你承担后果。凡是最终回到责任结构上的事情，都必须有人在场。

这四项权力一旦也交出去了，你可能获得一个极高效的流程，但你可能已经不再是自己工作和人生的主人了。就像一个国家可以把很多事务外包给国际组织，但主权——立法权、司法权、国防权——一旦交出去，这个国家在实质意义上就不再存在了。

所以这件事的 takeaway 是：主权不是“什么都自己做”的固执，而是“清醒地决定什么交出去、什么必须自己来”的能力。在 AI 时代，这四项权力是你作为一个专业人士的最后防线。

十一、在丰裕中学会收束

过去很多年，我们训练自己的方式，本质上是匮乏时代的训练。学会记忆、学会计算、学会搜索、学会组织材料——因为资源有限、外援很少、智能昂贵。在匮乏时代，“多做一点就赢了”是成立的。

但现在世界开始翻转了。智能供给越来越多，建议越来越多，草稿越来越多，路径越来越多。赫伯特·西蒙（Herbert Simon）在1971年就预言过这件事——他说，在信息丰裕的世界里，真正稀缺的是注意力。现在这句话可以更新一下：在智能丰裕的世界里，真正稀缺的是收束力。

收束力是什么？是以下五种能力的总和：

  1. 在很多建议里形成自己的标准。
  2. 在很多草稿里做出真正属于你的终稿。
  3. 在很多路径里选一条，然后长期走下去。
  4. 在很多优化机会面前知道何时该停。
  5. 在大量 AI 产出面前，不让自己的判断肌肉萎缩。

这是一种全新的训练。不是匮乏时代那种“多获取、多积累”的训练，而是丰裕时代的训练——靠少迷失一点、少发散一点、少把主权外包一点来取胜。

这也解释了为什么“自己安静想一想”在 AI 时代反而更重要了。AI 太会给答案了，你很容易在还没真正形成自己理解的时候，就满意于一个表达漂亮的外部答案。你以为自己想通了，实际上只是借用了一个看起来完整的结论。心理学上这叫“流畅性错觉”（fluency illusion）——当信息以足够流畅的方式呈现时，你会高估自己对它的理解程度。

所以你至少要给自己保留一些不靠 AI 的思考场域：自己写一版判断，自己做一版复盘，自己走完最后一公里的表达。不是反技术，而是给自己的认知肌肉留训练场。不废掉判断肌肉，是智能丰裕时代最重要的自我纪律。

所以这件事的 takeaway 是：未来一个人最重要的能力不是生产力，而是收束力。不是谁能调更多模型、生成更多东西，而是谁能在海量可能性面前仍然保持方向感。

十二、七条长期原则

如果把这篇文章压缩成七条可以贴在显示器旁边的原则，我会这样写：

1. AI 是廉价的可能性，人类是昂贵的承诺。 理解这个区分，是一切分工的起点。

2. 可逆的事情交给 AI 多试，不可逆的事情由人来定。 试错成本低的环节尽管让 AI 铺开，但最终的不可逆决策必须经过人的审慎判断。

3. 用便宜模型铺量，用强模型深判，用自己做裁决。 三层结构，各司其职。

4. 不要让强模型干廉价活，不要让便宜模型做终审。 这是两种最常见的资源错配，每天都在发生。

5. 真正该被 AI 消灭的是死摩擦，不该被轻易外包的是活摩擦。 区分这两种摩擦，是用好 AI 的基本功。

6. 软件工程的未来，不是更会写，而是更会让系统不容易写错。 从手艺人范式转向控制系统范式。

7. 在智能丰裕时代，人的核心任务是守住主权。 目标定义权、价值排序权、关键判断拍板权、后果承担权——这四项权力是你作为专业人士的最后防线。

结语：治理智能的人

如果有人问我“智能丰裕时代，程序员最该做什么”，我的答案有四层。

第一层：学会高效调用 AI，消灭死摩擦，提升产出。大多数人停在这一层。

第二层：理解 AI 和人类是两种性质不同的智能，建立正确的分工结构。开始有意识地区分铺量和深判、扩张和收敛、可逆和不可逆。

第三层：保留主权——目标定义权、价值排序权、关键判断拍板权、后果承担权——并且这个保留是清醒的、主动的，不是惯性的。

第四层：修炼收束力。在拥有巨大外部智能之后，仍然保有自己的方向感、判断力和承诺能力。

未来不属于最会调用智能的人，而属于最会治理智能的人。

这里的“治理”是一个非常讲究的词。它不是“使用”——使用是工具层面的事。它也不是“控制”——控制暗示着对抗关系。“治理”的意思是：你能够设定目标、分配资源、建立约束、监控执行、承担后果，并且在整个过程中保持对全局的方向感。

真正稀缺的东西，一直都不是算力和数据。真正稀缺的是：清晰的目标、诚实的价值排序、对风险的敏感、对质量的敬畏、对后果的承担、在无限选项面前的收束能力。

在智能丰裕的时代，真正的修炼不是怎样拥有更多外部智能——那个问题正在被技术进步自动解决。真正的修炼是在拥有巨大外部智能之后，仍然保有自己的主权、判断和承诺能力。

这大概是未来很多年里，最值得反复提醒自己的一件事。