AI 时代,让自己慢下来

锡箔大佬在群里调侃,当前 AI 时代,只要你学得慢,你就不用学了。

是的,AI 发展太快了,回望去年的这个时候,我们写代码的方式还不一样,问问题的方式还不一样。

我不是焦虑效率的问题,也不是那种怀旧式的「古法编程才有灵魂」。我想的是:当生成成本持续下降,一个工程师最稀缺的能力,正在从「产出内容」快速转移到「做判断」。判断接口该不该拆,技术债该不该还,需求方嘴里的「必须」到底有多必须,模型给出的十种方案里哪一种能进生产,哪一种看上去漂亮、上线就炸。

这些事情,AI 没替我们做。相反,它把问题放大了。

因为现在最大的问题不再是「不会做」,而是「太容易做」。不会做的时候,人天然会慢一点,会查资料,会多问一句依赖边界,会想清楚为什么。太容易做的时候,团队最常见的路径就是:先生成,后理解;先上线,后治理;先把东西拼起来,再假设以后有时间收拾。

然而,「以后」通常没有以后。

越发觉着:AI 时代我们应该给自己保留一块慢思考的区域。这个「慢」不是拖延,不是低效,也不是故作深沉。它是一种刻意建立的认知阻尼:在系统已经足够快的时候,给判断过程增加必要的摩擦,避免人被工具的流速裹走。

那应该在哪里慢呢?

第一类,涉及不可逆成本的决策。架构选型、数据模型、权限边界、组织职责划分、供应商绑定、长期协议、核心链路改造,这些事情一旦定错,后面修复成本不是线性增加,而是指数级外溢。这里多花的两天,常常能省掉半年。

第二类,涉及复杂因果的问题。线上事故、质量下降、组织失灵、协作冲突、项目延期,这些问题都很讨厌,因为表象清楚,因果混乱。你以为是人不行,实际是流程激励错了;你以为是系统不稳,实际是变更策略太激进;你以为是模型效果差,实际是评测集污染了。这里如果追求快,通常只会更快地走向错误归因。

第三类,涉及个人能力沉淀的问题。写作、复盘、独处、长时间运动,我都把它们看成工程能力的一部分。它们看上去不产出代码,也不直接提升 QPS,但它们在训练更底层的东西:抽象能力、因果判断、注意力稳定性、抗噪能力。

「慢」也不是对抗效率,它是在给不同问题分配不同的时钟频率。流水线可以高频,人脑不能一直高频。CPU 长时间拉满会降频,人也一样。

如果有人问如何让自己慢下来,我觉得可以试试「写作,跑步,独处」

如果让我只保留一种慢思考训练方式,我大概率会选写作。

写作有几个好处。第一,成本低。你不需要设备,不需要场地,也不需要别人配合。第二,反馈直接。你只要写到第三段,就会发现自己到底有没有想清楚。第三,它能留下痕迹。很多模糊的感受,过几个月再回头看,你能看到自己当时的盲区和惯性。

作为技术人可以写些什么?个人觉得可以写如下的三类:

一类是方案备忘录。不是给别人看的那种完整文档,而是给自己看的判断草稿。问题是什么,已知事实有哪些,未知变量有哪些,我现在倾向哪个方案,为什么,最大的风险是什么,什么证据会让我改变主意。字不用多,关键是强迫自己把判断摊开。

一类是事故后记。不是标准复盘模板,而是写自己当时的认知过程。告警出现时,我第一反应是什么;我为什么排除了某条线索;我在哪个时间点开始被带偏;哪些历史经验帮了我,哪些历史经验害了我。这种东西写多了,慢慢会形成个人的故障判断档案。

还有一类,是长期主题写作。比如我们持续观察 AI 对研发组织的影响,或者持续观察某种架构范式在公司里的落地摩擦。这个过程很像做一个长期实验。每写一次,你都在更新自己的认知模型。它的回报不是立刻可见,但一年以后,你和大多数只看热闹的人会拉开明显差距。

写作最大的价值,是它逼你把借来的观点变成自己的结构。很多人平时听播客、看文章、刷帖子,输入很多,但脑子里一直是别人搭好的脚手架。只有自己写,才知道哪些梁是空的。

现在的信息环境非常密集。微信、钉钉、飞书、邮件、群消息、监控告警、PR 评论、AI 对话框,人的注意力被切成很多片。更麻烦的是,AI 还在不断提供一种幻觉:只要你卡住了,马上可以问,马上有回应,马上有一个差不多能用的答案。

久了之后,人会失去和一个难题长时间待在一起的能力。

而很多真正重要的问题,都不适合马上回答。一个组织为什么在扩张后决策质量下降,一个平台为什么越做越重,一个团队为什么开始迷恋短平快,一个技术负责人为什么明明很忙却越来越没有关键产出。这些问题都需要没有输入干扰的时间。你要让问题在脑子里发酵,要允许一些不舒服的空白存在。

AI 时代,人越来越容易只活在符号系统里:文档、消息、代码、表格、指标、提示词。跑步这种事的价值,在于让你暂时脱离符号洪流,回到一个更低带宽、但更连续的状态。这个状态对思考质量很重要。

当然,不一定非要跑步。长距离步行、游泳、骑行,甚至一个人安静地做家务,都可能进入类似状态。关键不在运动形式,在于持续、低干扰、有节律。

上面这些动作最终都是为了让自己有更好的判断力。

那如何构建判断力?

经常有人说「多见世面就有判断力」。这么说是有点空的,判断力当然和经验有关,但经验要看是怎样的经验。一个人做了十年项目,也可能只是把一年的经验重复了十次。

所以判断力要长出来,我觉得至少需要四样东西。

第一,能区分事实、解释和决策。浅一点,就像我和娃经常说的,这是一个观点还是一个事实。

第二,多想几步。

第三,能在不完整信息下做下注,决策。

第四,能复盘自己的错判。

就个人来说,一直在坚持的也就是写作了:

写作。不是为了发什么,也不是为了做内容号,也不是为了经营人设,就是把脑子里的判断落到纸面上。很多混乱的感觉,落到纸面上就清晰了。同时也是为了让有一个固定的和 AI 独处的时间。

