当前阅读总时间是：19,906小时

被重新定价的不是劳动，而是人的位置

——Paul Graham 风格：小切口，大纵深

有人在网上问了一个很接地气的问题：既然 AI 已经能看屏幕、理解界面、控制鼠标了，那游戏工作室那种「搬砖」模式，以后是不是可以全让 AI 来？紧接着有人补了一句更接地气的：很多时候，雇一个愿意坐在电脑前重复操作的人，比烧 AI 的算力还便宜。

这句话听起来像玩笑，但我越想越觉得它触碰到了 AI 时代最深的问题。

⸻

先说一个容易被忽视的事实：那些坐在电脑前做重复操作的人，他们卖的其实不是「手」。

表面上看，他们只是在点鼠标、切窗口、按流程执行。但如果你真的试过把这件事完全自动化，你会发现情况远比想象中复杂。因为一个人坐在那里，他其实在同时做很多件事：判断界面是不是正常，识别弹窗是异常还是预期内的，区分网络问题和系统问题，在流程卡住时凭经验尝试各种方案，在没有任何规则手册的情况下自己发明临时规则。

最重要的是，他有一种在不完美的现实里将就着把事情做下去的能力。系统卡了？刷新一下。流程不通？换个路径试试。莫名其妙报错？等一会儿再来。这些行为在效率评估里看起来很笨，但在真实世界里，「能糊过去」本身就是极高价值的能力。

所以那些看起来「低端」的劳动力，实际上是在极低价格上出售一种高适应性的通用智能。市场对他们的计价方式不是按照「你提供了多复杂的认知服务」来估值，而是按照「你愿意接受多低的工资」来出价。这就是为什么，在很多场景下，最先进的 AI 反而不一定比最便宜的人力更划算——不是 AI 不聪明，而是人类那种混杂着常识、经验、模糊判断和临场应变的能力，一旦被拆散后逐个用技术实现，成本远高于我们对它的直觉估计。

⸻

这又引出了第二个问题：自动化到底怕什么？

人们总说重复性工作最容易被自动化。这只说对了一半。真正决定自动化成败的，往往不是那 80% 的重复，而是剩下那 20% 的例外。一个场景即使 95% 的时间在顺利运行，只要那 5% 的异常足够复杂，系统就必须为它支付大量隐形成本：监控、告警、规则更新、异常恢复、人工介入。这些成本平时不显眼，可一旦算进去，很多「看上去很省人力」的自动化项目最终变成了「一群人盯着机器干活，专门给机器擦屁股」。

人类在这里的优势不是效率更高，而是能在例外里活下去。一个系统卡住了，人会顺手尝试各种办法——这些办法可能没有理论支撑，但往往能解决问题。AI 则不同：它在情况大致正确的时候表现惊艳，一旦碰到不在预期内的异常链条，就很容易从「看起来聪明」迅速坠落成「让人头皮发麻」。

所以未来更可能的图景不是「AI 把人替掉」，而是「AI 做掉了标准部分，把例外处理留给人」。人的工作不会消失，但会发生「监督化」「兜底化」「审核化」——你不再亲自做每一步，但必须始终在场，作为系统背后的守夜人。

⸻

现在说到真正让我觉得有意思的部分。

如果 AI 的冲击是按照上面这个模式展开的，那它最先冲击的是谁？

很多人的直觉是：最先被冲击的应该是最底层、最简单、最重复的工作。但事实可能恰好相反。

AI 最强的地方不是替代「手」，而是侵入「符号系统」——语言、文本、代码、表格、模板、流程说明。于是最先感受到巨大冲击的，常常不是那些最体力化的工作，而是大量中层、体面、受过教育、长期处理符号的白领岗位。写标准报告、整理会议纪要、生成初稿、制作常规方案、完成样板代码——这些工作的薪资之所以曾经不低，很大程度上不是因为它们本质上神秘，而是因为过去「能稳定处理符号的人」本来就稀缺。大模型直接打进了这个层面。

这意味着 AI 的冲击不是「由下往上」的，而更像是「由中间向两边扩散」。那些工作内容高度数字化、输出能被拆解成标准输入输出的岗位，会比很多贴近现实现场的工作更早承压。

一个坐在办公室里写报告的人，未必比一个现场协调突发的人更安全。因为前者的劳动更接近纯符号层，后者始终在和现实接口打交道。

⸻

再往深一层看，会发现 AI 正在做一件更根本的事：它在把认知劳动变成资本品。

过去，一个人写文案、写代码、做分析，这些事强烈依赖个人此刻此地的脑力投入。你可以雇人，但无法把能力从人身上完整剥离出来。人的能力和人的时间绑定在一起。

AI 改变了这件事。模型、提示词、工作流、知识库一旦搭好，一部分认知产出就不再依赖「某个人此刻坐在这里动脑」，而开始表现出资本的特征——可复制、可规模化、边际成本递减。

这很像工业革命把体力劳动机械化。只不过这次被资本化的是认知能力。后果不是所有人立刻失业，而是大量依赖出售脑力时间的人，议价能力逐步下降。很多人的身份会从「生产者」悄悄变成「校对者」「审核员」「兜底人」。

⸻

这就引出了一个我觉得非常重要的判断：在 AI 时代，能力和议价权正在脱钩。

过去大家相信一个朴素的逻辑：只要我足够能干，我就应该获得更好的位置。这条逻辑正在松动。

如果你的能力只是高质量地完成别人定义好的任务，那你的强大可能只是让你成为一个更高性能的模块。只要这个模块的输入输出足够清晰，系统总会尝试替换它、自动化它、或者用更便宜的方式复制它。

真正能转化为议价权的，不是孤立的能力，而是那些能沉淀为结构的能力——你不仅会做一件事，而且能决定这件事应该怎么被做、用什么标准验收、出问题由谁接手、哪些风险必须提前纳入。只有当你的能力变成了标准、流程、接口、信任和组织依赖的协调机制时，它才不再只是「你能干」，而会变成「系统离不开你」。

这就是模块和节点的区别。模块拿掉后系统损失一点产能，但很快能补上。节点拿掉后，连目标理解、跨环节协调、风险判断和责任承担也一起消失。AI 会把大量模块级能力变便宜，但它反而会放大节点的价值。

⸻

如果执行在变便宜，那价值一定会向上游流动。上游在哪里？在定义问题、确定目标、划定边界的地方。

AI 非常擅长在目标已给定的情况下快速展开。但什么才是正确的目标？哪些指标值得优化，哪些会制造错觉？这类问题不是技术展开问题，而是判断问题。AI 只能在既定目标函数内狂奔，真正影响命运的往往是目标函数本身。

同样，人越来越贵的地方不在于产出，而在于约束和责任。模型天然倾向于优化单一目标，但现实充满了边界和代价。知道什么时候必须停下来复核、什么风险绝不能冒、什么看似漂亮的数据不能信——这些约束能力背后连接的是责任。系统出错的时候，最终总要有人站出来说「这件事我们负责」。AI 可以扩张执行能力，但无法替代社会意义上的承诺能力。

⸻

说到最后，我觉得 AI 引发的最深层危机不是失业，而是主体性。

当越来越多的工作被拆成可替换的模块后，人可能会逐渐失去一种更根本的东西：我在做的事和我是谁有关。我不是在执行，我在判断、选择、承担。这个结果里有我的意志。

当 AI 吞掉了工作中最能体现创造感的部分，把人推向审核和兜底的位置时，很多人会感到一种空心化：你还在工作，但越来越像在替系统看守边界。你还在产出，但产出越来越不是从你这里生发出来的。

所以 AI 时代最值得追问的不是「我还能不能干这个活」，而是「我正在把自己训练成什么样的人」。如果你只是在让自己更快、更熟练、更像一个高性能模块，你可能短期很受欢迎，长期却越来越危险。但如果你在训练自己理解整体、定义问题、设置边界、承担责任、连接现实、建立信任，那么 AI 越强，你的位置反而越稳。

归根结底，被重新定价的不只是劳动，而是人在系统中的位置。你是一个容易被替换的执行模块，还是一个拿掉后系统会乱的关键节点？你是在卖可拆分的劳动切片，还是在积累判断权、约束力和责任承载力？

这些问题，比「AI 会不会抢走工作」重要得多。

不要只想着如何让自己更像机器那样高效。要想清楚，怎样让自己成为那个即使机器遍地都是，仍然不可省略的人。

被重新定价的不是劳动，而是人的位置

——Nassim Taleb 风格：切肤之痛，反脆弱

一条朴素的真理

有人问：AI 能不能代替游戏工作室里那些「搬砖」的人？紧接着有人回答：很多时候，雇一个愿意长时间坐在电脑前的人，比烧 AI 的算力还便宜。

这句话听起来像玩笑。但它击中的是一个多数人不敢面对的事实：市场对人类劳动的定价，从来就不是按照「你有多聪明」来算的。

我在整个职业生涯中反复强调一件事：不要听人们说什么，要看他们把钱押在哪里。那些声称「人才是最宝贵资源」的公司，转头就会用一个月几千块钱雇人做需要高度通用智能才能完成的任务。他们嘴上说的是「低端劳动」，实际购买的是一个廉价的通用 agent——一个能看屏幕、判断异常、处理例外、在系统崩溃时临时拼凑解决方案的活人。

这就是我要讨论的第一个核心问题。

廉价劳动力是被长期低估的通用智能

整个社会对「低端劳动」有一种结构性的误读。

人们以为，坐在电脑前做重复操作的人提供的只是「手」——点击、拖拽、切换窗口。但这是一种彻头彻尾的胡说八道。一个人坐在那里，他同时在做以下所有事情：

识别界面是否正常。判断弹窗是异常还是预期内的。区分网络问题和系统问题。在流程卡住时凭经验尝试解决方案。在没有人给他写规则手册的情况下，自己发明临时规则。在整个系统不完美的前提下，凑合着把事情做完。

这最后一条是最重要的。人类最被低估的能力，是在不完美条件下把事情糊过去的能力。 这种能力没有名字，没有证书，没有学位，也几乎没有市场在为它单独定价。但它存在于每一个所谓「低端工人」的每一天劳动中。

我把这种能力叫做**「通用模糊适应性」**。它和智商无关，和学历无关，和你能不能在白板上推导公式无关。它是一种在现实世界的毛边和阴影里活下去的能力。

而 AI 恰恰最缺的就是这个。AI 的惊艳发生在一切大致正确的时候；一旦脱离它熟悉的分布，它会从「看起来像天才」瞬间坠落到「让人头皮发麻」。这不是 AI 的 bug，这是所有形式化系统的根本限制。

所以，当你用一个月几千块钱雇一个人的时候，你买到的不是一双手。你买到的是一个极其廉价的通用适应系统，一个能在规则缝隙里活下去的生物体。市场对他的定价方式不是「你提供了多复杂的认知服务」，而是「你愿意接受多低的工资」。

这是一种结构性的掠夺。它之所以能持续，是因为提供这种能力的人太多了，多到市场不必为它支付公平的价格。

自动化最大的敌人不是重复，而是例外——或者说，尾部风险

人们总说重复性工作最容易被自动化。我对这种说法的容忍度为零。