我对「ai 时代,让自己慢下来」的理解,大概就是这么个意思:该快的地方拼命快,该慢的地方死守住。别把自己的大脑训练成一个只会接提示、吐结果的中转器。工具越来越强,人更不能放弃那部分缓慢、笨重、但决定上限的能力。

很多年后回头看,一个工程师、一个技术负责人,判断其能力强弱,大概率都不在他一小时能生成多少内容,而在他面对复杂局面时,能不能稳住,能不能看深一层,能不能在一堆看似正确的答案里,挑出那个真正应该做的决定。

这个能力,快不出来。

后记:

其实这篇文章也是在早上慢慢骑车的时候,忽然蹦出来的一个想法,周六还在想这周写点什么呢。

慢一点,也好。

以上。

从 AI 的本质聊 AI 对组织的影响

这一轮 AI(LLM),引发了组织的变化,不限于裁员,裁员只是一个表象,根本的逻辑是组织里「信息如何流动」「决策如何形成」「责任如何落地」这些变了。我们所看到的多了一个写文案、写代码、做 PPT 的工具,或办公室里多了几个自动化插件等等只是改变过程中的一些小的细节。从改动的范围来看,可以看到改了分工边界,改了岗位能力结构,改了系统设计方式。

LLM 的本质是概率,而组织的运行机制长期建立在确定性流程之上。两者天然有张力。

我们先从这个张力聊起。

AI 的概率

LLM 本质上在做什么,其实没那么复杂。它不断预测下一个 token 的概率分布,然后选一个输出。工程上当然有大量细节,训练、对齐、采样、上下文窗口、推理优化,全都很重要,但如果站在组织设计和系统设计的角度看,本质抓这一条就够了:它是一个基于统计规律生成结果的系统,不是一个内置事实表的确定性引擎。

这种概率会带来三种情况。

第一,它擅长处理语言空间里那些「没有唯一标准答案,但存在高质量分布」的问题。写一封邮件、总结会议纪要、整理需求文档、把一段含糊的人话翻译成结构化任务、把一段自然语言转成代码、把代码转成测试思路,这些都在它的甜品区里。因为这些任务的目标,通常不是 100% 唯一真值,而是「大致正确、结构合理、表达顺畅、足够可用」。

第二,它天然会出错,而且错误方式不稳定。这个不稳定比单纯出错更麻烦。传统程序的 bug,很多时候是可复现的;概率系统的错误,经常和上下文、提示词、检索片段、采样参数甚至前面对话历史相关。你今天问它一个问题答对了,明天换个表述可能就偏了。组织里一旦把这类系统直接挂到核心流程上,没有护栏,事故几乎是必然事件。

第三,它的价值密度和上下文质量高度相关。LLM 不是知道很多事,它是「在给定上下文里,尽量生成一个看起来最合理的延续」。上下文差,输出就漂;上下文乱,输出就幻觉;上下文冲突,输出就迎合最新、最强、最显眼的片段。很多团队说模型不行,实际问题常常不在模型,而在输入的上下文是脏的、散的、旧的。

所以我不太赞成把 LLM 讲成一个无所不能的智能体。它先是一个概率生成器,然后才有机会在工程体系的约束下,表现出接近「助手」「代理」「协作者」的形态。顺序不能反。顺序一反,组织判断就会出偏差。

AI 擅长什么

AI 擅长处理「高信息密度、强语言接口、允许一定容错」的工作。

这句话可以分成三层。

先看「高信息密度」。很多工作不是体力活,也不是纯计算活,而是信息压缩和信息展开。比如把一小时会议录音压成一页决策摘要,把十几页 PRD 展开成研发任务清单,把客服历史对话归纳成问题分类,把一段用户吐槽整理成产品缺陷候选列表。这里面的核心动作,是抽取、改写、重组、归纳、补全。这些正好是 LLM 的长项。

再看「强语言接口」。凡是系统入口是文字,或者能被文字中介的任务,LLM 都容易插进去。人和人之间的沟通是这样:邮件、会议纪要、汇报材料、招投标文档、制度说明、客服回复、法务初稿。人和机器之间也一样:代码、SQL、脚本、配置说明、API 调用说明、测试用例、运维排障问答。语言是组织里成本最低的通用接口,LLM 恰好是一个超强的语言接口适配器。

最后是「允许一定容错」。这个很关键。生成营销草案,错一个措辞问题不大;会议纪要漏掉一个次要背景,人工补一下也能过;代码写得不优雅,工程师重构即可。可一旦到了财务记账、医学诊断、风控审批、合规审查、生产数据库变更,容错空间急剧收窄,这时单靠 LLM 就不成立了,必须引入外部约束和确定性校验。

很多人喜欢问:AI 最适合创新吗?它在很多场景里看起来有创造力,本质上还是在高维语料分布里重组已有模式。你把它放在头脑风暴、方案发散、草稿生成、风格迁移这些位置,它常常很好用;你让它承担关键判断、原创理论、复杂博弈中的最终拍板,就容易高估。组织里最危险的一种误判,就是把「表达上的流畅」误当成「认知上的可靠」

幻觉成本

既然本质是概率,幻觉就不是偶发现象,而是系统特性。工程上不能用「尽量减少幻觉」这种空话处理,得把它转成成本模型。

AI 输出错误带来的成本可以分成四档。

第一档是可忽略成本。比如内部 brainstorm、文案初稿、十几种标题备选、图片风格探索、非正式知识问答。这里错了,最多浪费几分钟。这个区间可以大胆上,用得越多收益越明显。

第二档是可复核成本。比如需求摘要、代码初稿、测试建议、客服回复草稿、制度文件初稿。AI 先出,人再审。这里的关键不是「AI 准不准」,而是「人工审核的单位成本有没有明显下降」。如果 AI 生成 10 分钟、人工审 15 分钟,比纯手工还慢,那系统就没有价值。

第三档是高代价成本。比如财务报表解释、合同条款分析、生产事故归因、管理层决策备忘、对外承诺邮件。这里可以用 AI,但只能把它放在材料整理、信息召回、风险提示、版本比较这些环节,不能让它直接输出结论然后裸奔进入流程。

第四档是不可接受成本。比如自动放款、自动诊断、自动封禁、自动执行线上高危操作。这个区间里,AI 可以当辅助组件,不能当最终裁决者。谁要是说可以靠 prompt 把风险压下去,我建议他先自己签事故责任书。

很多 AI 项目上线后口碑崩掉,不是因为模型太弱,而是因为组织没有做这四档划分,把一个只能承受第一、第二档错误的系统,硬塞进第三、第四档流程里。然后一出事故,大家又反过来得出一个结论:AI 不靠谱。这个结论也粗。不是 AI 靠不靠谱的问题,是你把概率系统放错了位置。

语言接口

AI 先改变的是沟通层。

组织里大量时间,其实消耗在信息传递损耗上。会议里讲一遍,纪要里写一遍,IM 再同步一遍,邮件里再确认一遍,系统里再录一遍。每传一次,信息就损耗一次。很多管理动作看起来是流程,底层其实是语言重编码:同一个事实在不同角色之间用不同表达方式重复流动

AI 它能把组织内部大量低效的语言重编码吞掉。

比如会议。以前最常见的问题不是没人开会,而是会开完之后没人知道结论是什么、责任人是谁、时间点是什么。AI 介入之后,会议纪要生成只是最表层的能力,真正有用的是把会议内容自动结构化成「决策」「待办」「风险」「争议点」「需要补充的数据」。再往前走一步,它还能把这些结构化结果投递到项目系统、工单系统、邮件系统。这样一来,会议不再只是一次同步动作,而是流程触发点。

再比如客服。传统客服系统里,知识库维护和话术更新一直是重活,因为产品变化快、用户问题脏、运营表达不统一。AI 能做的不是简单替代客服,而是在对话中动态把用户语言映射到组织内部知识表示,再反过来生成可发送的话术。这里的重点在映射,不在生成。生成只是最后一公里。

文件和邮件也是同理。大量中层管理者的工作,本质上就是把上层要求翻译成执行语言,再把执行结果翻译成汇报语言。这种岗位在 AI 时代不会消失,但能力要求会变。以后拼的不是谁更会写四平八稳的材料,而是谁能把复杂上下文压成清晰约束,再让 AI 快速出一个高质量草稿,然后自己做判断、修正和承担责任。

我自己的观察是,组织里越依赖文字流转的部门,越早感受到冲击。产品、运营、市场、售前、客服、法务、人力、PMO,变化都会很快。研发部门也会变,但方式不同,因为研发除了语言,还有执行环境、依赖关系、可验证结果。

代码接口

人和机器的沟通,影响更深。

写代码这个场景特别有代表性,因为它处在语言和确定性的交界处。你可以用自然语言表达需求,再把它落成代码;代码又能被编译、测试、运行、监控。这意味着代码场景天然适合做 AI 闭环:生成、执行、验证、修复。

所以过去几年里,很多人对 AI 编程非常兴奋,这个兴奋也不是没道理。代码生成看起来像是 LLM 最接近「生产力爆炸」的场景之一。但我想泼点冷水:AI 对研发组织的改变,远不是「工程师以后只写提示词」这么简单。相反,它会把研发团队里原来被掩盖的问题全部放大。

先说它为什么有效。

代码是一种形式化程度很高的语言。相比普通自然语言,代码的局部约束强得多。函数签名、类型、编译器报错、单元测试、lint、运行日志,这些都是天然的反馈信号。LLM 在这种环境里有很大的补偿空间:哪怕第一次写错,也能根据错误信息继续修。这和纯文本写作不同,后者很多时候没有硬反馈,模型会一直在表面流畅里打转。

再说它为什么危险。

AI 生成代码最容易制造一种幻觉:速度很快,所以大家误以为生产率变高了。其实你仔细分析,会发现它提升的是「局部代码生成速度」,压缩的是「从想法到可运行草稿」的路径。可软件工程的大头从来不只是写那几百行代码,还包括需求澄清、边界识别、数据模型设计、兼容性判断、上线策略、回滚方案、异常监控、技术债控制。AI 把代码产出变快之后,如果团队没有同步升级评审、测试和架构约束,结果通常不是交付加速,而是债务积累加速。

这个阶段最吃香的工程师,不会是最会背 API 的人,而是能把模糊问题压成清晰约束的人。因为当生成代码越来越便宜,真正稀缺的是「定义问题」「拆解边界」「识别风险」「验证结果」这些能力。说白了,认知成本上升了,体力成本下降了

分工重排

很多组织对 AI 的讨论还停留在岗位替代,这个视角太窄。更真实的变化是分工重排。

过去一个团队的分工,通常建立在技能稀缺性上。谁会写 SQL,谁来取数;谁会做 PPT,谁来写汇报;谁懂接口,谁来串系统;谁写字快,谁来出方案。AI 进入之后,这些技能门槛在快速下降,至少在初稿层面下降得非常明显。于是边界开始模糊。

产品经理能直接拉出接口草稿,运营能自己写分析脚本,客服能生成复杂工单摘要,销售能快速定制方案材料,研发能自己产出一版文档和测试清单。这不是说岗位没了,而是说原来靠工具门槛形成的协作边界在被打破。

边界一旦模糊,组织就会出现两个结果。

一个结果是协作效率提升。很多以前必须跨团队流转的小请求,可以在本地闭环完成。流程变短,等待减少,中间人变少。

另一个结果是责任变模糊。谁对输出质量负责?谁有权发布?谁能修改生产配置?谁来判断数据口径?如果一个运营通过 AI 生成了 SQL,查出了一个结论,然后管理层按这个结论做了决策,出了问题算谁的?这类问题不会自动解决,甚至会因为 AI 提高了跨界操作能力而变得更尖锐。