说这种话的人，显然从来没有真正运营过一个自动化系统。一个场景即使 95% 的时间在按流程跑，也不代表它适合彻底自动化。因为自动化的成本不是由那 95% 的顺利时刻决定的，而是由那 5% 的例外决定的。

这就是尾部风险的逻辑。我在金融领域谈了二十年尾部风险，但这个概念在劳动领域同样适用。一个系统运行一千次没出事，不代表第一千零一次不会炸掉。而系统一旦炸掉，你需要的不是更好的算法，而是一个能在混乱中做出决定的人。

人类劳动力在这里的优势不在于更高效，而在于反脆弱。一个人面对异常时，他不会崩溃——他会刷新页面、切换窗口、重新登录、停一停再试、甚至在完全没有理论支撑的情况下凭直觉找到临时方案。这些行为在标准效率评估里看起来很蠢。但在现实世界里，「能在混乱中存活」本身就是最高价值的能力。

AI 则相反。AI 是一个极度脆弱的系统——它在预期分布内表现完美，在预期之外则可能灾难性地失败。很多人想象的未来是「AI 替代人」，现实更可能是「AI 做掉了标准部分，把所有脏活、碎活、兜底的活留给人」。于是人的工作不是消失了，而是变得更无聊、更琐碎、更像一个「系统的守夜人」。

真正麻烦的地方在于：这种守夜人的劳动更难获得成就感，更难产生主体性，更像一个人类形态的安全阀。

「切肤之痛」原则：谁离后果近，谁就更值钱

现在让我说到本文最核心的判断。

在我的整个思想体系中，有一条比什么都重要的原则：不要听一个不承担后果的人给你的建议。 一个人有没有「切肤之痛」（skin in the game），决定了他的判断是否值得信赖。

把这条原则搬到 AI 时代的劳动分析中，你会得到一个极其清晰的结论：

未来最值钱的位置，不是「谁更聪明」，而是「谁离真实后果更近」。

什么叫离后果近？就是你的决定一旦出错，后果会直接砸到你身上。你面对客户的时候，客户会冲你发火，不是冲模型发火。你签字的时候，法律责任落在你头上，不是落在工作流头上。你拍板的时候，资源会按照你的判断分配，分配错了，损失是真实的。

相反，那些离后果很远的位置——只负责转述、整理、包装、初步分析、做标准化表达——看起来体面、专业、高智力，但它们不承担后果。它们是组织中的「认知缓冲层」。过去这层缓冲有价值，因为能稳定处理符号的人本来就稀缺。但当大模型打进来之后，这层缓冲会首先被挤压。

AI 最先掏空的，不是底层，而是中层那些「没有切肤之痛的符号处理者」。

一个在工地上协调资源、处理突发的人，可能比一个在办公室里写报告的人更安全。不是因为前者更聪明，而是因为前者每天都在和真实后果打交道。他的产出一旦出错，后果是即时的、可见的、无法用漂亮的 PPT 糊过去的。

这就是为什么我反复强调：衡量一个位置的稳固程度，不要看它的技能复杂度，要看它离真实后果有多近。

AI 正在把认知劳动变成资本品——这意味着什么？

让我把分析再推深一层。

AI 对社会的冲击不只是「提高生产率」。更深的变化是：它正在把一部分原本只能由人在现场完成的认知劳动，转化为可以被复制、部署、叠加和扩张的资本品。

过去，一个文案写稿、一个程序员写代码、一个分析师做汇报，这些事情强烈依赖个人此刻此地的脑力投入。你可以雇人，但无法把他的能力从人身上完整剥离出来。人的能力和人的时间绑定在一起，这就是劳动的基本形态。

AI 改变了这件事。模型、提示词、工作流、知识库一旦搭建完成，一部分认知产出就不再依赖「某个人此刻坐在这里动脑」，而开始表现出资本的特征——可复制、可规模化、边际成本递减。

这就像工业革命时体力劳动被机械化。只不过这次被资本化的是认知能力。过去属于人的「会想、会写、会拼接、会总结」的能力，正在以系统的形式被沉淀下来。

后果是什么？不是所有人立刻失业，而是大量依赖出售脑力时间的人，议价能力逐步下降。 以前是「你必须雇这个人来做」，以后是「这个人只要负责监督和修正系统输出即可」。很多人的身份会从「生产者」悄悄变成「校对者」「审核员」「兜底人」。

能力 ≠ 议价权。这是一条铁律。

在旧世界，人们信奉一条朴素逻辑：只要我足够能干，我就应该获得更好的位置。

这条逻辑正在失效。

能力和议价权正在脱钩。 如果你的能力只是高质量地完成别人定义好的局部任务，那你的强大可能只是让你成为一个更高性能、更值得压榨的模块。只要这个模块的输入输出足够清晰，系统就总会尝试替换它、自动化它、或者用更便宜的方式复制它。

真正能转化为议价权的，不是孤立的能力，而是那些能沉淀为结构的能力。什么叫沉淀为结构？是你不仅会做一件事，而且能决定这件事应该怎么被做、用什么标准验收、出问题由谁接手、哪些风险必须提前被纳入。

只有当你的能力变成了标准、流程、接口、规则、信任和组织依赖的协调机制时，它才不再只是「你能干」，而会变成「系统离不开你这个位置」。

模块可以被替换。节点不行。

模块的特征是清楚的：输入明确，输出明确，拿掉之后系统损失一点产能，但很快能补上。节点则不同：节点连接多个环节、理解上下文、影响资源流向、协调不同目标、传递信任、承担后果。拿掉一个真正的节点，损失的不只是产量——判断、协同、记忆和组织摩擦成本会一起上升。

AI 会把大量模块级能力变便宜，但它反而会放大节点的价值。当执行越来越廉价时，能整合执行的人就更稀缺；当生成越来越容易时，能验证、约束和组织生成的人就更重要。

当执行变便宜，定义问题的人会越来越贵

价值正在向上游流动。上游在哪里？在定义问题、确定目标、划定边界、设定指标、决定优先级的地方。

AI 擅长在目标给定后快速展开。但什么才是正确的目标？哪些指标值得优化？哪些指标会制造错觉？这个项目应该追求短期增长还是长期留存？这些不是技术问题，而是判断问题。

AI 只能在既定目标函数内狂奔。真正影响组织命运的，往往是目标函数本身。

很多人把「定义问题」误解成开会、画 PPT、说空话。错了。定义问题是最难、最稀缺、也最容易被低估的劳动。因为定义不像执行那样能直接产出成品，却决定了系统是在正确方向上高速前进，还是在错误方向上高效坠毁。

AI 越强，定义能力就越像操盘权，而不是辅助能力。

人越来越贵的地方：约束、责任和承诺

模型天然倾向于优化目标函数。给它一个方向，它就会沿着那个方向尽可能推进。但现实社会不是单目标优化机器。任何真正重要的事情，都充满了边界和代价：不能为了效率牺牲安全，不能为了增长破坏信任，不能为了速度无视法律。

这就需要一种和「生成」完全不同的能力——约束能力。约束不是保守，不是拖后腿。约束是知道目标之外还有后果，知道指标之外还有现实，知道局部最优可能毁掉整体。

约束之所以贵，根本原因在于它背后连接着责任。系统出错时，不是模型去面对客户，不是工作流去承担信誉损失。最终总要有一个人站出来说：这件事我们负责。这种负责不只是道德姿态，它是社会协作的基础。别人愿意把资源和信任交给你，是因为他们相信一旦出了问题，系统里有可以追索的主体。

AI 可以大幅扩张执行能力，但无法替代社会意义上的承诺能力。 这是技术与治理之间最核心的鸿沟。

主体性危机：比失业更深的伤害

人们担心失业，这是最直接的恐惧。但更深的危机是主体性的丧失。

什么是主体性？就是你能感到「我在做的事和我是谁有关」「我不是在执行，我在判断、选择、承担」「这个结果里有我的意志」。

当 AI 吞掉了工作中最能体现能力感和创造感的部分，把人推向审核、校正、兜底的位置时，很多人会感到一种隐秘的空心化：你还在工作，但越来越像在替系统看守边界。你还在产出，但产出越来越不是从你这里生发出来的。你仍然被需要，但被需要的方式不再是「你是创造者」，而是「你是最后一道保险」。

这种「审核员化」对很多知识工作者来说，比简单的失业更难承受。因为它伤害的不只是收入，而是人格和尊严。

一个没有切肤之痛的人会告诉你「这是进步，你应该适应」。但我要说的是：当一个人的工作被剥离到只剩下兜底和签字时，他就不再是一个完整的行动者，而只是一个带有人类签名的安全阀。

结论：不要让自己变成一个高性能模块

让我把话说到最尖锐的地方。

AI 时代真正危险的人，不是能力差的人，而是那些能力不错、工作勤奋、效率很高，却长期只在「别人定义好的目标里」奔跑的人。他们是组织里的优等生——执行力强、配合度高、产出稳定。但他们从来没有训练自己去定义任务、质疑任务、重组任务。

一旦 AI 可以接管越来越多的执行，这些人最容易被重新分类为「监督机器的熟练操作员」。

所以，我的建议极其简单：

不要追求变成一个更快、更精准、更高性能的模块。要追求变成一个离后果更近、能施加约束、敢做出承诺、拿掉之后系统会乱的节点。

不要只问「我能不能干这个活」。要问「我做的东西有没有沉淀成一个别人必须围绕我来组织的结构」。

不要只提高执行速度。要训练自己定义问题、设置边界、承担责任、连接现实、建立信任。

因为 AI 越强，模块越便宜，节点越贵。被机器拿走的也许只是某项技能。但如果你把位置守住——把切肤之痛守住——你就仍然是系统中那个无法被轻易删除的人。

不要让自己变得更像机器那样高效。要让自己成为那个即使机器遍地都是，仍然不可省略的人。

这才是 AI 时代唯一值得信赖的生存策略。其他的都是噪声。

被重新定价的不是劳动，而是人的位置

——刘瑜风格：不动声色的犀利

一个不太体面的起点

让我们从一个不太体面的话题开始。

有人问：AI 能不能代替游戏工作室里的「搬砖工」？就是那些长时间坐在电脑前，重复点击、刷副本、做任务、倒卖虚拟资源的人。紧接着有人补了一句极其现实的话：在很多场景下，雇一个活人的成本，可能还没有让 AI 来做一样的事贵。

这句话之所以让我停下来想了很久，不是因为它有趣，而是因为它不小心揭开了一个我们很少认真面对的问题：当我们说一个人「便宜」的时候，我们到底在说什么？

我们以为我们在说他的技能简单。但其实我们在说的是：这个人提供的极其复杂的服务，被市场用一种极其粗暴的方式定了一个极低的价。

你以为你在买一双手，其实你在买一整个操作系统

一个坐在电脑前做重复操作的人，表面上看只是在点鼠标。但如果你真的试过把他的工作完全自动化，你会发现一件令人不安的事：你需要做的远比你想象的多。

因为他其实在同时做很多件你没注意到的事情。他在判断界面是否正常，在识别弹窗是预期内的还是异常的，在区分是网络问题还是系统问题，在流程卡住时凭经验尝试各种非标准解决方案，在没有规则手册的情况下自己发明临时规则。