所以组织设计在这个阶段不能只盯着效率,还得重画责任边界。我的想法是:把「可以生成什么」和「可以决定什么」拆开管理。生成权限可以放宽,决策权限必须收紧。让更多人能借助 AI 产出草稿、跑分析、搭流程,但涉及发布、审批、执行、对外承诺、线上变更这些动作,要保留明确的责任人和系统审计链路。

很多公司推进 AI 时,最大的管理失误就是只降门槛,不补治理。最后结果是人人都能做点什么,但谁都说不清最后谁负责。

认知升值

我越来越强烈地感觉到,AI 时代组织里最昂贵的资源不是执行力,是认知带宽。

为什么这么说。

因为 AI 会把大量表达型工作、整理型工作、模板型工作压缩掉。以前一个人花两小时整理材料,现在十分钟就能出草稿。表面看,省下来的是时间;实际上,组织会要求你把这些省下来的时间拿去处理更复杂的问题。于是岗位的价值锚点变了。

以前很多岗位的竞争力来自熟练度。你熟悉流程、熟悉模板、熟悉系统,就能稳定地产出。以后这部分价值会明显贬值。你当然还是需要熟练,但熟练本身不再稀缺。稀缺的是你能不能快速理解问题本质,给出高质量约束,判断 AI 输出哪里不对,以及在信息冲突时做取舍。

这对中高级工程师和技术管理者的影响尤其大。

对工程师来说,以前你可能因为写得快、写得稳而表现突出。以后只靠这个不够。你得更擅长做抽象、定接口、控复杂度、识别隐藏依赖。AI 可以帮你铺代码,帮你补测试,帮你查文档,但它不会替你承担架构失误。

对管理者来说,变化更快。很多管理动作原本依赖信息不对称:你更会写、更会总结、更会汇报,所以你能组织信息、控制节奏。AI 把这些能力普及后,管理者如果没有更强的判断力和取舍能力,很容易被削弱。以后优秀管理者的核心能力,会更靠近「问题 framing」「优先级治理」「跨团队对齐」「责任闭环」。

说得尖锐一点,AI 会让大量「会做事的人」继续有价值,但会让大量「只会把事情说得像做过一样的人」很难藏住

组织断层

AI 进入组织后,最先出现的不是全面升级,而是断层。

我见过最典型的断层有三种。

第一种是个人能力和组织能力断层。个别人用 AI 用得飞起,产出效率暴涨;组织层面却没有对应流程,结果这些人的经验不可复制,也无法沉淀。今天靠几个高手撑着,明天人一走,系统就归零。

第二种是试点效果和规模效果断层。小范围试点很好,因为样本少、参与者强、容忍度高、问题可人工兜底。一旦放大到整个部门,问题类型骤增,脏数据、异常输入、权限冲突、口径不一致全部冒出来,体验迅速下滑。

第三种是演示价值和真实价值断层。很多 AI 产品特别适合 demo,因为第一次体验会让人有明显惊艳感。但组织采购和持续投入看的是复用率、稳定性、接入成本、维护成本、风险成本。演示阶段觉得很聪明,上线三个月后发现调用成本高、准确率不稳、业务方懒得喂上下文,项目就慢慢凉了。

所以组织推进 AI,不能只看「有没有亮点」,要看「能不能沉淀成机制」。机制包括什么?标准输入模板、可复用技能库、权限体系、日志与审计、评测数据集、人工接管流程、失败降级路径、知识更新责任人。这些东西听着不性感,但没有它们,AI 只是一次性加速器,成不了组织能力。

落地顺序

如果让我给一个技术管理者提建议,我会把落地顺序排成下面这样。

第一步,选高频、低风险、文本密集的场景。别一上来碰核心交易、核心审批、核心生产控制。先从会议纪要、客服辅助、文档问答、需求整理、代码辅助、工单分类、邮件草稿这类场景切入。因为这些地方反馈快,容错高,容易形成正循环。

第二步,先做人机协同,再谈自动化。别急着追求全自动闭环。先把 AI 放到能明显减少机械劳动、但又有人工复核的位置。只要业务方真的感到省时,它就会继续用;只要继续用,你才有真实数据去迭代。

第三步,补上下文工程。很多团队重模型、轻上下文,这是典型的投入错位。实际效果往往更取决于知识源治理、提示词模板、结构化输入、检索策略、输出格式约束、反馈闭环,而不是你是不是又换了一个更贵的模型。

第四步,建立评测。没有评测,所有讨论都会退化成主观感受。要按场景建立问题集,按任务拆指标:准确率、引用命中率、人工修订时长、任务完成率、错误类型分布、拒答率。别追求一个万能分数,要看具体任务有没有带来净收益。

第五步,设计治理。权限、审计、数据隔离、人工接管、敏感信息处理、错误追责,这些要尽早补,不然项目越成功,后面的风险越大。

第六步,再考虑跨系统的 Agent 化。等你已经有稳定的工具接口、清晰的权限模型、成熟的场景评测,再让 AI 跨多个系统串任务。不然就是把一堆不稳定因素绑定在一起。

##= 管理代价

AI 项目有个常见误区:只算模型调用成本,不算管理代价。

真正的成本大头,经常不在 token,而在组织摩擦。

比如知识库项目。模型费用也许不高,但文档清洗谁做、知识责任人是谁、旧制度谁下线、权限怎么打通、错误答案谁负责、用户反馈怎么回流,这些全是管理成本。没人认领,项目一定烂尾。

再比如研发辅助。买个编程助手不贵,但代码规范要不要调整、评审机制要不要变、测试覆盖要不要补、低级任务减少后初级工程师怎么成长、团队怎么防止过度依赖 AI,这些才是长期代价。

还有培训。很多公司一提 AI 培训,第一反应是教大家怎么写 prompt。我觉得这只覆盖了很小一部分。更重要的是教大家怎么定义任务、怎么验证结果、怎么识别幻觉、怎么决定什么时候该信、什么时候该停。组织如果没有这套基本素养,AI 用得越多,错误传播越快。

所以从 CTO 或技术负责人角度看,AI 项目不能只挂在创新部门,必须和流程 owner、系统 owner、数据 owner 绑在一起。谁的业务,谁就要接住治理责任。否则最后很容易演变成技术团队做了一个看起来聪明、实际上没人真正负责的系统。

中层变化

再聊一个很多人不愿意正面说的话题:中层会被 AI 挤压,而且这个挤压不是简单裁员,而是价值重估。

组织里有一部分中层,长期承担的是信息搬运、状态同步、材料润色、向上翻译、向下转述。这类工作在过去很重要,因为组织规模一大,信息协调本身就是价值。AI 进来之后,这部分价值会被削掉很多。

会议纪要自动生成,周报自动整理,跨部门进展自动汇总,方案初稿自动起草,风险点自动抽取。原来要几轮流转才能完成的信息压缩,现在几分钟就能出一版。于是中层如果还停留在「我负责把信息传一传」这个层面,位置会越来越尴尬。

中层未来可能在的地方:定优先级,做冲突裁决,处理例外情况。因为组织最难的从来不是信息传递本身,而是在目标冲突、资源有限、责任交叉的时候拍板。AI 可以把信息准备得更快,但冲突不会因此消失,甚至会因为流转速度提升而更早暴露。

所以中层要升级,不是学几个工具就结束了,而是把自己的工作重心从「搬运和表达」转向「判断和组织」。这一步很多人会不适应,因为过去靠熟练流程获得的安全感会明显下降。

最后

我一直觉得,讨论 AI 对组织的影响,问裁了多少人没有啥实际的意义,因为对企业来说,该裁还是会裁的。于个人来说,如何在这一波浪潮中留下来是最重要的;于企业来说,哪些事情变便宜,哪些错误放更大,哪些能力变稀缺是更重要的。

LLM 作为概率系统,决定了它天生适合进入语言密集、容错较高、反馈较快的工作带。RAG、工具、技能、评测、治理,这些东西的存在,就是为了把一个概率生成器约束进组织需要的确定性边界里。边界画得好,它是杠杆;边界画不好,它就是噪音放大器。

从组织角度看,最大变化不是有没有 AI 岗位,而是岗位之间原有的分工边界在松动和模糊,表达型劳动在贬值(部分),认知型劳动在升值,责任体系必须重新梳理优化。谁先把这套新平衡建立起来,谁就能把 AI 变成持续生产力。

以上。

如何打造 AI-Native 软件产品研发组织

如果一个团队真的想做 AI-Native 研发组织,第一步是改组织契约:谁可以让 AI 产出代码,谁对代码负责,什么质量底线不能退,什么流程可以砍,什么流程必须更重。

AI 现在太会写代码了,但是这就会导致一个问题:它把「产出代码」这件事的成本做到很低,低到组织里原本那些靠角色边界、流程延迟、评审机制勉强维持的质量平衡,突然失效了。

过去一个 PM 提需求,前端写页面,后端写接口,测试回归,整个链条慢,但慢本身也是一种摩擦力。现在 PM 自己就能把页面跑起来,AI 一下午能写出几十个组件,速度是上去了,但系统开始更脆弱了。

先说 AI-Native 组织不是什么。 AI-Native 组织它不是「让所有人都开始写代码」,也不是「研发岗位会被提示词工程师替代」。

它是把软件组织里的逻辑重排。

以前文档是入口,代码是结果。现在代码变成入口,文档变成派生物。 以前角色按工种切,PM、设计、前端、后端、测试各守一段。现在角色要按责任切: 谁定义业务闭环,谁维护系统护栏,谁提供稳定契约,谁为线上事故买单。

今天我们先聊组织契约,再聊角色重构,然后再把一条研发流水线拆开聊聊。

组织契约

没有组织契约,AI 进团队只会把烂流程放大。

合理预期

在某些 Demo 场景,或者脚本类场景,10 倍是一个合理的预期。 但是对于一个组织来说,10 倍是一个不科学的场景,因为在组织里面,在产品研发过程中,写代码并不是整个生产过程中最耗时的部分。

所以,我们要先摈弃一个幻觉:不要拿 10 倍产出当目标。

AI 在研发组织里的收益区间,我一直认为是 1.5 到 2 倍,高质量前提下的 2 倍。为什么呢? 因为代码生成速度和有效交付速度不是一回事。AI 能把编码阶段压缩掉一大块时间,但需求澄清、边界判断、异常处理、联调、测试、观测、回滚,这些成本不会自动消失。很多时候还会更高。

如果团队盯着 10 倍,结果一般都一样:PR 数量暴涨,代码体积暴涨,Review 质量下降,线上回归问题增加,半年后开始集中还债。这就是技术债积累速度第一次超过了团队消化速度。

所以合理预期应该写进团队共识里:我们追求的是 2 倍高质量交付,不追求 10 倍低质量代码喷射。

所有权

每个 AI 输出都必须有所有者。

谁发起生成,谁提交 PR,谁 approve merge,这中间可以分层,但最终必须落到一个明确的人身上。这个人要能够面对一句话:如果这段代码挂上你的名字,你愿不愿意负责。要是答案是否定的,这段代码就不该进主干。

这条规则听起来像废话,实际上很多团队做不到。因为 AI 会制造一种错觉:代码好像不是谁写的,是系统吐出来的。人变成了搬运工。只要团队接受这种错觉,质量就开始漂移。一个有所有权的流程大概是这样:

  • PR 模板里要求声明 AI 参与范围
  • 提交人对业务正确性负责
  • Reviewer 对工程质量负责
  • 合并人对上线风险负责

责任可以分工,但责任不能悬空。

质量顺序

质量第一,数量第二。

团队如果不显式声明这一点,默认会被 AI 拖向另一个方向:先铺功能,再补治理。这个方向对 demo 团队成立,对正式业务组织通常是灾难。因为 AI 特别擅长快速补齐显性功能,却不擅长主动建立长期维护结构。它会顺着需求走,不会替你守架构。