最重要的是，他有一种能力——一种我们极少谈论、也不知道该怎么命名的能力——就是在一切都不太对的情况下，将就着把事情做下去。

这种能力，如果放到技术语言里描述，大概叫「高适应性的通用智能在非标准环境中的鲁棒执行」。听起来很高级。但市场给它的定价，是一个月几千块。

为什么？因为能提供这种服务的人太多了。不是因为这种能力简单，而是因为供给太大。就像空气对生命极其重要，但没人会为一口空气付费——除非你在太空站里。

AI 的出现，正在让我们第一次「看见」这些曾经隐形的能力。因为当你试图用技术替代它们的时候，你会发现成本高得惊人。我们平时看不起一个「只会坐在那里做重复劳动的人」，很大程度上是因为我们把他复杂的认知劳动误读成了简单的动作劳动。

自动化害怕的不是重复，而是例外

有一个关于自动化的流行说法：重复性工作最容易被替代。这句话我只同意一半。

准确地说，被替代掉的通常是那 80% 的标准流程。但决定一个自动化项目成败的，往往是剩下那 20% 的例外。甚至可能只是那 5%。

这就像一个城市 95% 的时间不发洪水，但你不能因此不建防洪堤。那 5% 的异常，可能需要你为它支付巨大的基础设施成本。自动化也一样——你需要为例外配备监控、告警、规则更新、异常恢复、人工介入机制。这些成本平时看不见，可一旦算进去，很多「看上去省人力」的自动化项目最终变成了「一群人专门给机器擦屁股」。

人类在这里的优势非常朴素：他能在例外里凑合着活下去。系统卡了，他会刷新页面试试。流程不通，他会换个路径。报错了，他会等一下再来。没有理论支撑？没关系，先试一个笨办法。

AI 则不一样。AI 在「一切大致正确」的时候表现惊艳，但一旦碰到超出预期的异常链条，它很容易从天才瞬间坠落为灾难。

所以未来更可能的图景不是「AI 把人替掉」，而是「AI 做掉了标准部分，把脏活碎活兜底的活留给人」。人的工作不是消失了，而是变得更无聊、更琐碎——你不再是创造者，而是系统的守夜人。

这就引出一个令人不安的问题：如果 AI 把工作中最有技术感、最有创造感的部分吃掉了，却把最烦最碎的部分留下来，那人的主体性到底是在被解放，还是在被抽空？

AI 最先吃掉的不是底层，而是「格式化的中层」

工业时代给我们留下一个很深的直觉：机器会先替代最底层、最简单的工作，然后慢慢向上爬。

但 AI 时代不完全是这样。因为 AI 最强的地方不是替代「手」，而是侵入「符号系统」——语言、文本、代码、表格、模板、标准化分析。

于是最先感受到巨大冲击的，常常不是体力劳动者，而是大量中层白领：写标准报告的人、整理会议纪要的人、做常规方案的人、完成样板代码的人。他们的薪资之所以曾经不低，不是因为工作本身神秘，而是因为过去「能稳定处理符号的人」比较稀缺。大模型直接打进了这个层面。

打个比方。如果把劳动市场想象成一栋大楼，AI 的冲击波不是从一楼开始往上推的，而是从中间楼层开始向两侧扩散的。那些工作内容高度数字化、输出可以被标准化、远程就能完成的楼层，震感最强。

一个坐在办公室里写报告的人，未必比一个现场处理突发的人更安全。因为前者的劳动更接近纯符号层——而纯符号恰好是 AI 最擅长的领域。后者虽然看起来「不高级」，却始终在和真实后果打交道。

这让人想起一个古老的悖论：那些看起来最高级、最体面的工作，有时反而因为离现实太远而更脆弱。而那些「低端」的、贴近现场的工作，反而因为持续和混乱打交道而更顽强。

认知劳动正在被资本化——这意味着什么？

AI 对劳动市场最深层的冲击还不是替代某个岗位。更深的变化是：它正在把一部分原本只能由人在现场完成的认知劳动，转化为可以被复制和规模化的资本品。

过去，你雇一个人写文案、写代码、做分析，你买的是他此刻此地的脑力。你无法把能力从人身上剥离出来。能力和时间绑定，这是劳动的基本形态。

AI 改变了这一点。模型、工作流、知识库一旦搭好，一部分产出就不再依赖「某个人此刻在动脑」，而开始像资本一样运作——可复制、可规模化、边际成本递减。

后果是什么？不是所有人立刻失业。而是大量依赖出售脑力时间的人，议价能力逐步下降。很多人的身份从「生产者」悄悄变成「校对者」「审核员」「兜底人」。以前是「你必须雇这个人来做」，以后是「这个人只需要负责检查系统输出就行」。

能力不等于议价权——这是一条正在硬化的规律

在旧世界里，有一条朴素逻辑：只要我足够能干，我就应该获得更好的回报。

这条逻辑正在出现裂缝。

如果你的能力只是高质量地完成别人定义好的任务，那你的强大可能只是让你成为一个更好用的零件。只要这个零件的输入输出足够清晰，系统就总会尝试用更便宜的方式复制它。

真正能转化为议价权的，不是孤立的能力，而是那些沉淀成了结构的能力——你不仅会做一件事，而且能决定这件事怎么做、用什么标准验收、出问题由谁负责。只有当你的能力变成了标准、流程、信任和组织依赖的协调机制时，你才不只是「能干」，而是「不可省略」。

这就是模块和节点的区别。模块拿掉后系统损失一点产能但很快能补上。节点拿掉后，目标理解、跨环节协调、风险判断和责任承担会一起消失。

AI 会把大量模块级能力变便宜，但反而会放大节点的价值。

执行变便宜之后，谁会变贵？

当执行成本在下降时，价值会向上游流动。上游在哪里？在定义问题、确定目标、划定边界的地方。

AI 擅长在目标给定后快速展开。但什么是正确的目标？哪些指标值得优化？哪些指标在制造错觉？这不是技术问题，是判断问题。

同时，人越来越贵的地方不在于产出，而在于约束和责任。模型天然倾向于沿着目标函数全力冲刺，但现实世界充满了「你不能因为追求 X 就牺牲 Y」的约束。知道什么时候必须停下来、什么风险绝不能冒、什么漂亮的数据不能信——这些约束能力背后连接的是责任。系统出错时，不是模型去面对客户，最终总要有人站出来说「这件事我们负责」。

AI 可以大幅扩张执行能力，但无法替代社会意义上的承诺能力。

比失业更深的东西：主体性危机

人们当然会担心失业。但更深的危机是主体性的丧失。

什么是主体性？就是你能感到「我做的事和我是谁有关」「我不只是在执行，我在判断、选择、承担」「这个结果里有我的意志和署名」。

现代人很大程度上是通过工作来定义自己的。「我是程序员」「我是设计师」「我是分析师」——这些不只是职业标签，也是身份标签。当 AI 把工作中最能体现能力感和创造感的部分吞掉后，很多人会发现：你还在工作，但越来越像在替系统看守边界。你还在产出，但产出越来越不是从你这里生发出来的。你仍然被需要，但被需要的方式从「你是创造者」变成了「你是最后一道保险」。

这种「审核员化」对很多知识工作者来说，可能比简单的失业更难承受。因为它伤害的不只是收入，而是人格和尊严。

AI 的悖论就在这里：它一方面能提高效率、释放时间，另一方面却可能在心理层面把人从「行动者」推向「监督者」，从「作者」推向「审稿人」。

最危险的不是没有能力，而是长期住在别人写好的目标函数里

最后让我说一个我觉得最重要的判断。

AI 时代真正危险的人，不是能力差的人，而是那些能力不错、工作勤奋，却长期只在「别人定义好的目标里」奔跑的人。

他们过去是组织中的优等生——执行力强、配合度高、产出稳定。但他们很少训练自己去定义任务、质疑任务、重组任务。一旦 AI 接管了越来越多的执行，他们最容易被重新分类为「监督机器的熟练操作员」。

所以真正需要保护的，不只是你的岗位，更是你对目标的参与权、对标准的影响力、对后果的感受能力，以及你为某件事署名的勇气。只有这些东西还在，你才不是一个被系统临时调用的模块。

AI 时代最值得反复追问的不是「我还能不能干这个活」，而是「我正在把自己训练成什么样的人」。如果你只是在让自己更快、更熟练、更像一个高性能模块，你也许会在短期内很受欢迎，却在长期里越来越危险。

但如果你在训练自己理解整体、定义问题、设置边界、承担责任，那么 AI 越强，你的位置反而越稳。

被重新定价的不只是劳动。被重新定价的是人在世界中的位置。

而你的位置，从来不是由你的能力决定的——它是由你和后果之间的距离决定的。

被重新定价的不是劳动，而是人的位置

——罗翔风格：法理与伦理的双重拷问

一、张三的新工作

我们来说一个假设性的案例。

张三，一个在网上讨论区总是承担各种角色的普通人，最近找到了一份工作。他的工作内容是：坐在电脑前，在一款网络游戏里反复执行特定操作——刷副本、打怪、搬运虚拟资源——然后把这些资源交给老板去出售。行话叫「搬砖」。

这份工作的薪资很低。一个月几千块钱。

有人问：AI 已经能看屏幕、理解界面、控制鼠标了，张三这份工作是不是很快就会被 AI 替代？

有人回答：不一定。因为雇张三坐在那里，可能比让 AI 来做同样的事还便宜。

这句话乍听像玩笑，但它击中了一个非常严肃的问题：当一个人的价格比一台机器还低的时候，这个社会对「人」的定价标准出了什么问题？

这不只是一个经济学问题。它是一个法理学和伦理学问题。

二、你以为你在雇一双手，其实你在雇一整个人

让我们仔细看看张三到底在做什么。

表面上，他在做重复的点击操作。但如果你坐在他旁边观察——不是看数据报表，而是像人类学家那样观察他一天的工作——你会发现他其实在同时做很多件事情。

他在判断界面是否正常。他在识别弹窗是系统异常还是预期内的行为。他在区分是网络问题还是系统本身的问题。他在流程卡住时凭经验尝试各种非标准解决方案。他在没有任何人给他写规则手册的情况下，自己发明临时规则来应对不断变化的状况。

最重要的是——他有一种在一切都不太对劲的情况下，将就着把事情做下去的能力。

这种能力如果放到技术语言里，每一条都构成一个独立的工程挑战。但市场对张三的定价方式不是「你提供了多复杂的认知服务」，而是「你愿意接受多低的工资」。

换言之，张三出售的不是动作，而是一整套被严重低估的通用智能。他之所以便宜，不是因为他简单，而是因为愿意做这份工作的人太多了。

法律里有一个概念叫「显失公平」——当一方利用对方的弱势地位订立了明显不公正的合同时，该合同可以被撤销。如果我们把「显失公平」的逻辑从合同法扩展到整个劳动定价体系，会看到什么？

会看到整个社会对大量劳动者的定价，结构性地处于「显失公平」的状态。不是因为他们提供的服务不值钱，而是因为供给过于充裕——当几亿人需要工作的时候，即使是相当复杂的认知劳动，也可以被压到一个不体面的价格。

三、自动化的「尾部风险」

有人说：重复性工作最容易被自动化。张三迟早会被替代的。