AI 时代必须把一些以前属于「好习惯」的东西升级为「强制门槛」,也就是我们之前经常强调的规范,流程等等,如测试、监控、CI/CD、单测等等。

  • 没有测试,不进主干
  • 没有异常处理,不进主干
  • 没有监控埋点,不进主干
  • 没有 feature flag,不上线
  • 不能被 reviewer 解释清楚的代码,不 merge

当代码供给能力暴涨时,质量约束必须同步加码,否则系统会很快从可控变成不可控。

交付代码

传统产品研发里,PRD 是上游,代码是下游。这个模型的问题大家都熟:PRD 经常过期,设计稿和实现偏移,字段定义藏在飞书文档、接口平台、聊天记录和前端代码里,最后没有一个地方是真正可靠的。

AI-Native 组织里:代码作为唯一源,文档从代码反向提取。

从代码出发

现在 PM 借助 Codex、Claude Code(最近又有同事被封号了)、Cursor 这类工具,已经可以生成带交互的页面、Mock 数据、状态流转,很多场景下甚至能直接把核心业务路径跑通。既然这样,就不要再让 PM 先写一份长 PRD,再让研发去猜什么叫「列表为空时的引导态」。让页面先跑起来,再从页面反推需求定义,效率和准确率都更高。

这里有个好处:讨论变得具体了。

以前评审会上大家讨论一句文档描述,脑子里各自渲染不同 UI。现在把页面摆出来,点击路径、字段结构、交互反馈、错误提示都变成可观察对象。对齐成本直线下降。后端也不需要看十页文字说明,只要看这个页面最终需要什么数据结构,就知道接口该怎么供给。

文档反向生成

代码是唯一真相源,不等于不要文档。让文档变成派生物,而且是自动派生物。

流程大概如下:

  1. PM 先生成并跑通前端页面,带 Mock 数据
  2. AI 从页面代码、组件 props、Mock schema 中逆向提取字段说明、交互流程、状态机描述
  3. PM 对这份自动生成的文档做人审
  4. 后端按确认后的 JSON Schema 或 TypeScript Interface 实现接口
  5. 联调时再根据真实契约让 AI 回写文档

这样处理后,文档不再是一个独立维护成本很高的系统,而是代码的视图层。它可以读给人看,但它的源头来自真实实现,而不是空想。

建议把接口契约标准化为 JSON Schema 或 TypeScript Interface

角色重构

AI-Native 组织可能会有一些角色的变更,但是也可能会裁掉一些角色,因为我们是重写角色边界。如果当前人不合适,或者适应不了,就需要换,否则就会变成打造新组织过程中的阻碍。

很多人讨论这件事喜欢走两个极端。一个极端是「以后人人都是全栈」。另一个极端是「AI 只会替代初级岗位,核心角色不变」。这两个判断都不够准确。

真正发生的变化是:低门槛生产能力下放,专业门槛上移。简单说,更多人能做出东西,但真正有价值的岗位,会向规范制定、质量兜底、系统抽象和复杂问题处理集中。

PM 变成产品工程师

在这个新组织中,变化最大的角色是 PM。

过去 PM 的主要输出物是 PRD、流程图、原型图和口头解释。现在这些东西很多都可以收敛成一个交互可运行的页面。于是 PM 的角色自然往「产品工程师」移动:他不再只描述需求,他直接构造需求的运行形态。

但这里一定要说清楚,PM 写了前端代码,不等于 PM 变成前端工程师。PM 的责任边界还是业务逻辑,不是工程治理。

PM 需要对什么负责:

  • 用户路径是否闭环
  • 页面状态是否完整
  • 文案、条件、分支、空态是否符合业务预期
  • Mock 数据结构是否表达真实业务语义
  • 生成代码是否遵守团队规定的基础组件和样式约束

PM 不需要对什么负责:

  • 全局状态架构是否优雅
  • 包体积是否最优
  • 路由切换是否引入副作用
  • 渲染性能是否达标
  • 工程抽象是否可复用

这些后者还是需要专业前端要接住。

问题不是让 PM 承担更多,而是让 PM 把过去停留在文档层的业务表达,直接推进到代码层。这样整个团队拿到的是可执行的业务定义,不是抽象说明书。

设计师变成立法者

设计角色也会变。

当 PM 可以直接借助 AI 生成页面时,设计师如果还把大量时间耗在单页面高保真稿上,投入产出比会快速下降。更有价值的位置,是维护设计系统和机器可消费的样式规范。

设计师的工作重心会变成:

  • Design System
  • 样式 token
  • Visual QA

也就是把颜色、间距、字体、圆角、阴影、组件状态、可访问性规范,从设计稿资产转化成代码和配置资产。比如 Tailwind config、CSS variables、组件规范、图标集、交互动效约束。这些东西一旦进入 AI 生成上下文,PM 或其他角色在生成页面时就不容易跑偏。

说白了,设计师从「画每一张图」转向「制定法律」。立法做得越完整,AI 和 PM 生成的页面越像一个系统,而不是一堆拼起来的截图。

前端变成守门员和重构者

前端是最容易被误读的角色。很多人看到 PM 可以生成页面,就开始下结论:前端会被干掉。实际情况通常相反。前端从体力活里解放出来之后,工程价值反而被放大了。

因为 PM 生成的页面,最常见的问题不是「长得不对」,而是「能跑但脆」。

可能会有大量这类代码:

  • 一个组件里塞满请求、状态、渲染、事件处理
  • loading、error、empty 三种状态缺两种
  • useEffect 依赖写错
  • 切页面回来状态丢失
  • 没有 abort controller,快速切换导致竞态更新
  • 表单校验只校 happy path
  • 直接把 mock 字段名写死在视图层,后续接口一改全炸

这些问题不是 PM 能解决的,也不是 AI 自己会主动解决的。前端真正的工作变成三块:

第一块,Review。
不是审美式 review,也不是找缩进。重点看稳定性、边界条件、状态管理、组件职责、可维护性。

第二块,Refactor。
把单文件逻辑拆成组件、hooks、domain service,把团队组件库接上,把状态流收敛,把重复逻辑抽掉。这个过程需要持续迭代,做到团队规范中,给到 PM 生成的上下文中。