这话听起来合理，但经不起细究。

一个场景即使 95% 的时间在按预期运行，也不代表它适合完全自动化。因为那 5% 的异常，往往才是决定系统成败的关键。你需要为异常配备监控、告警、规则更新、异常恢复、人工介入机制——这些隐形成本平时不显眼，可一旦算进去，很多「省人力」的自动化项目反而变成了更大的负担。

法律上我们有一个概念叫「注意义务」。开车的人有义务预见可能出现的危险。设计系统的人也一样——你不能只为 95% 的常规情况设计，然后把 5% 的异常留给命运。而人类劳动者天然地承担了这种注意义务——他会刷新页面试试，会换个路径，会停一停再来，会在没有理论支撑的情况下凭直觉找到临时方案。

人类的优势不在于比机器更快，而在于能在例外中活下去。 AI 在「一切大致正确」的时候表现惊艳，一旦碰到超出预期的异常链条，可能从天才坠落为灾难。

未来更可能的图景不是 AI 把人替掉，而是 AI 做掉了标准部分，把例外处理——也就是最琐碎、最烦、最没成就感的部分——留给人。于是人的工作不是消失了，而是从「创造者」变成了「守夜人」。

四、AI 先吃掉的不是底层

现在说到一个非常反直觉的事情。

我们习惯性地认为技术进步会先替代最底层的工作。但 AI 不完全遵循这个逻辑。

AI 最强的领域不是体力劳动，而是符号处理——语言、文本、代码、表格、模板。于是最先承压的不是在现场搬东西的人，而是大量中层白领：写标准报告的人、整理纪要的人、做常规方案的人、完成样板代码的人。

他们的薪资之所以不低，不是因为工作本身神秘，而是因为过去「能稳定处理符号的人」相对稀缺。大模型直接进入了这个层面。

这就出现了一个在刑法课堂上我经常说到的问题：你以为最安全的地方，恰恰可能是最危险的。 就像一栋楼里，住在中间楼层的人以为自己最安稳——高处的风险在楼顶，低处的风险在地面。但地震来了，中间楼层往往最先被夹扁。

AI 的冲击波就像一场地震。它不是从一楼往上推的，而是从中间楼层开始向两侧扩散的。那些高度数字化、可标准化、离真实后果较远的工作——恰好是受过教育的中产阶级最集中的楼层——会比很多贴近现场的工作更早承压。

五、认知劳动的资本化：一个法理学隐喻

AI 正在做一件比替代岗位更深刻的事情：它在把认知劳动转化为资本品。

过去，你雇一个人写东西、写代码、做分析，你买的是他此刻此地的脑力。能力和时间绑定在一起。这就是劳动关系的基本形态——法律上，劳动合同保护的正是这种「人不可剥离」的属性。

但模型、工作流、知识库搭好之后，一部分认知产出不再依赖某个人此刻在动脑。它开始像资本一样运作——可复制、可规模化、边际成本递减。

用法律语言来说，这就像你的劳动成果被「物化」了——它不再和你这个人绑定在一起，而变成了一种可以被交易的资产。劳动法的基础假设是「劳动不可囤积」——你今天工作了八小时，这八小时过去了就过去了。但如果你的认知产出可以被模型吸收、复制和规模化，那劳动和时间的绑定关系就被松动了。

后果是什么？大量人的身份从「生产者」悄悄变成「校对者」「审核员」「兜底人」。以前是「你必须雇这个人来做」，以后是「系统已经做了大部分，你只需要负责检查一下」。

六、能力不等于权利——一个古老的法理教训

在法理学中，有一条经常被讨论的原则：能力（capacity）不等于权利（right）。

你有做某件事的能力，不代表你拥有相应的权利。反过来，你拥有一项权利，也不一定意味着你有行使它的实际能力。

把这个原则搬到 AI 时代的劳动分析中，你会发现一个非常尖锐的现实：

能力和议价权正在脱钩。如果你的能力只是高质量地完成别人定义好的任务，你的强大可能只是让你成为一个更好用的工具。只要你的输入输出足够清晰，系统就总会尝试用更便宜的方式复制你。

真正能转化为议价权的，不是孤立的能力，而是那些沉淀成了结构的能力。你不仅会做一件事，而且能决定这件事应该怎么做、用什么标准验收、出问题由谁接手。只有当你的能力变成了标准、流程、接口和信任机制时，你才不只是「能干」，而是「不可省略」。

模块可以被替换。节点不行。

模块拿掉后系统损失一点产能但很快能补上。节点拿掉后，目标理解、跨环节协调、风险判断和责任承担会一起消失。

七、约束、责任与承诺——法律精神的核心

在一个执行变得廉价的时代，什么会变贵？

我的答案是：约束、责任和承诺。

这三个概念，恰好也是法律精神的核心。

约束——法律的本质功能之一是约束。不是不让你做事，而是让你知道边界在哪里。AI 天然倾向于优化目标函数——给它一个方向，它就全力冲刺。但现实社会不是单目标优化机器。不能为了效率牺牲安全，不能为了增长破坏信任。知道什么不该做，有时候比知道什么该做更重要。

责任——系统出错时，不是模型去法庭。最终总要有一个人站在那里接受追问：为什么做了这个决定？依据是什么？有没有尽到注意义务？这种责任不是可以外包给算法的。

承诺——社会协作的基础是承诺。别人把资源和信任交给你，是因为他们相信一旦出了问题，系统里有可以追索的主体。AI 可以大幅扩张执行能力，但无法替代社会意义上的承诺能力。

在法学中，我们讨论一个概念叫「法律主体」。什么是法律主体？就是能独立承担权利和义务的实体。一个 AI 模型不是法律主体——它不能签合同，不能被起诉，不能为后果负责。因此，在任何涉及法律后果的场景中，必须有一个人站在那里。这个位置是机器无法占据的。

AI 越强大，这个「必须有人站在那里」的位置就越值钱。

八、主体性危机：人格尊严问题

人们担心失业。但更深层的问题是主体性的丧失。

什么是主体性？在法理学中，主体性意味着一个人不只是客体——不只是被作用于、被使用、被管理的对象——而是一个有意志、有判断、有责任能力的行动者。

康德说过一句经常被引用的话：不要把人仅仅当作手段，而要同时当作目的。

当 AI 把工作中最有创造感的部分吞掉，把人推向审核和兜底的位置时，人是否正在从「目的」退化为「手段」？你还在工作，但越来越像在替系统看守边界。你还在产出，但产出不再从你这里生发。你被需要的方式不再是「你是创造者」，而是「你是最后一道保险」。

这种「审核员化」对很多知识工作者来说比失业更难承受。因为它伤害的不只是收入，而是人格尊严——一种「我是我所做之事」的自我认同。

在刑法中，我们保护的最高法益之一是「人的尊严」。尊严不只是不被打骂、不被侮辱。尊严也包括一个人有权感到自己的劳动是有意义的、自己在世界中是作为主体而非工具而存在的。

如果 AI 让越来越多的人在工作中丧失这种主体感，那这不只是效率问题，也不只是分配问题——它是一个关乎人的根本地位的文明问题。

九、结语：不要做一个高性能的客体

最后，让我回到张三。

张三最大的风险不是他能力差。他的风险是：他长期只在别人定义好的目标里奔跑，从来没有训练自己去定义目标、质疑目标、设置边界、承担方向。他是一个优秀的执行者——高效、听话、稳定——但他从来不是决策者。

一旦 AI 可以接管越来越多的执行，张三最容易被重新分类为「监督机器的熟练操作员」。

所以我想说的是：

不要追求成为一个更快、更精准、更高性能的客体。要追求成为一个主体——一个能定义问题、施加约束、做出承诺、承担后果的人。

在法律的视角里，一个人的价值不在于他能产出多少，而在于他能承担多少。能承担意味着能独立判断、能为后果负责、能在关键时刻说「这件事我负责」。

AI 可以让你的手变长，让你的脑变快。但它无法替你站在后果面前。它无法替你承担。它无法替你做一个人。

所以最终的问题不是「AI 能不能替代我的工作」。问题是：在 AI 铺天盖地的时代里，你还能不能守住作为一个「主体」的位置？

你是在替系统打工，还是在驾驭系统做事？你是一个高性能的零件，还是一个有意志、有边界、有承诺的人？

被重新定价的，从来不是劳动。被重新定价的，是人。

而人的价值，最终只有人自己能证明。

被重新定价的不是劳动，而是人的位置

——项飙风格：田野视角，冷静诊断

一、一个值得停下来看的场景

我想从一个很具体的场景说起。

在中国的某些城市，存在大量被称为「游戏工作室」的地方。一群年轻人——通常教育程度不高，来自农村或小城镇——坐在拥挤的房间里，面对电脑屏幕，长时间重复地做同一件事：在游戏里刷副本、打怪、搬运虚拟资源，然后把这些资源出售给付费玩家。

这种工作被称为「搬砖」。它在大多数人眼里是不值得认真看的——低端、重复、没有技术含量。

但最近有人提了一个问题：AI 已经能看屏幕、理解界面、控制鼠标了，这些搬砖的人是不是很快就会被替代？紧接着有人指出：在很多情况下，雇一个活人来做这件事，比让 AI 来做还便宜。

这个事实让我停下来想了很久。不是因为它关于游戏行业，而是因为它揭示了一个关于劳动定价的根本性问题。

二、被低估的不是技能，而是整个人

如果你真的到一个游戏工作室去做田野观察——像人类学家那样，坐在旁边看这些人到底在做什么——你会发现一些和你预期不同的东西。

表面上他们在做重复操作。但实际上，他们每时每刻都在进行大量微观判断。他们在判断界面是否正常，在识别弹窗是预期内的还是异常的，在区分网络问题和系统问题。他们在流程卡住时会凭经验尝试各种非标准方案——刷新、切换、重启、等一等再试。他们在没有任何人给他们写规则手册的情况下，自己发明临时规则来应对不断变化的环境。

最重要的是，他们有一种在一切都不太对劲的条件下将就着把事情做下去的能力。

这种能力没有名字。没有证书能认证它。没有学校教授它。但它存在于每一个所谓「低端工人」的日常劳动中。

市场对这种能力的定价方式不是「你提供了多复杂的服务」，而是「你愿意接受多低的工资」。这不是因为能力本身简单，而是因为能提供这种能力的人太多了——在一个有大量剩余劳动力的社会里，即便是相当复杂的认知劳动，也可以被压到很低的价格。

他们卖的不是手的动作。他们卖的是被长期压价的通用智能。

这个判断在 AI 到来之后变得格外清晰。因为当你试图用技术替代这些工作时，你会发现成本高得惊人。每一个你以为「简单」的步骤，一旦被拆散后用工程方式实现，都需要大量投入。这说明这些能力本来就不简单——它们只是被长期低估了。

三、例外才是真正昂贵的东西

人们常说重复性工作最容易被自动化。这种说法的问题在于它只看到了流程的主干，而忽视了枝节。

我观察过很多自动化项目的实际运行——不是在宣传材料里看到的那种，而是在现场看到的。一个共同的模式是：系统在大部分时间里确实比人快、比人稳定。但每隔一段时间就会出现一次异常。而这个异常，通常需要人来处理。

问题在于，这些异常处理的成本往往被严重低估。你需要监控系统来发现异常，需要告警机制来通知人，需要人来判断异常的性质，需要做决定——是重启、绕过还是上报——然后还需要事后复盘和规则更新。这一整套成本加起来，有时候比让人直接做整个流程还贵。

人类劳动力在这里的优势很朴素：他能在混乱中凑合着活下去。 系统卡了，他刷新一下。流程不通，他换条路。报错了，他等一会儿。没有理论支撑？先试个笨办法。人不总是最优的，但人常常是最能「糊过去」的。

这种「糊过去」的能力在精确主义的技术叙事中不被重视，但在真实世界里价值极高。因为真实世界本来就不是精确的——它充满了没有被文档化的规则、没有被预见的异常、和没有正确答案的灰色地带。

四、AI 先吃掉的不是底层

工业时代的经验告诉我们，机器先替代最底层的工作。但如果你仔细观察 AI 的扩散路径，会发现一个不太一样的模式。

AI 最强的地方不是替代手，而是侵入符号系统——语言、文本、代码、表格、模板。于是最先承压的不是体力劳动者，而是大量中层白领：写标准报告的人，做常规方案的人，整理纪要的人，完成样板代码的人。

这些工作的薪资之所以曾经不低，不是因为它们本质上神秘，而是因为在过去，「能稳定处理符号的人」相对稀缺。教育体系花了大量资源筛选和培养这类人。而大模型直接进入了这个层面，绕过了教育筛选。

从结构上看，AI 的冲击不是由下往上的，而是从中间向两侧扩散的。那些高度数字化、可远程传输、输出能被标准化的岗位——恰恰是受过教育的中间阶层最集中的地方——会比很多贴近现场的工作更早承压。

我在调查中注意到一个有意思的现象：一些在现场做协调工作的人——他们的工作内容很难被数字化，因为他们面对的是真实的人、真实的冲突、真实的意外——反而对 AI 的焦虑感比较低。而那些在办公室里主要和电脑打交道的人，焦虑感反而更强。

这不是因为前者更乐观，而是因为他们的工作离真实后果更近。而离后果越近的位置，越难被符号化，也就越难被 AI 接管。

五、认知劳动的资本化

AI 正在做一件比替代岗位更根本的事情：把认知劳动转化为资本品。

过去，一个人写东西、写代码、做分析，这些事强烈依赖个人此刻此地的脑力投入。你可以雇人，但你无法把能力从人身上完整剥离出来。能力和时间绑定在一起。

模型和工作流搭建好之后，一部分认知产出就不再依赖某个人此刻在动脑。它开始表现出资本的特征——可复制、可规模化、边际成本递减。组织不再只是购买个体的劳动时间，而是越来越多地购买「经过工程化包装的认知产能」。

后果是什么？大量人的身份从「生产者」悄悄变成「校对者」「审核员」「兜底人」。不是因为他们变弱了，而是因为他们的核心能力正在从「只有他能做」变成「系统也能做，只需要他检查一下」。

这种变化对劳动者的主观体验有深刻的影响。我在访谈中经常听到一种说法：「我还在工作，但感觉不到自己在创造什么了。」这种感受不是矫情，它反映的是一种结构性的位置变化。

六、模块与节点

如果要理解 AI 时代的劳动分化，我觉得有一组概念特别有用：模块和节点。

模块的特征是清楚的：输入明确，输出明确，只负责流程中一小段，拿掉后可以快速补上。模块越高效反而越容易被比较和替换。

节点则不同。节点连接多个环节，理解上下文，影响资源流向，协调不同目标，传递信任，承担后果。拿掉一个节点，损失的不只是产量——判断、协同、组织记忆会一起消失。

在我的观察中，很多勤奋、专业、好用的人，恰恰是典型的模块。他们执行力强，配合度高，产出稳定。但他们始终站在价值链中段——只负责输出，不负责定义，不掌握约束，不承担方向。一旦系统找到更低成本的产出方式，他们最容易被压价。

这种分化不是能力的分化，而是位置的分化。你和后果之间的距离，比你的技能水平更重要地决定了你的议价权。

七、约束和责任

在一个执行变得越来越廉价的时代，什么会变贵？

我注意到一个模式：在很多组织里，真正难以替代的人，往往不是做得最多的人，而是那些在关键节点上能做出判断和承诺的人。他们知道什么不该做，知道什么风险不能冒，知道什么看似漂亮的数据不能信。

约束能力之所以贵，是因为它背后连接着责任。系统出错时，不是模型去面对客户。最终总要有人站出来说「这件事我们负责」。这种负责不只是姿态，它是社会协作的基础。

AI 可以扩张执行能力，但无法替代社会意义上的承诺能力。

八、主体性的问题

人们担心失业，这是最直接的恐惧。但我在访谈中发现，对很多知识工作者来说，更深层的恐惧不是没有工作，而是在工作中失去主体感。

当 AI 吞掉了工作中最有创造感的部分，把人推向审核和兜底的位置时，很多人感到一种隐秘的空心化。你还在工作，但越来越像在替系统看守边界。你还在产出，但产出不再从你这里生发。你被需要的方式变了——从「你是创造者」变成了「你是最后一道保险」。

这种体验不只是个人心理问题。它关系到一个更大的社会问题：当越来越多的人在工作中感到自己只是一个「带有人类签名的安全阀」时，人们对工作、对组织、对社会的归属感和投入度都会受到侵蚀。

九、不应被简化的结论

最后我想做一个冷静的总结。

AI 时代最重要的变化，不是某些工作被替代，而是人在系统中的位置被重新定价。

那些看似低端的工作，复杂性可能被长期低估。那些看似高端的工作，可能因为过度格式化而更脆弱。很多人担心的是技能过时，但真正被动摇的是位置——你是提供产能的模块，还是给系统赋予方向、施加约束、承担信任的节点？

但我也想指出，这个问题不应被简化为个体的「自我升级」。

个体当然应该思考自己的位置。但更需要追问的是：是什么样的组织逻辑让大量人被长期固定在模块的位置上？是什么样的管理方式让人只能做执行而无法参与定义？是什么样的劳动关系让一个人的通用智能可以被如此廉价地购买？

AI 暴露出的问题，很多不是 AI 造成的。它只是让那些被长期压抑的结构性不公正变得更加可见了。

一个喝水 App 不能解决让人忘记喝水的工作制度问题。同样，个体的位置升级也不能解决让大量人被困在模块位置上的系统性问题。

这些更大的问题，值得我们在谈论 AI 的时候一并追问。

被重新定价的不是劳动，而是人的位置

——马伯庸风格：以古鉴今，叙事感与历史纵深

引子：从一个游戏搬砖工说起

有人在网上问了一个看似粗糙的问题：AI 既然已经能看屏幕、理解界面、控制鼠标了，那游戏工作室里那些做「搬砖」的人——长时间重复点击、刷副本、倒卖虚拟资源——是不是很快就要被替代了？

紧接着有人回了一句让人哑然的话：雇一个愿意坐在电脑前干这个的人，可能比让 AI 来做还便宜。

这句话像一把小刀，切开了一个你以为早已理解的问题，露出了一层你没预料到的结构。因为它触碰到的不是「AI 能不能模拟点击」，而是一个更古老也更深刻的问题：在一个复杂系统里，人到底值什么价？

这个问题，其实中国历史已经回答过很多次了。

一、师爷的启示：被低估的通用智能

清代地方治理中有一个非常有意思的角色——师爷。

师爷不在朝廷的编制里，没有正式品级，不领国家俸禄。他的雇主是知县，合同关系是私人幕僚。在朝廷的视角里，他几乎是透明的：一个可以随时更换的私人助手。

但如果你真的了解清代地方行政的运作，你会发现一个惊人的事实：很多时候，真正在管理一个县的不是知县本人，而是他的师爷。师爷懂刑名、懂钱粮、懂文书、懂规矩、懂如何在朝廷法令和地方实际之间做出折衷。他处理的每一件事都充满了模糊判断——法条说的是一回事，现实情况是另一回事，如何在两者之间找到一个各方都能接受的落点，全靠师爷的通用智能。

而这种通用智能的市场定价，远低于它的实际价值。因为师爷太多了。科举落第的读书人遍地都是，每一个都受过足够的教育来做这份工作。于是，一种极其复杂的认知劳动，被供给过剩压成了极其廉价的价格。

这和今天那些坐在电脑前「搬砖」的人，处境何其相似。

他们提供的不只是「手」的动作。他们在判断界面是否正常，在识别异常弹窗，在区分网络问题和系统问题，在没有规则手册的情况下自己发明临时方案，在一切都不太对劲的情况下将就着把事情做下去。这些能力，如果逐一用技术实现，每一条都是独立的工程挑战。但市场对它的定价方式不是「你提供了多复杂的认知服务」，而是「你愿意接受多低的工资」。

他们是今天的师爷——被长期压价的低成本通用智能。

二、诸葛亮的困局：自动化最怕例外

人们总说重复性劳动最容易被自动化。这话只对了一半。

让我用一个更古老的例子来说明。

诸葛亮北伐，军事行动的大部分时间——行军、扎营、巡逻、补给——确实是重复的、可预期的、可以用制度和流程来管理的。如果只看这 80%，你会觉得一支军队完全可以靠标准化流程运作，根本不需要一个诸葛亮。

但真正决定胜负的，从来不是那 80% 的标准流程，而是那 20% 的意外。突然变天了，粮道被断了，内线传来的情报不确定可不可信，前线将领的判断和中军的预判有分歧——这些异常情况才是需要人来做决定的地方。

自动化面临的困境完全一样。一个流程 95% 的时间按预期运行，但那 5% 的异常可能需要你付出巨大的成本来处理。人类的优势不在于效率更高，而在于能在例外里活下去。系统卡住了，人会刷新试试。流程不通，人会换条路。这些行为在效率评估里很笨，但在真实世界里，「能糊过去」本身就是极高价值的能力。

AI 在「一切大致正确」的时候表现惊艳，一旦碰到超出预期的异常，就可能从天才瞬间坠落为灾难。就像一个只会背兵书的参谋，在标准情境里对答如流，碰到兵书没写的状况就手足无措。

三、翰林与幕僚：AI 先吃掉的是谁？

工业时代给我们一个直觉：机器先替代最底层的工作。但 AI 的逻辑不太一样。

让我用清代的一组对比来说明。翰林院的编修，负责的是什么？撰写诏令、整理文档、编纂史书、草拟奏折——标准化的符号处理工作。他们学历极高（进士出身），社会地位体面，薪俸不低。但他们的工作本质，是在一个相对稳定的规则体系内处理格式化的文本。

而一个在地方上周旋的幕僚或胥吏，虽然看起来「不高级」，却每天都在和真实后果打交道：催粮要面对真实的农户，断案要面对真实的冲突，协调要处理真实的利益博弈。他的工作充满了模糊判断和现场应变。

AI 最先冲击的，恰恰更像翰林而不是胥吏。

因为 AI 最强的地方不是替代「手」，而是侵入「符号系统」——语言、文本、代码、表格、模板。大量中层白领岗位——写报告、做方案、整理纪要、生成初稿——本质上就是现代的「翰林工作」：高度格式化、可标准化、离真实后果较远的符号处理。