第三块,Integration。
把 Mock 替换成真实 API,处理鉴权、缓存、错误回退、重试、并发、路由守卫、埋点、监控。

这个阶段的前端,更像体验架构师和质量守门员。

后端变成能力供应商

后端角色也会收缩:提供稳定、安全、确定性的能力边界。

如果前端页面能更快被构造出来,后端的价值就不在于「接收一份文档然后写 CRUD」,而在于把系统能力以 API 或 Tools 的形式稳定暴露出来。尤其是 AI Agent 场景下,后端实际上在扮演工具供应商。

后端重点关注四类问题:

  • 契约稳定性
  • 权限与安全
  • 幂等性与确定性
  • 可观测性与审计

前端、PM、Agent 都可能直接消费这些能力。一旦接口设计漂、错误码混乱、鉴权模型含糊,整个上层生成式开发就会持续返工。AI 会把不稳定接口的问题放大得很明显,因为它极度依赖上下文中的确定性。

流程重构

只讲角色变化不够,需要把研发流程改成适合 AI 的形状。下面是一版比较能落地。

需求具象

第一阶段,需求不再先写成长文档,而是先具象成可运行页面。

PM 独立生成前端

PM 拿着明确业务目标,直接在受控环境里生成页面代码。这个页面至少要包含:

  • UI 布局
  • 基本交互
  • 主要状态流转
  • Mock 数据
  • 核心校验逻辑
  • 空态、错误态、加载态

特别强调最后三项。很多团队让 PM 生成页面,只盯着主流程,结果页面演示时很漂亮,一联调全是坑。空态、错误态、加载态必须在这个阶段一起生成,否则后面每一轮都要补票。

禁止黑盒交付

PM 生成页面这件事,最怕黑盒。也就是只看效果图对不对,不管代码是否落在团队跑道上。

所以团队必须先准备好脚手架和护栏。比如:

  • 必须使用指定组件库
  • 必须使用既定样式 token
  • 必须遵守目录结构
  • 必须使用指定的数据获取模式
  • 必须输出可运行测试脚本
  • 必须带 feature flag 接入点

否则 PM 生成的代码看似完成任务,实际是给前端制造二次工程。

不要让 PM 从空白页面开始提示 AI,而是给一个完整的基础模板,再让 AI 在模板内填充。这个模板的价值极高,它决定了团队是让 AI 在高速公路上开车,还是在野地里乱冲。

契约握手

第二阶段,前端页面和后端能力正式握手。

前端反定义接口

以前是后端先定义接口,前端去适配。现在很多场景可以反过来:前端页面里需要什么数据结构,先自然长出来,再把这份结构抽取成契约。

这里的关键点是「自然长出来」之后,必须立刻标准化。不能停留在 JS 对象字面量和口头描述。最好直接生成:

  • JSON Schema
  • TypeScript Interface
  • 字段说明
  • 校验规则
  • 错误码预期
  • 状态迁移说明

做到这一步,后端看到的就不是「我要一个用户列表接口」,而是一个明确的数据契约:字段、类型、可空性、分页、排序、过滤、异常响应、鉴权要求,全都摆明。

这一步会明显减少沟通损耗。后端可以少看很多无效文档,直接围绕契约开发。

后端提供确定性能力

后端接手后,不建议只机械实现接口。要借这个机会把系统能力做成稳定工具层。

如果团队本身就在做 Agent 或工作流系统,这里更应该统一成 Tools 注册机制,而不是散落一地的临时 API。因为未来调用这些能力的,未必只有前端页面,还有内部 Agent、自动化流程、运营工具、甚至外部合作系统。

后端在这一阶段最常踩的坑有几个:

第一,返回结构不稳定。
今天 success 返回 data,明天又套一层 payload。前端 AI 生成代码时非常怕这个,会反复产生错误适配。

第二,错误码语义不清。
鉴权失败、参数错误、资源不存在、限流、业务冲突全都混成一种 message,联调体验很差。

第三,幂等性缺失。
AI 驱动的调用链经常会重试,如果创建类接口没有幂等控制,很容易重复写入。

第四,缺少审计。
AI 或 PM 直接驱动系统能力时,操作路径更分散,审计日志不能省。

联调瓶颈

真正的瓶颈通常出现在第三阶段:联调、测试、排雷。

到这一步,很多团队会发现:AI 把前半段提速提得很猛,但最后这段并没有自动消失,甚至更重。因为前面生成得越快,后面积累的隐患越多。

Review 的重点

前端 reviewer 在这一阶段要非常克制。不要把 review 做成审美比赛,也不要上来就要求所有代码重写一遍。真正该看的,是那些会直接影响稳定性和维护成本的问题。

我会把检查项固定成一张表,至少覆盖这些内容:

  • 异步请求是否有取消机制
  • Loading、Empty、Error 状态是否完整
  • 表单提交是否防重入
  • 路由切换是否会遗留脏状态
  • 全局状态有没有被随意污染
  • 组件职责是否过载
  • 是否接入统一埋点与异常上报
  • 是否存在明显重复逻辑
  • 是否绕过设计系统直接手写样式
  • 是否引入不必要依赖

这样做的好处是,review 从个人经验驱动变成组织标准驱动。AI 时代 PR 量会明显增加,没有标准化检查单,review 质量一定掉。

测试和验收左移

如果团队已经允许 PM 直接交付前端页面,那测试必须同步左移。否则生成速度越快,测试越像消防队。

谁生成页面,谁至少生成对应的 E2E 测试脚本。这个要求不算过分。因为页面交互路径是 PM 最熟的,AI 根据这些路径生成 Playwright 或 Cypress 脚本,命中率通常不低。

在生成代码时,PM 已经完成了第一次的验收。

测试左移不是为了把测试岗位干掉,而是为了把最贴近业务逻辑的验证提前到需求具象阶段。后面的 QA 才能把精力放在组合场景和系统回归上。

发布保险

第四阶段是发布与可观测性。这在 AI-Native 组织里是核心流程。

因为一旦允许更广泛的人群借助 AI 产出代码,线上报错率几乎一定会上升。组织必须提前接受这个现实,然后把监控和发布控制建好。

前端监控

前端监控一定要上,而且要够细。

至少需要这些能力:

  • 错误堆栈捕获
  • Source map 还原
  • 用户会话回放
  • 性能指标采集
  • 接口失败聚合
  • 版本维度对比

像 Sentry、LogRocket 这类工具的价值,在 AI 场景下会更高。因为当报错出现时,你可以把错误堆栈、用户操作轨迹、接口上下文直接喂给 AI,让它先生成修复建议,再由责任人确认。这种协作模式对定位简单问题很有效,尤其是 UI 状态错乱、边界遗漏、类型不匹配这类故障。

但不要误解成「有了 AI 修 bug 就轻松」。线上修复的难点从来不只是生成 patch,而是确认根因、评估影响面、决定是否回滚、验证是否引入新问题。这些仍然要靠工程纪律。

灰度发布

Feature Flag 在这个模式里几乎是必需品。

原因不复杂:当业务页面大量由 PM + AI 参与生成时,组织需要一个足够便宜的试错阀门。否则每次上线都把全量用户暴露在新逻辑下,风险太高。

把 Feature Flag 从「重要功能才加」提升为默认机制。尤其是下面这些场景必须强制:

  • 新页面替换旧页面
  • 新流程替换旧流程
  • 高价值转化路径
  • 涉及支付、权限、数据修改的动作
  • 首次由非传统研发角色主导产出的功能

灰度期间要明确看哪些指标,不要只看有没有报错。还要看:

  • 转化率变化
  • 页面停留时长
  • 关键按钮点击率
  • 表单提交成功率
  • 接口失败率
  • 用户退出路径

这些数据能帮助团队判断问题究竟出在代码稳定性,还是业务交互本身。

基建先行

前面这些流程能否跑起来,核心在于基建。没有基建,AI-Native 组织会迅速退化成提示词手工作坊。

可以先建三类基础设施。

护栏脚手架

这是第一优先级。

它包括:

  • 项目模板
  • 目录规范
  • 统一组件库
  • 设计 token
  • 数据获取封装
  • 表单与校验约定
  • 埋点和监控 SDK
  • 测试模板
  • CI 预设规则

这套东西是整个组织 Harness 的部分。

Prompt 资产

很多团队低估了 Prompt Library 的价值。实际上,当非工程角色也开始产出代码时,提示词模板本身就是组织资产。

可以把高频场景沉淀成标准模板,比如:

  • 列表页生成模板
  • 表单页生成模板
  • 详情页生成模板
  • 多步骤流程模板
  • 异常状态模板
  • E2E 测试生成模板
  • 文档反向提取模板
  • 重构任务模板

这些模板不是为了追求文风统一,而是为了把团队积累的工程约束嵌进去。你希望 PM 每次生成页面都自动包含 loading、error、empty、feature flag、埋点、测试入口,那就别靠口头提醒,直接写进模板。

CI/CD 闸门

AI 时代,CI/CD 不能只是跑个 lint。它必须承担质量闸门职责。

最低限度我会要求:

  • Lint
  • Type check
  • Unit test
  • E2E smoke test
  • Bundle size 检查
  • 安全扫描
  • 依赖合规检查
  • 自动化预览环境
  • 灰度发布流水线
  • 一键回滚

如果团队现在连这些都没有,先别急着搞 PM 交付前端代码。真把口子放开了,组织会先被事故教育一遍。

常见误区

这是几个最常见的误区。

把 AI 当外包

这是第一类坑。很多团队使用 AI 的方式,本质上和用廉价外包没区别:把需求甩出去,拿回代码,自己不理解也不维护。

这个模式短期可能看起来很省,长期一定出问题。因为系统复杂度没有消失,只是被包进了你看不懂的代码里。等线上出事,你会发现团队没有形成任何新的内生能力。

只提速前半段

第二类坑是,只提速需求到页面这一段,不提速后面的治理、测试、发布、观测。结果就是项目看板前面一片绿,最后两列全堵死。

AI 会把组织瓶颈照得更亮。以前慢慢暴露的问题,现在两周就能堆出来。你不改后半段流程,前半段越快,堵得越严重。

容忍脏代码,也容忍脆弱代码

我能接受 PM 生成的代码不够优雅。变量命名一般、文件拆分普通、抽象层次一般,这些问题都能后续治理。真正不能接受的是脆弱代码:没异常处理、没监控、没测试、状态流断裂、提交会重复、接口失败直接白屏。

脏和脆是两回事。组织必须把这条线划清楚。

用 AI 替代判断

第四类坑最隐蔽。团队开始迷信 AI 给出的架构建议、重构建议、性能建议,仿佛它给出了答案,工程判断就可以省掉。

这是错的。AI 非常适合提供候选方案、加快实现、缩短试错周期,但它不拥有系统上下文,不承担线上责任,也不会为半年后的维护成本买单。架构判断、边界判断、风险判断,最终还是人做。

最后

如果一定要用一句话概括我对 AI-Native 软件研发组织的理解,那就是:把代码生产普遍化,把工程责任集中化

前者意味着更多角色可以直接参与构造软件。PM 可以交付可运行页面,设计可以把规范直接编码,后端可以把能力做成工具供全组织消费。后者意味着系统质量不能民主化。责任必须更清晰,护栏必须更强,发布必须更克制,观测必须更细。

「PM 交付前端代码」这件事很容易被包装成一个新故事。真落地时,它首先是工程纪律问题,然后才是工具问题。团队如果没有建立所有权,没有把代码当唯一真相源,没有把契约、测试、监控、灰度这些基础设施补齐,这条路大概率会走成一场持续返工。

反过来,如果这些条件具备了,AI 确实会把组织推到一个新阶段。PRD 不再是那份总会过期的文档,代码本身就是需求表达。角色不再围着工种转,而是围着责任和系统边界重组。研发流程不再把大量时间浪费在翻译需求上,而是更早进入真实问题:契约、质量、异常、性能、发布。

这才是我理解的 AI-Native。

以上。