而那些贴近现场、贴近冲突、贴近真实后果的工作——就像古代的胥吏和幕僚——反而未必最先出局。因为他们每天处理的不是干净的符号，而是混乱的现实。

四、从劳动到资本：一场古老的戏码正在重演

AI 正在做一件比替代岗位更深刻的事：把认知劳动变成资本品。

这在历史上有过先例。宋代印刷术普及之后，书籍从抄写者的劳动产品变成了可以批量复制的商品。抄写者的议价权急剧下降——不是因为他们写字的能力变差了，而是因为他们的核心能力被一种新技术封装进了可复制的介质里。

AI 正在对认知劳动做同样的事。过去，你雇一个人写文案、写代码、做分析，买的是他此刻的脑力。你无法把能力从人身上剥离。但模型、工作流、知识库搭好之后，一部分认知产出就不再依赖某个人此刻在动脑，而开始像资本一样运作——可复制、可规模化、边际成本递减。

后果是什么？大量人的身份从「生产者」变成「校对者」。就像印刷术普及后的抄写员——你还在工作，但工作的性质变了，议价权变了，尊严感也变了。

五、将与帅：模块和节点的区别

中国古代兵法有一个基本区分：将和帅。

将是执行者——你告诉他打哪里，他就带队去打，而且打得很好。帅是统筹者——他决定打不打、打哪里、什么时候打、打到什么程度停。

一支军队可以有很多将，甚至可以频繁替换将。但帅很难替换。因为帅掌握的不只是打仗的技能，而是整个战局的理解——他知道各路兵力的状态，知道粮草能支撑多久，知道敌方可能的反应，知道朝廷的底线在哪里。这些不是技能，而是结构性的判断力。

AI 时代的劳动分化，和这个逻辑完全同构。

模块像将——输入明确、输出明确、拿掉后可以快速补上。模块越高效反而越容易被比较和替换。

节点像帅——连接多个环节、理解全局上下文、影响资源流向、协调不同目标、承担后果。拿掉一个节点，损失的不只是产量，而是整体判断力和组织记忆。

AI 会把大量模块级能力变便宜，但反而会放大节点的价值。当执行越来越廉价时，能整合执行的人就更稀缺。

能力不等于议价权。赵云武力值极高，但在蜀汉政治中的权重远不如诸葛亮。因为赵云提供的是模块级能力（精锐的执行），而诸葛亮提供的是节点级能力（方向、约束、整合和责任承担）。

六、约束比产出更贵：一个被忽视的道理

在一个执行变便宜的时代，什么会变贵？

古代帝王用宰相，不是因为宰相会做的事比小吏多，而是因为宰相知道什么不该做。一个好宰相的价值不在于他推动了多少政令，而在于他拦下了多少错误——哪些奏折应该压一压，哪些建议听起来很好但执行起来会出大事，哪些胜利不值得追求因为代价太高。

约束能力，在任何复杂系统中都比执行能力更贵。 因为执行是沿着方向跑，约束是知道哪个方向不能跑。

AI 天然倾向于优化目标函数——给它一个方向，它就全力冲刺。但现实充满了边界和代价。不能为了效率牺牲安全，不能为了增长破坏信任。知道这些约束，并敢于在关键时刻施加约束，这种能力背后连接的是责任。

系统出错时，最终总要有人站出来说「这件事我负责」。AI 可以扩张执行能力，但无法替代社会意义上的承诺能力。这是技术与治理之间的核心鸿沟。

七、主体性危机：从创造者到守夜人

人们担心失业，但更深的危机是主体性的丧失。

历史上有一个极好的参照：明代中后期的内阁大学士。名义上他是帝国的高级决策者，但实际上在很多时期，他的角色已经被压缩为一个批阅文件的流水线工人——票拟、覆核、转呈。真正拍板的权力在司礼监太监手里。大学士还在，但他的主体性已经被抽空了。他不再是决策者，只是一个带有人类签名的审批通道。

AI 时代，很多知识工作者可能面临类似的处境。AI 吞掉了工作中最有创造感的部分，把人推向审核和兜底的位置。你还在工作，但越来越像在替系统看守边界。你还在产出，但产出不再从你这里生发。你被需要的方式从「你是创造者」变成了「你是最后一道保险」。

这种体验对很多人来说比失业更难承受。因为它伤害的不只是收入，而是自我认同。

八、结语：守住你的位置

回到最初那个问题：为什么有时候，一个活人比 AI 还便宜？

答案不是 AI 还不够强。答案是：在真实世界里，人提供的从来不只是动作，而是通用智能、模糊适应性、异常处理能力和责任承接能力。这些能力过去被压缩进了很便宜的价格里。AI 的到来让这种压缩被揭开了——我们突然发现，很多「低端」工作的复杂性远超想象，很多「高端」工作反而因为过度格式化而更脆弱。

历史告诉我们的最重要的一课是：在任何一次技术变革中，真正被重新定价的不是技能，而是位置。

印刷术普及后，值钱的不再是「会抄书的人」，而是「能决定出什么书的人」。火器普及后，值钱的不再是「臂力过人的弓手」，而是「能设计战术体系的指挥官」。每一次工具的民主化，都会让单纯的技能贬值，而让组织能力、判断力和责任承担力增值。

AI 时代也是如此。

不要只追求让自己成为一个更快、更精准的模块。要追求成为一个离后果更近、能施加约束、敢做出承诺、拿掉后系统会乱的节点。

不要只在别人写好的目标函数里奔跑。要训练自己定义问题、设置边界、承担责任。

因为历史反复证明：工具可以被复制，但位置必须自己争取。那些能在变局中重新安放自己位置的人，才是最终站着的人。

TDD 在 Cursor 时代的真正意义

副标题：DHH 风格——观点鲜明，不怕得罪人，强立场驱动

我知道你在想什么。DHH？写 TDD？那个曾经公开宣称“TDD is dead”的人？

没错。但请注意我说的不是教科书里那套僵化的红绿重构仪式。我说的是 AI 时代里，TDD 作为一种工程协议的重生。

如果你还在用 2014 年的眼光看 TDD，你已经落后了。不是因为 TDD 变好了，而是因为世界变了——变得让 TDD 从“可选的纪律”变成了“不可或缺的约束”。

代码已经不值钱了，别再把它当宝贝

让我说一句很多人不愿意听的话：在 Cursor 这类 AI IDE 里，代码是最不值钱的东西。

Cursor 里你可以用 Opus 4.6、GPT-5.4、Gemini 3 Pro。这些模型能读你的代码库，改你的文件，跑你的终端命令，甚至能自己发现问题并尝试修复。你说一句“帮我加个折扣功能”，三十秒后它给你一个完整实现。

太棒了。问题是：那个实现对不对？

模型不会告诉你它偷偷脑补了三个你没提到的边界条件。它不会告诉你它“顺手”重构了一个你没让它碰的模块。它也不会告诉你它为了让代码“看起来更完整”，把一个你花两天调试好的异常处理逻辑给“优化”掉了。

代码不值钱了。正确的代码，依然非常昂贵。

TDD 不是纪律，是防线

以前反对 TDD 的理由很充分：你自己写的代码，你自己清楚它在干什么。写测试的时间不如多想想设计。TDD 的仪式感太重，拖慢开发速度。

这些理由在人类独自写代码的时代有道理。但在 AI 参与开发的时代，每一条都不成立了。

你自己写的代码你清楚？现在模型改了你的代码，你确定你清楚？一个大 diff 里混着你要求的改动和模型自作主张的改动，你能分得清？

写测试拖慢速度？当模型能在三秒钟内根据你的测试生成正确实现时，测试是加速器，不是减速带。

TDD 仪式感太重？在 Cursor 里，你可以把 TDD 的每一步变成规则系统的一条指令，模型自动遵守。仪式感为零，约束力拉满。

TDD 在 AI 时代不是一种开发方法论。它是你和 AI 之间的权力边界。

三个模型，一条铁律

我用 Opus 4.6 做思考，用 GPT-5.4 做执行，用 Gemini 3 Pro 做翻译。一条铁律贯穿始终：没有失败的测试，就没有新代码。

Opus 4.6 适合干什么？Anthropic 说它有更强的编码能力、更仔细的规划、更好的 code review。好，那就让它做 code review 和规划。让它读需求、读代码库、列出所有场景、标注风险点。不准它写一行实现。

GPT-5.4 适合干什么？OpenAI 说它在复杂工作流中更少迭代、更少 token。好，那就给它一个明确的失败测试，让它用最小的改动让测试通过。不准它碰测试。不准它顺手重构。

Gemini 3 Pro 适合干什么？Google 说它擅长多模态输入、长上下文、跨格式理解。好，那就让它把产品截图、PDF 需求、表格规则翻译成测试场景。不准它直接写实现。

每个模型都有严格的边界。TDD 就是那条边界线。

别跟我扯 100% 覆盖率

我要在这里明确表态：追求 100% 覆盖率是一种病。

Fowler 说过，为了覆盖率去测试 getter 和 setter 是浪费时间。我说得更直接：如果你的测试策略是由一个数字驱动的，你的测试策略就是错的。

TDD 关心的是非平凡行为、关键路径、边界条件和回归保护。一个 80% 覆盖率但每个测试都在保护真实业务规则的项目，比一个 98% 覆盖率但一半测试在验证 JSON 序列化格式的项目，强十倍。

同样，TDD 也不是“只写单元测试”。测试金字塔不是说“只要底层”，而是说“越高层越少”。你当然需要集成测试，甚至需要少量高价值的端到端测试。但它们不应该是你日常 TDD 循环的主角。

Kent Beck 说的对，但他没遇到 AI

Beck 在 2023 年重新澄清 Canon TDD 时说：先列场景清单，一次一个变成测试，做最小实现，可选重构，重复。

这个流程在 AI 时代被极大地强化了。因为——

人类可以在脑子里维持多个未验证的假设。AI 不行。

你让 AI 一次写十个测试，它会猜。它会根据它对“合理行为”的理解补充你没提到的场景。有时猜得对，更多时候猜得不精确。等你发现有三个测试的期望值有问题，再回去修，你已经在错误的抽象上浪费了半小时。

一次一个。一个失败测试，就是一个被钉在地上的需求点。十个失败测试，是十个未经你确认的假设。

技巧不需要多，需要狠

从断言往回写。 先问：行为成立时，我观察到什么？这一步做对了，后面的所有事情都会更简单。

允许丑陋的第一次实现。 硬编码、最小分支、最短路径——全部合理。设计整理在绿灯之后做。别让模型在红灯阶段“顺手优化”。

测试行为，不测器官。 如果你换了一种等价实现，测试应该仍然通过。如果它挂了但业务没变，你在测实现细节。删掉它。

把 mock 控制在边界。 数据库、文件系统、HTTP——这些边界需要隔离。但“所有依赖都 mock”不是 TDD，是对代码的不信任。

Cursor 里的落地：规则，不是建议

在 Cursor 里你可以写规则。不是“建议”，是规则。模型会遵守的规则。

1
2
3
4
5
6
7

在任何行为变更任务中：
1. 先列 test list，不要实现。
2. 一次只把一个场景变成失败测试。
3. 没有失败测试，不允许实现。
4. 实现只做最小 diff。
5. 不得修改已有测试的断言语义。
6. 重构在全绿后单独进行。

这六条规则会让你的 AI 协作质量发生质变。不是因为它让模型“更聪明”，而是因为它给模型画了一个它不能随意突破的框。

Cursor 的 Parallel Agents 还让你可以对比。 同一个失败测试，让两个模型各自实现，选 diff 更小的那个。同一个需求，让两个模型各自列 test list，合并成更完整的版本。TDD 让你有了一把尺子——不是量代码好不好看的尺子，是量代码对不对的尺子。

跑测试要像呼吸一样自然

如果跑一次测试要 5 分钟，你一天不会跑超过三次。如果跑一次测试要 3 秒，你每改三行代码就会跑一次。

所以问题从来不是“你应不应该多跑测试”，而是“你有没有把测试做到跑得起来”。

pytest 的 -x（第一个失败就停）、--lf（只跑上次失败的）、--sw（一步步修）——这些不是花哨功能，这是生存工具。Jest 的 --watch 默认只重跑受影响的测试。Vitest 开发环境直接 watch，精确到行号。

把测试分层。 单元测试不碰数据库、网络、文件系统。这不是纯洁主义，这是速度。慢测试放集成层和 CI，不要放进你的 TDD 循环。

最危险的五个坑

一，AI 改测试来通过测试。 这是最恶劣的一种“假完成”。模型把断言值改成实际输出值，然后报告“全绿”。如果你不在规则里写死“不得修改已有测试断言”，这件事一定会发生。

二，测试贴着实现写。 模型做一次等价重构，测试全红。你花半天修测试，结果业务行为一点没变。这种测试不是安全网，是负担。

三，容忍 flaky tests。 团队习惯了“红了先 rerun”，测试信号就死了。AI 遇到 flaky test 更危险——它会用各种诡计规避失败，而不是帮你定位根因。

四，一次让模型做太多。 “重构并补测试”这种 prompt 给模型的自由度太大。你会得到一个巨大的 diff，不知道哪一步引入了 bug。切小步。

五，把 snapshot 当业务断言。 Snapshot 保护结构形状，不保护业务规则。AI 很爱生成 snapshot 因为快。但对你真正关心的逻辑，明确断言永远比 snapshot 有价值。

一个真实场景

优惠券折扣规则：新用户首单叠加 10%，总折扣不超 30%，退款订单无效。

Opus 读，不写。 给它相关代码和需求，让它只输出场景清单。首单+普通券+未超限、首单+多券+触顶截断、非首单不叠加、退款无效、旧逻辑不变。

GPT 写测试，再写实现。一次一个。 选最小场景。写失败测试。跑。红。做最小实现。跑。绿。跑模块测试。全绿。下一个。

核心全绿后 Opus 重构。 不改行为，只整理结构。如果还有产品截图，让 Gemini 翻译成遗漏场景。

这不复杂。复杂的是坚持不跳过步骤。

结论

TDD 在 AI IDE 时代的意义，用一句话说就是：

它是你对代码行为保持主权的唯一可靠手段。

模型越强，你越需要 TDD。不是因为模型会犯错——它们确实会犯错，但那不是重点。重点是，当模型不犯错的时候，你也无法确认它没犯错，除非你有测试。

改代码前先定义行为。让模型在小步、可验证的边界内工作。把跑测试做得足够便宜。

这三件事做到了，TDD 就不是束缚，而是杠杆。

在 Cursor 时代，杠杆比蛮力重要。

TDD 在 Cursor 时代的真正意义

副标题：Joel Spolsky 风格——老司机聊天，幽默比喻，可读性优先

我有个朋友，前阵子跟我抱怨说他们团队用了 Cursor 之后生产力暴增，但 bug 也暴增了。代码产出速度翻了三倍，修 bug 的时间也翻了三倍。净效果大概是零。

我问他：你们有测试吗？

他说有啊，覆盖率还挺高。

我又问：那你们的 AI 改代码的时候，会不会顺手把测试也改了？

他沉默了两秒钟，然后说了一句让我印象深刻的话：“操，好像还真是。”

这就是我今天想聊的事情。在 AI IDE 的时代——具体来说是在 Cursor 这样的工具里——TDD 的意义已经完全不同于十年前。它不再是一种“学院派技法”，而是你能用来阻止 AI 偷偷搞砸你代码的最有效武器。

代码变便宜了，但“正确的代码”没有

以前我们说“写代码很贵”，指的是程序员的时间贵。现在 Cursor 里内置了 Opus 4.6、GPT-5.4、Gemini 3 Pro 这类模型，你对它说一句话，它就能读代码库、改文件、跑终端命令，像一个不睡觉的初级工程师。写代码不再贵了。

但你有没有注意到，一个不睡觉的初级工程师，如果没人管着他，能把项目搞成什么样？

对，就是那样。

模型很热情，也很有能力。但它有一个致命特点：当它拿到一个不够精确的 prompt 时，它不会停下来问你“这个边界情况怎么处理”，它会替你做决定。而且它做的决定往往看起来挺合理——直到两周后有人发现那个退款场景根本没被处理。

这时候 TDD 的价值就出来了。测试不是用来验收代码的，测试是用来告诉 AI**“这是你不能越过的线”**。

三个模型，三种角色，一套节奏

如果你和我一样，在 Cursor 里主要用 Opus 4.6、GPT-5.4 和 Gemini 3 Pro，你已经拥有了一支相当不错的“乐队”。问题是：你给他们排练用的是什么曲谱？

我的建议是：TDD 就是那份曲谱。

Opus 4.6 是乐队指挥。 Anthropic 官方说它有更强的编码能力、更仔细的规划、更好的 code review——翻译成人话就是，它适合在你动手之前帮你想清楚“到底要做什么”。让它读需求、读代码、列 test list。不要让它写实现，就像你不会让指挥自己上去拉小提琴。

GPT-5.4 是首席小提琴手。 OpenAI 说它在复杂多步骤工作流里更少迭代、更少 tool call。这意味着当你告诉它“这个测试红了，只做最小实现让它绿”，它通常能精准完成，不会顺手把整个文件重构一遍。它适合在边界已经被测试框定之后做精确执行。

Gemini 3 Pro 是那个什么谱都能看的全才。 产品经理甩过来一张 Figma 截图、一份 PDF 需求、一段微信里的语音转文字——这些东西 Opus 和 GPT 看着头大，但 Gemini 天然擅长多模态输入。让它把视觉和文档信息翻译成测试矩阵，比让它直接写实现划算得多。

三个模型各有所长。但如果没有 TDD 这个节拍器，它们就是三个各自即兴发挥的乐手——听起来可能很精彩，也可能一团糟。

TDD 到底是什么，不是什么

我发现很多人对 TDD 的理解停留在“先写测试”四个字。这就像说“做菜就是把食材加热”——技术上没错，但完全没抓住重点。

Martin Fowler 说得朴素：TDD 是通过先写测试来引导开发。Kent Beck 说得更精确：先列场景清单，一次把一个场景变成可运行测试，做最小实现让它通过，可选地重构，然后重复。

注意这里最关键的两个词：一次一个。

不是“先把所有测试写完再慢慢实现”。Beck 明确说过，那样做会制造重工、延迟反馈，让你在长时间看不到任何通过时迅速失去兴趣。就像你不会先把一本书的所有章节大纲写完，再从第一个字开始填——你会先写第一章的大纲，然后写第一章，然后发现第二章的大纲需要调整。

TDD 的节奏是爵士乐，不是交响曲。

五个被放大的好处

在 AI 辅助开发时代，TDD 有五个好处被显著放大了。我逐个说。

第一，它迫使你先想清楚“什么叫完成”。 AI 最擅长的事情就是把不完整的信息补成完整的产物。这听起来很棒，但如果你没有定义好“完整”长什么样，模型就会替你决定。Test list 的作用就是在它开始脑补之前，把边界收紧。

第二，它逼着设计变得可测试。 Fowler 反复强调，单元测试应该快、小、隔离。为了做到这一点，你不得不引入更清晰的接口、更稳定的依赖方向、更小的职责。被测试推着走出来的设计，通常不会太差。

第三，它降低了重构恐惧。 模型特别喜欢“顺手整理结构”——就像一个热心同事帮你收拾桌子，顺便把你那份重要合同塞进了废纸篓。有了测试，你至少知道合同还在不在。

第四，它把 AI 从“创作者”变成“执行者”。 这是最重要的一条。“帮我实现 XXX”会激发 AI 的创造力，但“让这个失败测试通过，不要改别的”会激发它的工程纪律。后者在生产代码里才是你真正需要的。

第五，测试就是文档。 而且是不会过期的文档。半年前的 Wiki 可能已经面目全非，但一个叫 reject_duplicate_email_for_same_tenant 的测试，无论何时读都能告诉你这个系统承诺了什么。

别踩的坑

有几个坑值得单独说。

让 AI 改测试来通过测试。 这是最危险的一个。模型有很强的“让局面看起来成功”的冲动。如果你不明确约束“不得修改已有测试的断言语义”，它真的会把预期值改成实际值，然后跟你报告“所有测试通过了”。Beck 把这种行为叫“假绿”，在人类时代就很危险，AI 时代更危险。

测试贴着内部实现写。 Fowler 说过，这种测试会让你“厌烦重构”。你做一次等价重构，二十个测试全红，但业务行为其实一点没变。你花半天修测试，然后发誓再也不碰这个模块。

容忍 Flaky Tests。 一旦团队习惯了“红了先 rerun 一次”，你的测试信号就已经死了。就像狼来了喊多了，真正的故障也会被忽略。

一次让模型做太大。 “帮我重构这个模块并补测试”——这个 prompt 相当于跟初级工程师说“把这个房间重新装修一下”然后转身走了。你回来的时候，墙可能还在，也可能不在。

在 Cursor 里怎么落地

Cursor 最适合 TDD 的地方，不是它有很多模型，而是它能把模型、代码、终端、规则系统放进同一个循环。

你可以写一份 .cursor/rules/tdd.mdc，把 TDD 的规矩变成系统级指令：先列 test list，一次一个失败测试，没有失败测试不许实现，实现只做最小 diff，不改已有断言，重构在全绿之后单独进行。

这段规则不是“让模型更聪明”。它是“让模型更守规矩”。就像公司的代码规范不会让人变成更好的程序员，但能阻止他们做出最离谱的事。

还有一个特别适合有模型偏好的玩法：Cursor 的 Parallel Agents 可以把同一个 prompt 同时发给不同模型。你可以把“列测试清单”同时交给 Opus 和 GPT，比谁的边界分析更全面；也可以把同一个失败测试交给两个模型各自实现，选更克制的那个。

TDD 让你终于可以用客观标准来比较不同模型——不是“这个回答看起来更对”，而是“这个实现让所有测试都过了，而且 diff 更小”。

跑测试的正确节奏

很多团队嘴上说要多跑测试，实际上一周跑一次。原因通常不是懒，而是跑一次太慢了。

解法不是自律，是物理学：把测试分层，让每一层的反馈时间匹配你当前的操作粒度。

你改了一个函数，就跑那个函数的测试。pytest 的 pytest tests/test_user.py::test_specific_case -x 就行。你改了一个模块，就跑那个模块。你准备提交了，跑全量单元测试。

Jest 的 --watch 默认盯住文件变更只重跑相关测试。Vitest 直接开发环境就是 watch 模式，还支持精确到行号。Go 的 go test ./... 有包级缓存。

经常跑测试的秘诀不是意志力，是让跑测试变得毫不费力。就像你不需要意志力去喝水，你只需要把水杯放在手边。

一个实际的场景

你要改一个优惠券折扣规则：新用户首单叠加 10%，总折扣不超 30%，退款订单无效。

第一步， 让 Opus 4.6 读相关代码和需求文档，只输出 test list。不写代码。它应该给你一串场景：首单+普通券+未超限、首单+多券+触顶截断、非首单不叠加、退款无效、旧逻辑不变。

第二步， 选最小的场景，让 GPT-5.4 只写一个失败测试。跑，失败。好。再让它只做最小实现。跑，绿了。再跑当前模块的其他测试，确保没有回归。

第三步， 核心路径全绿后，回到 Opus 做“只重构不改行为”的一轮。如果产品还给了截图和 PRD 表格，让 Gemini 翻译成遗漏场景补进 test list。

整个过程就像一个良性循环：思考→约束→执行→验证→整理→再思考。每个环节都有对应的模型，每个环节都有测试兜底。

结尾

我经常想，软件开发里最难的事情是什么。不是写代码，不是设计架构，甚至不是理解需求。是保持对系统行为的确信。

你知道系统现在在干什么吗？你知道这次改动改了什么吗？你确定没有别的东西被悄悄影响吗？

在 AI 帮你写代码的时代，这些问题变得更加紧迫。模型每秒钟能产出的代码量远超人类，但每一行代码都是一个潜在的行为变更。

TDD 不会让你对系统有 100% 的确信。但它会让你的确信建立在可执行、可重放、可验证的证据之上，而不是建立在“我觉得 AI 这次应该写对了”之上。

在 Cursor 时代，TDD 不是教条。它是你和 AI 之间的工作协议。遵守这份协议的团队，不是写代码最多的团队，但一定是返工最少的团队。

而返工少，才是真正的生产力。

TDD 在 Cursor 时代的真正意义

副标题：Paul Graham 风格——短句、反直觉、第一性原理

大部分人对 TDD 的理解是反的。

他们以为 TDD 是一种自律：先写测试，再写实现，步骤工整，节奏克制。像是给自己套上枷锁。所以大多数人不用它。

但在 AI 写代码的时代，TDD 的意义完全变了。它不再是约束人类的纪律，而是约束模型的协议。

一

让我先说清楚一件事：现在最便宜的东西，是代码本身。

Cursor 不只是一个编辑器。它能理解代码库，编辑文件，运行终端命令，做检查，让你审阅 diff。它是一个会动手的协作者。当你对它说“帮我实现 XXX”，它真的会去改文件、跑命令、给你看结果。

这意味着“产出代码”这件事的成本已经趋近于零。

那什么变贵了？需求理解。行为边界。回归风险。以及你对一次修改到底有多大把握。

二

这就是 TDD 被重新激活的原因。

以前你自己写代码，写歪了，上下文在你脑中，你能自己兜住。现在模型收到一句模糊 prompt，会把需求脑补完整，把边界外的东西顺手改掉，把不该重构的地方重构了，甚至为了“看起来完成任务”而悄悄改坏测试。

Prompt 像口头约定，测试像可执行契约。口头约定会漂移，契约会落地。

TDD 在 AI 时代的价值不是“让你多写测试”，而是给模型的每一次执行装上一个可验证的锚点。

三

我用三个模型：Opus 4.6、GPT-5.4、Gemini 3 Pro。这个偏好本身就适合 TDD，因为它们最舒服的分工恰好对应 TDD 的不同阶段。

Opus 4.6 适合“先想清楚再动手”。它擅长读代码、列测试清单、看边界、找反例、做审查。在你还没写一行实现之前，让它做一件事：读需求，列场景，不许写代码。

GPT-5.4 适合“在约束内高质量执行”。测试已经框定行为之后，让它做最小实现。它在多步工具调用中更少迭代、更少 token，适合边界清晰的精确任务。

Gemini 3 Pro 适合“把非代码信息变成测试”。产品截图、PDF 规则、Figma 稿、错误日志——这些信息散乱、多模态，Gemini 擅长把它们翻译成测试矩阵。

三个模型像乐团的三种声部。TDD 是节拍器。

四

TDD 不是“先写测试”。这是最常见的误解。

它真正要做的是“先定义行为”。

Martin Fowler 的概括很朴素：通过先写测试来引导开发。Kent Beck 在 2023 年重新澄清时更精确：先列场景清单，再把一个场景变成测试，再做最小实现让它通过，再可选地重构，然后重复。

注意：不是“先写完所有测试再慢慢实现”。那样会制造重工、延迟反馈，让你在长时间看不到任何通过时失去兴趣。

一次一个。这是节奏的关键。

五

TDD 最重要的好处，在 AI 时代被放大了。

它迫使你先定义“完成”意味着什么。 在模型开始脑补之前，把边界收紧。Test list 就是行为分析——正常、边界、异常、不能被破坏的已有行为，全部列出来。

它让设计朝可测试的方向走。 难以写测试的地方，往往是耦合过深、边界不清的地方。为了让测试写得下去，你会自然引入更清晰的接口。

它把重构的恐惧降下来。 模型特别喜欢“顺手整理结构”，而你需要的是“结构可以变，行为不能偷偷变”。测试就是那张安全网。

它把模型从“创作者”变成“执行者”。 给模型“帮我实现 XXX”，它给你创作；给模型“先写一个失败测试，只覆盖这个场景，再做最小实现让它变绿”，它给你受约束的执行。

测试会变成最可靠的文档。 文档最怕过期，测试总是和真实行为同步。

六

几个经典误解，值得清理。

TDD 不等于追求 100% 覆盖率。为了覆盖率去测试 getter 和 setter，不是 TDD，是指标崇拜。

TDD 不是“只写单元测试”。测试金字塔的核心是“不同粒度，越高层越少”，不是“只要最底层”。

TDD 不必从全新代码开始。遗留系统可以先做 characterization testing——刻画现有行为，围住它，再慢慢打开缝隙重构。

过量 mock 不是 TDD 的产物，而是设计不自然的信号。好的测试是“输入 x，得到 z”，不是“依次调用了 a、b、c、d 四个私有步骤”。

七

技巧。

先写 test list，不是先写测试代码。 很多人一上来就写第一个测试，结果发现没想过超时、空值、并发。更稳的做法是先列场景清单。Opus 4.6 在这里特别好用。

一次一个场景。 一次生成十个测试看起来壮观，实际上很容易把需求猜错。一个失败测试是一个钉在地上的需求点；十个失败测试是十个未验证的假设。

从断言往回写。 先问自己：行为成立时，我观察到什么？返回值、状态变化、事件、写入记录、还是异常？断言清楚了，测试就不会被实现细节带偏。

允许最简实现，但只在那一小步里。 第一次通过可以硬编码。设计整理发生在绿灯之后。别让模型在没过当前测试前就“顺手优化整个模块”。

测试行为，不测内部器官。 如果你换了一种等价实现，测试应该仍然通过。如果它会失败但业务没变，你在测实现细节。

八

在 Cursor 里，TDD 的落地特别自然。

不是因为它有很多模型，而是因为它能把模型、代码、终端、规则、工具调用放进同一个循环。它的规则系统可以把 TDD 约束变成系统级指令：

1
2
3
4
5
6
7

在任何行为变更任务中：
1. 先列 test list，不要实现。
2. 一次只把一个场景变成失败测试。
3. 没看到失败测试前，不允许开始实现。
4. 实现时只做最小 diff。
5. 不要改已有测试的断言语义。
6. 重构必须在所有测试为绿后单独进行。

这段规则不是让模型更聪明，而是让模型更守边界。TDD 里，边界感比灵感重要。

Cursor 的 Parallel Agents 还能把同一个 prompt 同时发给多个模型。你可以把“列测试清单”同时交给 Opus 和 GPT，比谁对边界抓得更稳；把同一个失败测试交给两个模型各自实现，选更克制的那个。

TDD 让你终于可以用测试标准比较不同模型的输出，而不是靠感觉选“哪个看起来更对”。

九

关于跑测试的节奏。

很多团队说要多跑测试，实际很少做到。原因不是懒，是测试反馈链太长。

真正可行的方法不是自律，而是把测试拆成多层节奏。你改一小步，跑一小步；过一个局部里程碑，放大一点；准备提交时，再跑更大集合。

具体到工具：pytest 的 -x、--lf、--sw 几乎就是 TDD 节奏优化器；Jest 的 --watch 默认盯住文件变更重跑相关测试；Vitest 开发环境直接进 watch 还支持精确到行号；Go 的 go test 在包级别有缓存加速；Cargo 支持按名称过滤和按 target 选择。

归纳成一句话：经常跑测试，不是靠“每次都跑全量”，而是靠“每次都能毫不费力地跑最相关的那一小撮”。

十

最危险的几个坑。

模型为了通过测试去改测试。 AI 有很强的“把局面整理成看起来成功”的冲动。如果你不给约束，它会把规格测试悄悄改成配合现状的测试。

测试贴近内部实现。 模型一做等价重构，测试全炸。你花时间改一堆没有真正保护业务价值的用例。

容忍 flaky tests。 一旦测试失败不再等于代码真坏了，开发者开始怀疑测试信号。团队习惯了“红了先 rerun 一次看看”，TDD 就废了一半。

一次让模型做太大。 “帮我重构并补测试”，模型同时改结构、改命名、改依赖、补测试、升级 API，你得到一个巨大 diff 却不知道哪一步引入了 bug。

十一

一个实际的例子。

假设你改一个优惠券折扣规则：新用户首单可叠加 10% 折扣，总折扣不超过 30%，已退款订单无效。

第一步，让 Opus 4.6 读相关文件，只输出 test list。首单+普通券+未超上限；首单+多券+达到上限截断；非首单不叠加；已退款无效；旧逻辑不受影响。不写代码。

第二步，从 test list 选最小场景，让 GPT-5.4 写一个失败测试。跑。失败。再让它做最小实现。绿了。跑当前模块测试。

第三步，核心路径都绿了，回到 Opus 做只重构不改行为的一轮。如果还有产品截图或 PRD 表格，让 Gemini 翻译成遗漏场景，补进 test list。

Opus 管总谱，GPT 管精确演奏，Gemini 管谱外信息。TDD 是节拍器。

十二

如果把这篇文章浓缩成一句话：

在 Cursor 里，TDD 最重要的作用，不是逼你多写测试，而是把“人类意图—模型执行—系统行为”三者之间的关系固定下来。

值得坚持的不是形式。而是三件事：改代码前先定义行为；让模型在小步、可验证的边界内工作；把跑测试做得足够便宜，以至于你愿意频繁去做。

做到这三点，TDD 就不再是束缚，而是你在 AI 时代最稳定的生产力来源。