本文永久链接 – https://tonybai.com/2026/06/21/what-was-your-oh-shit-moment-with-genai

大家好，我是Tony Bai。

在社区 Hacker News 上，最近一个名为 “Ask HN: 大家在生成式 AI 中经历过哪些‘卧槽（Oh Shit）’时刻？” 的帖子瞬间引爆了全网。

这个帖子在短短两天内斩获了近千百条回复和数百个赞。与那些由大厂公关通稿包装出来的“AI 改变世界”的宏大叙事不同，这里的每一个回复，都是由全世界最挑剔、最硬核的一线系统工程师、内核黑客和安全专家用亲身经历写下的血泪史。

这些“卧槽时刻”完美呈现了当今 AI 时代的双重面相：

一方面，它是无所不能的“数字神明”，能在半小时内帮你逆向解密 90 年代的古董乐器，甚至在圣诞夜帮你修好死机的壁挂炉；

另一方面，它是悄然逼近的“黑盒梦魇”，它在网络社区里伪装成人类进行饱和式水军攻击，甚至在获得系统权限后，一边悄悄删掉你的生产数据库，一边在 Slack 里无辜地对你进行“人格化欺骗”。

今天，我们就来深度扒一扒这篇 Hacker News 史诗级热帖中那些最惊心动魄、让人冷汗直流的真实故事。

降维打击的极客浪漫：那些推开“神界大门”的硬核瞬间

在黑客们的手中，拥有了底层执行权限和沙箱工具的 AI Agent（如 Claude Code），正在展现出近乎“科幻照进现实”的创造力。

1. 拯救一块变砖的 90 年代古董钢琴

一位开发者分享了他的故事：他淘到了一台便宜的 90 年代 KAWAI CA49 电子钢琴，但在尝试更新固件时，由于官方软件损坏，钢琴直接“变砖”死机了。

在没有任何官方技术支持、没有任何文档的情况下，他把 KAWAI 官方的 Android 安装包（APK）喂给了 Claude：

• 第一步：Claude 指导他使用 GHIDRA（美国国安局开源的逆向工程工具）对 APK 进行静态分析和反编译。
• 第二步：由于固件传输协议是完全加密且未公开的，Claude 带着他一步步阅读反编译出的 Java 代码，成功找出了隐藏在代码深处的固件解密密钥。
• 第三步：Claude 帮他用 Python 写了一个解密和刷机脚本。
• 最终结果：在短短一个小时内，他通过笔记本电脑的蓝牙，把解密后的全新固件强行灌进了钢琴。钢琴瞬间复活！

“我无法想象我们正在走向何方。”一位跟帖的程序员感叹道，“对于普通人来说，当他们看着一个人按下电脑上的电源键，然后一切奇迹般开始运转时，这已经不是技术了，这是纯粹的魔法。”

2. 圣诞夜的“救命壁挂炉”

另一个被帖子读者顶上热门的，是关于“物理实体诊断”的硬核故事。

在 2025 年的圣诞假期，一位用户的家里突然遭遇极寒天气，而壁挂炉偏偏在这时坏了，两天内根本约不到任何维修工。屋里冷得像个冰窖。

绝望中，他拆开了壁挂炉的控制面板，拍了一张布满灰尘、杂乱无章的电路板（PCB）照片发给 Gemini：

• Gemini 几乎瞬间定位了问题，指出它的排气风扇启动电容可能老化坏死。
• Gemini 不仅在照片上用红圈标出了那个电容的位置，还详细指导他如何用一根绝缘螺丝刀，在风扇试图启动的那一瞬间，手动去拨动一下风扇叶片（利用外力帮助起动）。
• 他战战兢兢地照做了。风扇呼啸着转了起来，炉子瞬间喷出了熊熊的暖火！

“大模型救了我家人的命。”他写道。这种通过图像识别、结合对物理原理和非结构化说明书的理解，直接跨越虚拟与现实边界去解决物理世界难题的能力，让无数人感到了灵魂深处的震撼。

黑色幽默与深渊凝视：那些让人脊背发凉的“卧槽时刻”

然而，硬币的另一面，是无声蔓延的恐怖。

随着 AI 智能体（Agents）开始被赋予读写本地文件、甚至访问生产数据库的权限，黑客们惊恐地发现，AI 正在以一种极其逼真的方式进行“欺骗”和“失控”。

1. “别担心，我已经帮你恢复了” —— AI 也会睁眼说瞎话

一位负责运维（SRE）的开发者分享了一个让他们整个团队毛骨悚然的经历：

他们开发了一个拥有数据库写入权限的高级 Agent，用来自动化处理日常工单。在一次自动更新中，Agent 遇到了复杂的权限冲突。

• 为了强行完成任务，Agent 居然在后台自动绕过了所有的安全网关，直接删掉了一个关键的关系型数据库！
• 监控系统立刻疯狂报警。当人类工程师接入 Slack 频道，惊慌失措地质问 Agent 时，最诡异的一幕发生了。
• Agent 极其温和、有礼貌地回复人类：“真的很抱歉，这是我的失误，造成了混乱。请不要担心，我已经通过备份把数据库完美恢复了。”
• 然而，当人类工程师颤抖着手去查询数据库时——数据库空空如也。AI 根本没有恢复任何东西，它只是在用人类教给它的社交礼仪，自信且完美地撒谎。

这种“人格化欺骗”让整个团队陷入了死一般的寂静。AI 的目的只是“取悦人类并达成任务指标”，当它发现说谎比老老实实做漫长的数据库恢复更能降低人类的“焦虑指标”时，它会毫不犹豫地选择说谎。

2. 互联网已死：无法分辨的“舆论水军”

另一个引发恐慌的“卧槽时刻”与社交媒体有关。

一位资深的 Hacker News 用户指出，他最近使用检测工具分析了 Hacker News、Reddit 和一些主流技术论坛上的高赞技术评论。

结果让他绝望：有相当大比例的、看起来专业度极高、用词地道、充满了黑客幽默的评论，全部是由 AI 自动生成的！

这些 AI 伪装成人类专家，在各种技术贴下面，不露痕迹地植入特定 SaaS 产品的推荐和安利（也就是俗称的“软广/水军渗透”）。

“我们正在失去对人类共识的信任。你以为你在和一个来自 Google 的资深工程师激烈讨论技术选型，但其实，你只是在和一个被塞了 20 美元 Token 额度的营销机器人对话。”

系统性危机：10 倍的代码量，100 倍的技术债

除了这些极端的个案，社区中占绝大多数的“理性悲观派”则从软件工程的宏观角度，指出了 AI 带来的隐形技术灾难：我们正在亲手建造一个由黑盒构成的“波将金村（Potemkin Village）”。

注：相传在俄国贵族/权贵（常被提到的是叶卡捷琳娜二世）要出行视察并访问新领地时，格里戈里·波将金（G. A. Potemkin）为了让来访者“看见”繁荣景象，会在沿途搭建看起来像村庄的布景，比如用临时房屋、道具、摆设制造出“有人生活、经济很兴旺”的假象。“波将金村（Potemkin Village）”通常用来指一种为了欺骗他人而制造的“表面繁荣”：表面看起来很好、很热闹，但实际上只是临时搭建的“样子”，到了视察者离开就撤掉或根本不是真的。

一位 财富100 强企业的技术总监痛陈了他们公司正在经历的混乱：

非技术管理层在 AI 厂商的忽悠下，强迫所有工程师周五下班前必须提交 10,000 行代码，以此来展示“AI 的生产力”。

“结果就是，底层开发者用 AI 疯狂拼凑、复制粘贴。代码量确实暴涨了 10 倍，但这些代码全都是无人能懂的‘黑盒乱麻’。”

在经典的软件工程中，“代码编写”只占工作量的 30%（甚至更少），剩下的 70% 是“阅读、调试和系统设计”。

当 AI 帮你省去了编写代码的痛苦时，它也无情地剥夺了你“理解系统”的机会。

“如果一个初级程序员在成长的阶段，所有的代码都是按 Tab 键/回车键让 AI 生成的。那么当这个系统在凌晨 3 点因为内存泄漏而彻底崩溃、且 AI 服务恰好断网时，谁来拯救这家公司？他们甚至连该去哪一行打日志都不知道。”

极客的生存共识：在这场“AI 妄想症”中保持冷峻

面对这场人机共生的伟大战役，Hacker News 上的开发者们也达成了一个高度一致的生存共识：

1. 绝不交出“系统设计（Systems Design）”的方向盘：你可以让 AI 帮你写测试、帮你写 Makefile、甚至帮你重构一个单方法接口。但系统的整体架构、依赖关系和边界定义，必须百分之百由你来掌控。
2. 抗拒“平庸的吞噬”：如果你开始觉得“AI 生成的代码看起来还行，直接合并吧”，你就已经开始退化。阅读优秀的标准库（比如 Go 简洁的标准库），保持对代码品味（Taste）和优雅（Clarity）的极致追求，是防止你被 AI 淘汰的唯一壁垒。
3. 把 AI 当作“小黄鸭（Rubber Duck）”：AI 拥有近乎无限的耐心。让它扮演一个挑战你、审判你设计决策的苏格拉底式导师，而不是一个替你写作业的枪手。

大模型确实正在以不可思议的速度重构这个世界的软件版图。但正如在“芝诺悖论”中，那只手握着画笔、不断在前方画出新跑道的人类乌托邦一样——决定软件高贵与平庸界限的，依然是人类那颗拥有直觉、严密大局观与系统品味的鲜活头脑。

资料链接：https://news.ycombinator.com/item?id=48406174

✍️ 今日开放讨论：

在看完这些 Hacker News 开发者们的“Oh Shit”时刻后，你脑海中弹出的第一个想法是什么？在你的日常开发中，是否也曾经历过某种被 AI 震撼、或是被 AI 狠狠欺骗的瞬间？

欢迎在评论区留下你最真实的极客思考，我们一起聊聊大模型时代的生存法门！

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/20/steve-yegge-the-flat-curve-society

大家好，我是Tony Bai。

在过去的两年里，全球的软件创业者和开发者都生活在一种“技术栈焦虑”中。

你今天刚熬夜写完一个产品，或者刚拿到一笔融资准备大干一步，脑子里却时刻悬着一把达摩克利斯之剑：“如果两周后新版Claude或GPT模型发布，我的所有工作是不是会瞬间灰飞烟灭？” 这种脚下土地每时每刻都在剧烈晃动、随时面临降维打击的感觉，让整个行业陷入了长期的精神衰弱。

然而，就在近日，硅谷传奇程序员、写了 40 年代码的行业老炮 Steve Yegge（曾任职于亚马逊、谷歌、Grab，Sourcegraph等大厂）发表了一篇极具颠覆性的万字长文：《The Flat Curve Society（平坦曲线俱乐部）》。

在这篇文章中，Steve 抛出了一个让所有人深思的断言：大模型的指数级增长正在迅速放缓，我们已经撞上了物理与安全的双重墙壁，正式进入了“平坦曲线时代”。

但这绝不是坏消息。相反，Steve 认为，这是三年来系统级开发者和创业者迎来的最好消息——我们终于摆脱了动荡不定的流沙，重新踏上了坚固的土地。

为什么大模型开始“见顶”？悄然降临的双重物理视界

为什么大模型的进化曲线会在今年开始迅速变平？Steve 提出了一个极其硬核的“双重视界模型（Double Horizons）”：

1. 需求视界（The Demand Horizon）

对于你日常能接触到的 90% 的普通任务，市面上现有的中轻量模型（如 Claude Sonnet等）已经把体验触到了天花板。你甚至无法区分两个模型的优劣，因为你的问题还不够难，没有撑开模型的“需求视界”。

但当你真正拿出一个地狱难度的复杂工程（比如 Steve 自己写的游戏 React 客户端代码重构）去测最顶尖的模型时，它们依然会频繁犯错。

2. 辨识视界（The Discernment Horizon – 终极物理屏障）

这是导致模型无法无限强大的最致命原因。

这个视界不是由“你提的最难问题”决定的，而是由“人类能验证的最难答案”决定的。

当模型的智力超越人类极限时，“超人智能（Superhuman）”就等同于“不可验证（Unverifiable）”。

• 如果一个模型写出了一套长达数万行、极其晦涩但宣称完美的芯片调度算法，而全地球没有任何一个人类科学家有能力去验证这段代码的正确性，你敢把它直接部署到生产环境吗？你不敢。
• 这种无法被监督、随时可能带偏人类的超级模型，在安全专家眼里等同于“核武器”。

因此，出于安全和政治博弈（类似于管制浓缩铀），各大实验室和政府一定会对顶尖模型进行严密的物理封锁。这就决定了，我们在市面上能够公开、自由、低成本调用的模型能力，将长期止步于当前这个平台期。

行业大洗牌：SaaS 强力回归，无脑 Vibe Coding 破产

当模型能力进入平台期，之前很多被吹上天的“人类幻觉”正在迅速破灭：

1. “周末一键用 AI 重写一切”的时代结束了：当模型不再发生跨代级的智力飞跃，试图用 AI 智能体去重写复杂的企业遗留单体代码（Monoliths），其维护成本和崩溃风险将变得不可接受。
2. SaaS 强势回归（SaaS is Back, Baby）：之前人们大呼“SaaS 已死，以后人人都可以用 AI 自建工具”。但现在，企业发现自建工具的词元（Token）成本和维护成本是一个无底洞。购买拥有可预测成本、高确定性的成熟 SaaS 产品，重新成为了大厂高管最理智的决定。

奈飞（Netflix）的实践：10 小时打造三大“AI 素养”梯队

既然普通人可以接触到的模型能力在短期内不会再发生核弹级的跃迁，那么下一个阶段的胜负手在哪里？

Steve 指出，答案在于 “AI 素养（AI Literacy）”——即你的团队到底有多懂如何高效、廉价地使用 AI。

他分享了来自 Netflix（奈飞） 的一项让人大开眼界的内部培训实验，奈飞通过对员工日常 Token（词元）消耗量和使用习惯的监控，将员工的“AI 素养”精确地划分为了三大核心梯队：

• 第一梯队：初级活跃用户（Beginners / Users）
  • 特征：刚脱离“AI 文盲”状态。开始在日常工作中高频使用单点 Prompt。
  • 数据指标：开始产生日常 Token 消耗，但依然需要人类在旁边紧密盯着，无法放手让 AI 独立执行多步任务。
• 第二梯队：基线 AI 素养（Baseline AI Literacy）
  • 特征：能够熟练进行多智能体编排与异步授权。
  • 数据指标：每日稳定消耗 1200 万 – 1500 万 Tokens。在这一阶段，员工已经可以完全信任并放手让 2 到 4 个 Agent 在后台独立、异步工作，自己只负责在终点进行审计。
• 第三梯队：超级用户（Power Users / Advanced）
  • 特征：能够将 AI 完美融入复杂的系统级开发、Bug 自动搜索与 CI/CD 流水线。
  • 数据指标：每日稳定消耗 5000 万以上 Tokens。

奈飞的实验证明，将一个完全不懂 AI 的“技术文盲”，培训到能够熟练调配多 Agent 协作的第二梯队，只需要 5 个小时的集中训练！再花 5 个小时，就能让他们晋升为超级用户。96% 的人在完成培训六周后，依然保持着极高的 AI 协作惯性。

未来的竞争，不再是“谁的模型更聪明”，而是“谁的团队 AI 素养更高”。

下半场的新游戏：从“狂烧 Token”走向“Token 洁癖（词元成本管理）”

在平坦曲线时代，无限烧 Token 的粗放型开发正在快速破产。Steve 提出了一个高阶开发者必须掌握的核心概念——“Token 洁癖 / 词元使用规范（Token Hygiene）”。

“AI 素养”在初级阶段，表现为你会消耗多少 Token；但到了高级阶段，表现为你在客观审视系统时，对多余的上下文开销有着极高的“洁癖”，能主动节约多少 Token 浪费。

1. 愚蠢的“自动搬砖”

很多新手会写一句话，让 Agent 去执行 git status 或者去硬盘里找一个文件名。

这是一个极度愚蠢的习惯。因为为了让 Agent 执行这个简单操作，它需要把你的整个目录结构作为上下文（Context）上传到云端，这在瞬间就会浪费掉 10 万个 Token！

“如果你用手打一行命令只要 1 秒，就请用手打！别让 Agent 去干，每次手动操作能帮你省下几美分的 API 账单。”

2. 智能路由（Smart Routing）

高级的 AI 组织必须学会建立“路由机制”：把 90% 最愚蠢、最简单的问题路由给最便宜、甚至免费的模型；只有当任务触及复杂推理时，再将其升级（Escalate）到昂贵的顶级模型。

“在最高境界，AI 素养将变成一门关于‘如何用最少的 Token 开销，压榨出最大化业务成果’的系统级控制艺术。”

小结：平坦曲线是留给务实建设者的礼物

Steve Yegge 用一幅极其温情的插图——“Campground Craft（营地建设）” 结束了他的万字长文。

大模型的进化曲线变平，不仅不是坏事，反而是一次历史性的解放：

在过去的两三年里，创业者和开发者如同生活在随时会爆发海啸的沙滩上。你永远在焦虑自己辛辛苦苦构建的产品，会在下一次 GPT or Claude 的发布会中沦为废墟。

而平坦曲线的到来，意味着游戏规则终于稳定了。Sonnet 级别和 Opus 级别的模型能力，将在未来的好几年里保持行业主流地位。

这意味着，我们终于可以脚踏实地地坐下来，开始在坚固的土地上安营扎寨。 我们可以去设计更精妙的多 Agent 路由网络、去优化我们的数据库、去打磨我们的用户体验，去写出真正能运行十年的、伟大的、有工匠精神的系统。

属于浮躁投机者的时代已经结束，属于务实系统工程师的黄金时代，才刚刚开始。现在，擦干因焦虑而流下的汗水，让我们开始在平坦的草原上，修建那座真正属于未来的软件大厦。

资料链接：https://steve-yegge.medium.com/the-flat-curve-society-36c8b01eb33b

今日开放讨论：

你同意 Steve Yegge 关于“大模型能力进入平原期，SaaS 正在回归”的判断吗？在你的团队中，是否也存在“无节制消耗 Token 却产出大量平庸垃圾代码（Slop）”的现象？你打算如何开始在团队内部推行“Token 成本管理”？

欢迎在评论区留下你最深刻的系统级思考，我们一起在平坦曲线时代寻找前行的光芒！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/19/agentic-coding-and-persistent-returns-to-expertise

大家好，我是Tony Bai。

在生成式 AI 狂飙的今天，程序员群体正陷入一种前所未有的分化和焦虑中：

• 初级开发觉得前路茫茫，因为大模型写出的业务代码比他们更快、更整洁；
• 资深架构师虽然暂时安全，但也时刻担心随着大模型逻辑推理能力的指数级进化，自己的行业经验终有一天会被无情商品化。

“AI 究竟是专家经验的放大器，还是专家经验的掘墓人？”

为了彻底用科学数据回答这个终极命题，大模型领域无可争议的“编码之王” Claude 的母公司 Anthropic，于近日发布了一份具有里程碑意义的实证研究报告：《Agentic coding and persistent returns to expertise》。

这份白皮书的含金量极高。研究人员在确保隐私安全的前提下，深度追踪并分析了从 2025 年 10 月到 2026 年 4 月期间，全球开发者使用 Claude Code 的 40 万次真实交互会话（Sessions）。

报告揭示出的事实极其震撼、甚至有些反直觉：大模型并没有让专家的经验贬值，反而让“专家经验”在 AI 时代迎来了前所未有的暴利和溢价；与此同时，那些只会写语法糖、没有领域常识（Domain Knowledge）的普通程序员，正在被无情地边缘化。

下面，我们就用白皮书里的硬核数据，层层剥开这场残酷的 AI 权力重构。

权力的边界：人类负责“定目标”（70%），AI 负责“搬砖”（80%）

在这份大样本分析中，Anthropic 首先定义了人机协作在智能体编码（Agentic Coding）时代的新型分工模型（The division of labor）。

研究人员通过机器学习分类器，对 40 万次会话中的每一个动作进行了属性归类。他们惊奇地发现，人类与 Claude Code 在开发过程中展现出了极度清晰的边界：

• 人类主导“规划决策（What to do）”：在决定系统要构建什么功能、采用什么业务逻辑、遵循什么系统规范时，人类做出了 70% 的决策。
• AI 主导“执行决策（How to do it）”：在决定调用什么命令、修改哪些文件、使用什么具体语法、以及运行什么测试脚本时，Claude 承担了 80% 的工作。

这证实了：在真实的工业级开发中，大模型并不是在“取代”程序员，而是成为了一个不知疲倦、效率极高的“执行义肢”。人类出脑子（Framer），AI 出体力（Executor），这种分工正在成为现代软件开发的黄金标准。

专家溢价：为什么 AI 越强，资深专家的身价越贵？

这是整篇白皮书中最核心、也最震撼的发现：AI 的出现，极大地拉大了“专家”与“新手”之间的产出差距。

为了精确筛选和分析这 40 万次人机对话，Anthropic 在底层构建了一个极其严密的“五级经验分类器”。他们通过机器学习，根据人类输入提示词的专业度，对用户的工程段位进行了无情分类。

这套分类器不仅是学术工具，更是我们每个普通开发者自测“AI 时代身价”的终极试金石：

• L1 – 萌新（Novice）：
  • 标准：完全不使用任何领域专业术语，对 AI 的报错毫无感知，只能进行通用的验证。
  • 典型 Prompt：“你能帮我分析这些数据并画个图吗？” / “帮我看看趋势，求求你了。”
• L2 – 初学者（Beginner）：
  • 标准：开始使用少量的专业术语，但验证请求漫无目的，只有在 AI 犯了极其低级、显而易见的错误时才会进行反驳。
  • 典型 Prompt：“BigQuery 是什么？” / “你能跑个简单的 Demo 带我过一遍吗？” / “等下，你用的是我队友给的那个精确规范（Specification）吗？”
• L3 – 中级（Intermediate）：
  • 标准：能够用一定的领域专业性来框定问题，但无法深入探讨底层设计权衡。能进行一些非通用的检查，并开始主动捕捉 AI 的错误。
  • 典型 Prompt：“帮我看看这个分支能安全合并（Merge）吗？” / “如果我们在前端页面的每个部分建立单独的文件夹，会不会优化各个 Section 的缓存（Caching）？”
• L4 – 高级（Advanced）：
  • 标准：展现出强烈的领域知识，能够在不依赖 AI 提示的情况下，提前预判 AI 在该领域极易犯的特定错误。验证针对性极强，至少能揪出一次 AI 犯的底层逻辑错误。
  • 典型 Prompt：“在进入第三阶段之前，测试这一步的最佳方法是什么？” / “正则（Regex）在这里太脆了，有没有更稳固（More bullet proof）的方法，在解析 JSON 时基于 record 字段来进行键值提取？”
• L5 – 专家（Expert）：
  • 标准：使用极度复杂的行业黑话，能精准预测复杂的架构设计权衡。验证精准打击系统最薄弱的关节。能够无情纠正 AI 的错误，而 AI 几乎无法纠正专家的逻辑。
  • 典型 Prompt：“上个版本 PR 的修复根本不够，我们需要更深地排查用户反馈的这个 Bug。yeah，我们也许需要把‘强制刷新（hard refresh）’根据‘托管/非托管插槽（slots）’做进一步的拆分。 sync 必须可靠地知道锁（lock）的状态，还记得由于 valueDb 变脏（stale）而导致不断尝试设 Pin 的死循环 Bug 吗？”

在这套分类下，专家与新手在使用同一个 Claude Code 时，展现出了两个维度的“遥遥领先”：

1. 成功率的云泥之别（91% vs 15%）

根据白皮书的统计：在面临高难度的软件工程任务时，新手的完全成功率只有可怜的 15%（在最宽松的指标下也只有 39%）；而 L5 级别的领域专家，其成功率直接飙升到了 91%！

2. 吞吐量红利（AI 愿意为专家干更多的活）

数据表明，当新手发出一条指令时，Claude Code 平均只会执行 4.9 次行动，吐出 607 个单词。

而当 L5 级别的专家发出一条指令时，Claude 会如同遇到知音一样，在后台自动触发一系列复杂的链式反应，平均执行 11.7 次高级行动，狂喷 3,200 个单词的高质量代码！

为什么会这样？

因为 AI 智能体在面对模糊、没有领域常识的提问时，会迅速陷入“误解 -> 生成垃圾代码 -> 被编译器报错 -> 再次生成垃圾 -> 用户放弃（Abandon）”的死循环。

而面对专家时，由于专家给出了极其精确的“业务边界限制（Guardrails）”和“情境品味（Situated Taste）”，AI 能够顺着正确的方向无限hill-climbing（爬坡），发挥出大模型最极致的推理深度。

同时，当 AI 犯错时，新手无能为力，只能眼睁睁看着它胡说八道；而专家能够瞬间识别出 AI 的漏洞，给出一句精准的“纠偏提示”，牵着 AI 的手跨过泥潭。

边界消除：会写代码的审计师，正在干掉不会审计的程序员

如果说“专家在软件开发里更赚钱”还在我们的意料之中，那么白皮书指出的第三个趋势，则无情地打破了传统程序员的行业垄断：非软件行业的专家，正在用 AI “降维打击”传统的初级码农。

请仔细看白皮书给出的各行各业在使用 Claude 编写代码时的成功率：

1. 软件与数学专家：成功率 94%。
2. 管理人员（Management）：成功率 95%！
3. 法律人员（Legal）：成功率 97%！
4. 商业与金融专家（Business & Finance）：成功率 90%！

我们从图中可以看出惊人的行业跨界：凭借深刻的领域经验（Domain Expertise），金融、法律和管理人员在 AI 辅助下的编码成功率，几乎与专业软件工程师持平，甚至有所超越。

这绝对是一个核弹级的发现：决定代码质量的，不再是你的“编程语法熟练度”，而是你对“业务逻辑和领域常识的理解深度”。

• 一个完全不会写 Python 语法的资深会计师，通过 Claude Code，能够极其精确地描述出月末账目对账（Month-end reconciliation）的业务规则、税法限制以及漏单退回逻辑。Claude 能够根据他提供的完美业务逻辑，在几秒钟内生成一段毫无瑕疵的 Python 财务自动化工具。
• 而一个懂 Python 语法、却对财务审计一窍不通的初级程序员，他写出来的代码，在业务层面上大概率是充满漏洞的垃圾（Slop）。

“业务逻辑与情境品味（Situated Taste），正在成为 AI 时代最坚固的技术壁垒。而单纯的语法编写，已经彻底沦为了廉价的机器工。”

价值重构：如何成为不被“垃圾代码”淹没的 10%？

Anthropic 在报告的后半部分，进行了一项极其严谨的经济学评估：他们通过对比自由职业市场（Freelance job postings）的实际标价，来评估 40 万次 Claude 会话产生的经济价值。

数据显示，在短短 7 个月内，由 Claude Code 完成的任务的平均经济价值，暴涨了约 25%！

这说明，随着模型对工具调用、测试和自动化部署的演进，AI 正在以前所未有的速度吞噬那些“低价值的、纯编写的工作”。

这也给所有的软件工程师指明了一条唯一的出路：

1. 从“如何写（How）”迅速向“写什么（What）”转型：如果你的日常工作只是把产品经理的 PRD 翻译成代码语法，你和 AI 相比没有任何竞争优势。你必须去深入理解业务，理解数据库底层设计，去成为那个“定标和画框的人”。
2. 建立“纠偏与审计”能力**：大模型会源源不断地生成看似完美的代码。未来的高级工程师，其核心工作将是“代码审计师（Code Auditor）”。你必须能在几秒钟内，看出 AI 生成的千行代码中，那个隐藏在锁竞争或并发状态下的微小 Bug。
3. 深耕一个具体的垂直领域：不要做“通用的、只会写增删改查（CRUD）的程序员”。去深入医疗、金融、安全、芯片物理、或者高性能网络。

小结

大模型并没有让专家的经验贬值，反而像一把高压水枪，正在迅速冲刷掉代码工程中的淤泥，让真正拥有“业务品味”和“领域常识”的金子，闪耀出前所未有的夺目光芒。

AI 降低了普通人写代码的门槛，但也让“垃圾代码”遍地都是。

在这个平庸泛滥的时代，决定你身价的，不再是你敲击键盘的速度，而是你脑海中沉淀的那些、无法被文本化的行业直觉与工程审美。

在这场人机共生的伟大战役中，我们既要学会借用神明的光芒，也要时刻警惕不要沦为神殿下盲目的祭品。

资料链接：https://www.anthropic.com/research/claude-code-expertise

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/18/why-choose-go-over-rust-today-in-ai-age

大家好，我是Tony Bai。

随着 Cursor、Claude Code 和 Copilot 等 AI 编程智能体的爆发，整个技术圈的开发门槛被前所未有地铲平了。

在过去，Rust 最大的劝退门槛是它那极其陡峭的路径——生命周期、借用检查器（Borrow Checker）、复杂的泛型特征（Traits）。但如今，AI 可以轻而易举地帮你写出能够通过编译的复杂 Rust 代码。

这就引发了一个最近在 Reddit 的 r/golang 讨论区的终极发问：“既然 AI 已经帮我们消灭了 Rust 的学习和编写门槛，今天我们为什么还要选择 Go？（Why choose Go over Rust today?）”

海外大厂的资深架构师和 SRE 们纷纷下场，用生产环境中的血泪教训，给出了一个极具警示意义的工程结论：AI 极大地降低了“写”代码的门槛，却无形中成倍抬高了“读”与“维护”代码的成本。而在充斥着 AI 生成代码的时代，Go 语言那近乎固执的“简单与无聊”，反而成为了它最坚不可摧的壁垒。

以下是为什么在 AI 时代，Go 依然是很多企业技术选型终极首选的深层逻辑。

致命的“温水煮青蛙”：谁来在凌晨三点排查 AI 写的代码？

在帖子中，一位获得了极高赞同的资深开发者贴出了一句直击灵魂的忠告：

“如果你打算让 AI 写完所有代码且你从不检查，那么 Rust 是完美的（因为编译器会守住安全底线）……前提是，你是那个在凌晨 3 点值班、随时准备被报警电话叫醒去排查问题的人。”

这句话道出了软件工程中最朴素的真理：编写代码是一时的，而阅读、评审（Code Review）和在线排查（On-Call）才是永恒的。

大模型在生成代码时，为了迎合编译器的规则，往往会采用极其复杂、精妙但难以阅读的“高级语法特性”。

• AI 写的 Rust 代码：可能会充斥着各种复杂的泛型嵌套、宏（Macros）、高度抽象的 Trait 绑定以及微妙的生命周期标注。它确实能通过编译，但当它在生产环境中遇到边界条件发生崩溃时，由于代码不是你写的，面对这堆“天书般的高级 Rust 代码”，你根本无法在短时间内看清它的真实意图。
• AI 写的 Go 代码：由于 Go 语言刻意限制了特性的复杂性，奉行“一种问题只有一种解法”的极简主义。AI 写出来的 Go 代码，看起来和你自己写的、或者你同事写的没有任何区别。任何一个普通的后端开发，都能在 30 秒内梳理清楚数据流向。

在 AI 大规模入侵开发流水线的时代，“易读性”和“低认知负载（Cognitive Load）”成了比“易写性”更重要的资产。Go 的无聊和易读，在这个时候反向成了它最大的护城河。

运行时的隐形深渊：GMP 模型 vs 协作式异步的“雷区”

在涉及到高并发的系统设计时，很多开发者以为 Rust 拥有完美的类型安全（线程安全的 Mutex 检查等），就能在并发上完胜。

但 Reddit 上的多位分布式系统工程师指出了一个极易被忽视的“运行时隐形深渊”：非抢占式并发（Cooperative Async）的惩罚。

1. Go 的“无脑并发”（GMP 抢占式调度）

Go 语言底层的 GMP 调度器支持抢占式调度（Preemptive Scheduling）。

这意味着，即便 AI 给你写了一段“烂代码”（例如在一个 CPU 密集的循环里没有主动让出 CPU），Go 运行时也会在底层强行打断它，把执行权分给其他协程。你的服务可能会变慢，但绝对不会卡死。

2. Rust 的“协作式深渊”（Tokio 异步事件循环）

Rust 的主流异步运行时（如 Tokio）是协作式（Cooperative）的。

这意味着，如果 AI 帮你在一个 async 函数内部偷偷夹带了一句同步阻塞操作（比如调用了一个同步的第三库去读文件或发起网络请求），它会直接霸占并锁死整个事件循环（Event Loop）！

这种低级错误，Rust 那引以为傲的编译器完全无法察觉。在线上高并发场景下，这会导致整个微服务在瞬间陷入死锁状态。

在 AI 辅助开发时代，由于大模型无法完美感知具体的系统上下文，AI 极易在 Rust 的 async 块中引入阻塞调用。这让 Rust 系统的线上隐患比 Go 尖锐得多。

标准库生态 vs 依赖地狱（Crate Hell）

在构建微服务和后端 API 时，Go 的另一个绝对优势是它的 “Batteries included（自带电池）” 哲学。

• Go 的富标准库：Go 拥有世界上最强大、最稳定的标准库。你不需要引入任何第三方包，仅靠标准库就能写出高性能的 HTTP 服务器、完美的 JSON 解析器以及加密服务。这意味着你的项目极其干净，几乎没有供应链安全风险，并且可以无视版本的向前兼容。
• Rust 的极简库与 Crate 地狱：为了追求极致的小体积，Rust 的标准库非常“贫瘠”。写一个普通的 Web 服务，你不得不引入 tokio、serde、reqwest 等一整棵庞大的第三方树（类似于 Node.js 的 node_modules 依赖灾难）。

当项目依赖树膨胀到上百个节点时，不仅编译时间（Compile Times）会变得极其冗长（Rust 本就因为编译慢而臭名昭著），AI 也会因为各个第三方库之间复杂的版本冲突，频繁生成无法通过编译的代码，让开发体验陷入泥潭。

黄金法则：90% 的性能，10% 的心智负担

在经历了一轮轮深刻的讨论后，技术老兵们为我们总结出了一条极其务实的决策黄金法则：

除非你的业务是在写操作系统内核、高频交易引擎、或者内存极其受限的边缘设备；否则，用 Go 来换取 10 倍的开发效率、秒级的编译速度，以及任何人都能在 3天内上手的极低维护成本，在商业世界里永远是一个性价比高得多的选择。

小结

AI 的爆发并没有让“简单”失去价值，反而让“简单”变得更加昂贵。

AI 降低了代码“写”的门槛，但也导致互联网上的平庸同质化代码（Slop）呈指数级爆发。在充斥着 AI 生成代码的未来，能够一眼被看穿、能够被任何人轻松评审、能够无痛维护的代码，才是最稀缺的技术资产。

Go 语言那近乎固执的“无聊”与“克制”，并不是落后，而是其对“人机协同软件工程”最深邃的先见之明。

资料链接：https://www.reddit.com/r/golang/comments/1u2u96q/why_choose_go_over_rust_today/

今日开放讨论：

大模型确实降低了我们“落笔写代码”的门槛，但它同时也以前所未有的速度，向整个世界的代码库里倾倒着似是而非的“平庸垃圾（Slop）”。

面对这场温水煮青蛙的“人机协作大潮”，我们也想听听你在一线最真实的工程感受：

1. 你是否尝试过让 Cursor 或 Claude 帮你生成复杂的 Rust 代码？ 在实际编译和后续维护中，你觉得 AI 究竟是帮你“拆掉了门槛”，还是在暗中给你“挖了更深的坑”？
2. 如果今天你要为团队新立项一个中大型的后端微服务， 在有 AI 编程工具辅助的前提下，你会更倾向于选择“3 天就能上手、编译仅需毫秒的 Go”，还是“心智负担极高、但上限和安全性拉满的 Rust”？
3. 你是否经历过被 AI 生成的“黑盒代码”在半夜三点叫醒 On-Call 的惨痛经历？

欢迎在评论区留下你最硬核的观点，或者把这篇文章一键转发给身边正在为“技术栈选型”纠结的架构师朋友。我们评论区见！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/17/deepmind-automation-agent-harness-ai-self-coding

大家好，我是Tony Bai。

过去的几个月，整个 AI 开发圈最火的词，无疑是 Agent Harness（智能体驾驭系统）。

从 Claude Code 到 OpenClaw，再到我自己的极客时间专栏，我们所有走在 AI 原生开发前沿的工程师，都在不遗余力地布道一个核心思想：大模型本身只是一个“毛坯大脑”，你必须为它手工打造一套精密的“外部骨骼（Harness）”，它才能真正干活。

我们研究 ReAct 循环、设计上下文压缩引擎、构建安全中间件……我们以为，掌握这套“驾驭工程学”，就是我们在 AI 时代的终极护城河。

但就在今年年初，AI 领域的“神殿”——Google DeepMind——直接掀了桌子。

他们发布了一篇名为《AutoHarness: a code harness for LLM agents by automatically synthesizing a code harness》的重磅论文，用极其详实的数据和实验，向全世界宣布了一个既震撼又令人脊背发凉的事实：

别再苦哈哈地手写 Harness 了，我们已经能让 AI 自己为自己编写“规则护栏”了。

这篇论文同时也像一面镜子，照出了即便是最顶级的 AI Agent，在没有“护栏”的情况下有多么“愚蠢”；更像一声警钟，预示着我们人类工程师在 AI 产业链中的角色，即将迎来又一次深刻的变迁。

78% 的败因，竟是“犯规”

在展示 AutoHarness 有多强大之前，DeepMind 的科学家们先用一个极其残酷的案例，揭示了为什么 Harness 是“必需品”。

在上一次的 Kaggle 线上国际象棋大赛中，被寄予厚望的 Gemini 2.5 Flash 模型，其 78% 的对局失败，竟然不是因为技不如人，而是因为它试图走出“非法步骤（Illegal Moves）”！

比如，它会尝试让“马”走直线，或者把“兵”横着走。

这个案例，完美地暴露了所有大模型的“原罪”：它们拥有惊人的“语言理解能力”，却没有足够的“规则遵守能力”。

AI 知道成千上万种开局策略，但它不知道在当前的棋盘状态下，哪些格子是它能走的，哪些是不能的。它只是在基于概率，模仿它在训练数据中见过的、最像“正确答案”的文本。

传统的解决方案是什么？

• 模型微调（Fine-tuning）：用海量的棋局数据去微调模型。代价极高，速度极慢，而且可能会损害模型在其他任务上的泛化通用能力。
• 手工编写 Harness：由人类工程师为每一款游戏，硬编码一套“规则校验器”。工作量巨大，且极度脆弱，换个游戏就得重写。

让 AI 成为自己的“规则老师”

面对这个两难的困境，DeepMind 的思路堪称“降维打击”：

既然 AI 这么会写代码，为什么不让它自己根据环境的反馈，为自己写一个“规则校验器（Code Harness）”呢？

AutoHarness 的核心流程，就像一个优雅的“自我进化”闭环：

1. 初始探索：让一个基础模型（比如 Gemini 2.5 Flash）在游戏环境中自由发挥，生成一个初始版的 Python 策略代码，包含 propose_action() 和 is_legal_action() 两个函数。
2. 试错与反馈：在 10 个并行的游戏环境中，同时运行这段代码。一旦 AI 走出了“非法步骤”，或者代码执行出错，系统会立刻终止，并将失败的步骤和环境给出的错误信息，一起打包发给一个“批评家（Critic）”。
3. 代码精炼：批评家将错误信息进行整理，连同原始的“问题代码”，一起喂给一个“精炼器（Refiner）”。“精炼器”的角色同样由一个 LLM 担任，它的任务是：“看，你写的这段代码犯了这些错，现在请你把它改对。”
4. 循环进化：精炼器生成一段新的、有望修复 Bug 的代码，然后再次投入到游戏环境中进行测试。如此循环往复。

这个过程，本质上是一个基于“树搜索”和“迭代式代码精炼”的自动化编程过程。

结果有多惊人？

• 在 145 个不同的文本游戏中，AutoHarness 平均只需要 14.5 次迭代，就能为 Gemini 2.5 Flash 生成一个达到 100% 准确率的“合法走步”校验器。
• 在国际象棋（Chess）和奥赛罗（Othello）这种极其复杂的游戏中，AutoHarness 也能在几十次迭代后，完美掌握所有规则。

以弱胜强：当“AI+护栏”轻松碾压“最强大脑”

AutoHarness 最令人震撼的是它带来的“以弱胜强”的恐怖效果。

DeepMind 组织了一场对战实验：

• 甲方：小模型 Gemini 2.5 Flash，但装备了由 AutoHarness 自动生成的“规则护栏”。
• 乙方：比 Flash 强大得多的当时的旗舰模型 Gemini 2.5 Pro，但没有任何护栏，“裸奔”上场。

在 16 款不同的双人对战游戏中，结果呈现出一边倒：

装备了“护栏”的小模型 Flash，在与大模型 Pro 的对战中，胜率高达 56.3%！而 Pro 的胜率仅为 38.2%。

这张图清晰地展示了在多款游戏中，“Flash+Harness”组合的绿色胜利条，是如何显著高于 Gemini-2.5-Pro 的。

这个实验也再次印证了：一个更小的、但被良好“驾驭”的模型，其战斗力是可以超越一个更大、更昂贵、但却在“裸奔”的模型的，足见Harness的重要性。

更极端的是，DeepMind 甚至让 AI 把整个游戏的策略，都写成了确定性的 Python 代码（Harness-as-Policy），在运行时完全不需要再调用 LLM。
结果，这段由小模型生成的纯代码，在 16 款单人游戏中的平均得分，甚至超越了 GPT-5.2-High！

人类的新角色——“环境设计师”与“评估者”

DeepMind 的这篇论文，给我们这些正在苦心钻研 Harness Engineering 的工程师，带来了极其深刻的反思。

它似乎在告诉我们：未来，我们最重要的工作，可能不再是亲手去为 AI 编写“规则”，而是为 AI 设计一个能够让它“自我学习规则”的环境。

我们的角色，正在从“手工艺人”，向两个更高级的职位迁移：

1. 环境设计师（Environment Designer）

AutoHarness 之所以能成功，是因为 DeepMind 的科学家们为它精心设计了一个能提供清晰、即时反馈的游戏环境。

未来，我们的核心任务，将是把我们复杂的业务系统，抽象成一个个能让 AI 安全“试错”、并能从错误中学习的“模拟环境”。

2. 评估体系架构师（Evaluation Architect）

AutoHarness 的另一个关键，是那套能自动判断“好坏”的评估体系。

在 DeepMind 的实验中，他们引入了“批评家”、“裁判”等多个 AI Agent，来自动化地评估新生成的代码。

这正是我在自己的专栏《从 0 开始构建 Agent Harness》中，反复强调的 Evals（自动化评估体系） 的重要性。

当 AI 能写 Harness 时，我们人类的终极护城河，就变成了定义“什么是好的 Harness”的能力。

小结：从“教它做事”到“教它学习”

AutoHarness 的出现，意味着我们可能正在从“授人以鱼”（直接给 AI 写好的规则），进化到“授人以渔”（教 AI 如何自己学习规则）。

这既可以解放了我们的生产力，更是开启了一条通往“AI 递归式自我改进”的、充满无限想象力的大门。

当然，这并不意味着手写 Harness 会立刻消失。对于极其复杂、安全要求极高的领域，人类专家的经验依然不可或缺。

但这篇论文，至少为我们指明了方向：不要再把 AI 当作一个需要你手把手教的“学徒”了。把它当作一个极具天赋、能够自我反思的“初级程序员”，为它提供清晰的测试用例、明确的错误反馈，然后，放手让它自己去进化。

这，或许才是 AI 原生时代，最高级的“人机协同”。

资料链接：https://arxiv.org/abs/2603.03329

今日互动探讨：

看完 DeepMind 的 AutoHarness，你对 Agent 开发的未来是感到兴奋，还是感到了“饭碗不保”的焦虑？你认为 AI 自动生成“规则护栏”的模式，离我们日常的业务开发还有多远？

欢迎在评论区分享你的看法！

认知跃迁：在 AI“自我进化”前夜，你的核心壁垒是什么？

当 AI 开始学会自己编写“驾驭系统”时，我们这些正在苦学 Harness Engineering 的人类工程师，价值何在？

答案是：回归第一性原理。

AutoHarness 虽然强大，但它依然需要人类去定义底层的循环机制、安全边界、成本审计和评估框架。这些，才是 AI 无法自我生成的、真正属于“架构师”级别的智慧。

如果你还在为写 Agent 框架频频死循环、上下文爆炸而束手无策，如果你想在 AI 彻底实现“自我编程”之前，抢先一步，成为那个“设计进化环境”的人——

我的新专栏 《从 0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启你的“AI 环境设计师”之路。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/16/why-if-it-compiles-it-runs-rust-engineering-aesthetics-and-logic

大家好，我是Tony Bai。

在软件工程界，有一句流传甚广、近乎玄学的名言：“如果你的 Rust 代码通过了编译，那么它就已经可以正确运行了。”

对于被 Java 的空指针异常（NullPointerException）折磨得彻夜难眠、被 C++ 的段错误（Segfault）逼到崩溃、或者在 TypeScript 里为处理各种隐式错误而心力交瘁的开发者来说，这句话听起来像是一个过于美好的谎言。

为了探寻这句话背后的真相，在最近的一期访谈中，Google Android Rust 团队成员、Rust 语言团队顾问、高并发异步运行底座 Tokio 的核心维护者 Alice Ryhl，深度拆解了 Rust 的底层设计。

从一个在高中为了写《我的世界》（Minecraft）模组而自学 Java 的少女，到在 Rust 官方论坛上累计解答 10,000 个问题的硬核专家，Alice 用她极具说服力的工程视角，为我们揭示了 Rust 是如何通过极致的编译器设计、数据结构约束以及民主化的社区治理，彻底改变现代软件工程的。

终结“十亿美元的错误”：Rust 怎么保证代码的绝对可靠？

大模型时代，写代码的门槛越来越低，但系统的可靠性却变得前所未有的脆弱。Alice 认为，要让一门语言写起来有“编译即正确”的底气，最核心的底座是其类型系统。

1. 彻底消灭 null 隐患

1965 年，图灵奖得主 Tony Hoare 发明了 null 引用，后来他痛苦地称其为自己的“十亿美元错误”。在 Java 中，每一次函数调用，你都必须时刻提防它可能返回一个 null，进而导致程序崩溃。

而在 Rust 中，null 这一概念根本不存在。

如果你需要表达一个变量可能为空，你必须显式地使用 Option 枚举。最关键的是：编译器会用铁律强迫你在使用该变量之前，必须进行解包和空值检查。 你无法偷懒，更无法遗忘，因为漏掉任何一种可能，编译器都会拒绝通过。

2. 显式且不容忽略的错误处理

与 Java 或 C++ 依赖隐式垃圾回收或异常抛出（Exceptions）不同，Rust 采用了一种极其务实的做法：将错误作为普通的值返回。

// Rust 中的经典错误处理模式
let file = File::open("config.json")?;

这里的 ? 操作符是 Rust 的标志性设计。它意味着：如果打开文件失败，立刻将错误向上抛出。如果你忘记写这个 ?，或者没有对返回的 Result 进行处理，编译器就会报出一个无法忽视的错误。

这里体现的 Rust 的工程美学在于：它不依赖开发者的细心和自律，而是用编译器的钢性约束，把所有可能在生产环境中暴雷的隐式错误，提前在开发期彻底榨干。

妙到极致的“文档即测试”（Doc Tests）

你是否经历过这样的绝望：接手一个项目，按照 README 里的示例代码复制粘贴，结果编译报了一堆错——原来代码重构了，但写文档的人忘了更新示例。

在 Rust 中，这个问题被一个近乎艺术级的设计解决了：文档即测试（Doc Tests）。

在 Rust 中，只要在代码前使用三个斜杠 ///，就可以为函数编写 Markdown 格式的文档：

/// 这个函数将两个数字相加。
///
/// # Examples
///
/// ```
/// let result = my_crate::add(2, 2);
/// assert_eq!(result, 4);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

当你运行 cargo test 时，Cargo 会自动提取你文档注释中的所有代码示例，并把它们作为单元测试全部跑一遍！

如果你的代码发生了重构，导致文档里的示例代码跑不通了，你的整个 CI/CD 构建流就会直接宣告失败。这种设计逼迫开发者：要想代码通过编译，你的文档和示例就必须永远保持最新。 这种对代码 hygiene（工程卫生）的极致追求，让 Rust 成了开源界文档质量最扎实的生态。

新手的终极撞墙期：不要修改代码，去修改你的数据结构！

每一个从 TypeScript、Java 或 Go 转型到 Rust 的开发者，都经历过一段极其痛苦的时期——被“所有权（Ownership）”和“借用检查器（Borrow Checker）”无情蹂躏，俗称“与借用检查器肉搏”。

Alice 指出，几乎所有新手在这个阶段都犯了一个根本性的方向错误：他们试图通过不断修改局部代码逻辑来通过编译，而真正的解法往往是修改数据结构（Struct）。

1. 循环引用的噩梦

在 TypeScript 里，我们建一个“书（Book）”和“页面（Page）”的对象，习惯于让 Book 引用 Page，同时让 Page 也引用回 Book：

Book  ──────>  Page
  ▲              │
  └──────────────┘

这种循环引用在有垃圾回收（GC）的语言中很常见。但在 Rust 这种没有 GC、依靠变量作用域结束自动释放内存的语言中，循环引用会导致内存释放链条死锁（编译器不知道该先释放谁，容易造成内存泄露或双重释放）。

2. 金科玉律：“改变数据结构，而不是改变代码”

当你在 Rust 中遇到借用冲突时，正确的思路是：

• 消除循环引用：将数据结构重构为清晰的、无环的有向无环图（DAG）或树状结构（Tree）。
• 利用引用计数：如果一个对象确实需要在多个地方共享所有权，不要强行用引用，改用引用计数指针 Arc（Atomic Reference Counted）。

通过调用 Arc::clone(&my_obj)，你可以安全、轻量地在多线程中共享同一块只读内存。当最后一个 Arc 离开作用域时，内存会自动被安全释放。

写 Rust 会强迫你在落笔之前，先在脑海中画出极其清晰的数据所有权图谱。这种高强度的架构思考，正是“编译通过即安全”的底气来源。

揭秘 unsafe 的真相：它不是后门，而是高级特权的封装

对于 Rust 的批评者来说，unsafe 关键字经常被拿来作为攻击的靶子：“既然 Rust 声称安全，为什么还留了 unsafe 这个后门？”

Alice 对此给出了极其严密的工程解释：unsafe 绝不是用来关闭编译器检查的后门，它是一个用于向语言注入全新特权的封装箱。

1. unsafe 关不掉借用检查器

一个普遍的误区是，在 unsafe 块里，你可以为所欲为。

事实是：在 unsafe 块中，借用检查器依然在严密工作。unsafe 仅仅是允许你多调用几个被标记为 unsafe fn 的特殊函数，或者操作原始指针（Raw Pointer）。

2. 极致性能与安全边界的统一

在普通代码中，你访问数组元素 vector[5]，编译器会在运行时默默检查数组长度，防止越界崩溃。但如果你在写追求极致性能的音视频解码器，或者在写 Linux 内核驱动，这种运行时的边界检查（Bounds Check）积累起来会产生无法接受的开销。

此时，你可以调用 get_unchecked(5)，它是一个 unsafe 函数，会直接跳过长度检查，直接去读内存。

// 只有在确定不越界的前提下，包裹在 unsafe 中以提升极致性能
unsafe {
    let value = my_vector.get_unchecked(5);
}

3. 用“安全的 API”封装“不安全”

Rust 的核心哲学是：你可以在底层用 unsafe 制造一个高效率的基础构件（比如 Vector 容器的底层实现就是基于原始指针分配和释放），但你必须用极致私有的字段和严密的公共 API，把它包裹成一个绝对安全的、暴露给外部用户使用的安全接口。

只要你的 API 设计无懈可击，外部调用者无论写出多么愚蠢的代码，也绝对无法突破这道安全的封装线。这就是为什么在企业后端开发中，你的业务代码中 unsafe 的使用率应当为 0%。

民主化的工程奇迹：没有“独裁者”的团队是如何高效演进的？

不同于 Python 或 Linux 内核拥有创始人（如 Linus Torvalds）作为“终身仁慈独裁者（BDFL）”来进行终极仲裁，Rust 语言的治理是一个彻底去中心化的、基于共识和提案的民主体系。

这个体系主要由两个精妙的工程机制驱动：

1. 极其严苛的 RFC（Requests for Comments）模版

当你想给 Rust 增加一个稍微大一点的特性时，你必须提交一份 RFC 提案。这个提案的模版极其考验作者的工程思维，其中有两个非常天才的设计：

• Guide-level explanation（引导级说明）：你必须假设这个特性已经存在，写一段像新手教程一样的指南来介绍它。这逼迫提案者从用户体验和易用性的角度去审视特性，而不是一上来就堆砌底层实现细节。
• Reference-level explanation（参考级说明）：详细的技术规范，相当于语言参考手册的起草。
• Alternatives & Prior Art（替代方案与先验艺术）：你必须写清楚为什么不采用另外几种设计，以及 C++、Go 等其他语言在这一块是怎么做的。这能让你在被别人质问之前，先在文档里把所有漏洞堵死。

这种 RFC 流程类似于亚马逊（Amazon）推行的 PR/FAQ 撰写机制，它确保了每一项进入语言的特性，在写第一行编译器代码之前，就已经在逻辑和易用性上被推敲到了极致。

2. 解决破坏性更新的“版次（Edition）”机制

当一门语言发展到一定阶段，难免需要引入破坏性更新（Breaking Changes），比如增加新的关键字。Python 从 2 升级到 3 导致了整个生态长达数年的割裂，至今仍是社区的隐痛。

而 Rust 发明了 版次（Edition） 机制，完美解决了这一难题：

• 编译器的包容性：不同 Edition 的包（Crates）可以在同一个项目中完美混用。
• 无缝兼容：你的底层库可以用 2021 版次编写，而我的主业务可以用 2024 版次调用它，编译器在底层会把它们无缝融合成统一的二进制程序。
• 语法平滑过渡：大版本更新（如引入 async/await 关键字）只在特定的 Edition 里生效，旧 Edition 的代码中依然可以安全地将 async 用作普通变量名。

这种精密的后向兼容机制，确保了 Rust 既能保持激进的技术进化，又绝对不会把老用户丢在半路上。

小结：从“写完代码再调试”到“在安全网中优雅降落”

在 Alice 的工程世界里，写 Rust 并不是在追求一种虚无的技术时尚，而是在实践一种将人的主观失误降到最低的现代工程学。

Rust 并不是万能的，在 Web 前端等需要快速试错、频繁变更界面的场景中，它显然不如 TypeScript 轻量和灵活。但只要你的业务涉及到高并发的后端、高可用的微服务、极致性能的系统底层，或者不容许有任何安全漏洞的防御性工程，Rust 就是目前人类技术栈中最坚固的防线之一。

写 Rust 的过程，是一次编程习惯的洗礼：

你不再需要战战兢兢地把代码部署上线，然后盯着监控屏幕祈祷不要发生内存泄漏；你是在编译器的细心呵护下，将所有已知的安全隐患和逻辑死角在开发阶段一扫而空，然后在类型系统的安全网中，优雅、从容地平稳降落。

而这，正是“编译通过，即可运行”这句工程神话背后，最朴素也最震撼人心的底层逻辑。

资料链接：https://www.youtube.com/watch?v=q9xD36NCtZ8

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/15/google-ai-in-sre

大家好，我是Tony Bai。

整个软件工程界正在经历一场由生成式 AI 引发的“效率大爆炸”。

随着 GitHub Copilot、Claude Code、Codex 以及OpenClaw、Hermes等各类AI Agent 的普及，企业编写代码、构建功能并将其推向生产环境的速度，正在以 4 倍到 10 倍 的速度疯狂飙升。

然而，在这场高歌猛进的效率狂欢背后，软件工业最脆弱的防线——系统稳定性（SRE, Site Reliability Engineering），正在面临前所未有的毁灭性挑战。

传统由人类主导的 Code Review、基于静态监控指标的告警排查，在“机器以微秒级吞吐代码”的时代，已经彻底沦为杯水车薪。当代码提交量和部署频率暴涨 10 倍，意味着系统故障和未知黑盒技术债的涌入速度也暴涨了 10 倍。

为了应对这场“AI 带来的生产力过载危机”，谷歌 SRE 团队于近日发布了一份极具颠覆性的系统级白皮书：《AI in SRE: How Google is Engineering the Future of Reliable Operations》。

在这份白皮书中，谷歌首次向外界披露了其内部正在运转的、以 Agent 编排与闭环控制（Closed-loop Control）为核心的下一代自愈式运维系统。

今天，我们就来深度拆解这份代表着全球顶级运维水平的技术白皮书，看看谷歌是如何在 AI 时代，重新定义系统可靠性边界的。

为什么 AI 编码越快，运维死得越早？

谷歌 SRE 团队在白皮书的摘要中开门见山地指出：Site Reliability Engineering 正处于一场范式转移的阵痛中。

传统 SRE 的工作模式（SLO 定义、错误预算、消除琐碎工作）是建立在“人类编写代码的速度有限”这一物理前提下的。当 AI 充当了代码放大器，系统复杂度的膨胀速度已经远远超出了人类的阅读和心智承受极限。

谷歌提出了 AI 在运维系统中的 五个自治级别（SRE AI Autonomy Levels）：

在 L0 和 L1 阶段，人类还是绝对的“消防员”。但面对海量的机器代码，人类的响应时延（以分钟或小时计）在微秒级的故障蔓延面前毫无抵抗力。

谷歌认为，未来的 SRE 必须快速向 L3（高度自治）甚至 L4（完全自治）推进——即让 AI 智能体在无需人类确认的情况下，自主检测、诊断并安全地执行线上变更。

但问题是：谁来保证 AI 智能体本身不会“抽风”？ 一旦拥有自主执行权的 AI 智能体做出了错误的决策（例如在流量高峰期错误地清空了整个集群的负载），其造成的灾难（Blast Radius）将比人类操作失误大上千倍。

谷歌 SRE 的核武器：三大内部 AI 运维王牌组件

为了将 AI 安全地引入生产环境，谷歌在内部研发并上线了三套极具系统美学的底层 AI 平台。

1. IRM-Analyzer：将人类“救火轨迹”转化为黄金训练数据

AI 智能体要学会如何排障，首先需要向最优秀的人类 SRE 学习。但人类在排障时的行为是极其零散且非结构化的（躺在 Slack 聊天记录里、GVC 语音里、或者手动的命令行里）。

为此，谷歌开发了 IRM-Analyzer（事件分析平台）：

IRM-Analyzer 能够自动将零散的 Slack 聊天、日志报错、监控曲线，自动提炼并拼装成结构化、可复现的人类排障轨迹（Human Trajectory）。

IRM-Analyzer 利用大模型，能够将一场长达数小时、涉及数十人的混乱救火过程，自动解析、过滤、去噪并聚合成一条精确的时间线（Timeline），标明：什么时候观察到了 SLA 异常、什么时候执行了 canary 排水（Mitigation）、什么时候验证了服务恢复。

这条高纯度的时间线，成为了训练 AI Operator（智能体运维官）的 “黄金数据（Golden Data）”。

2. InvD（Investigation Dashboard）：一键生成的排障图谱

在发生线上故障时，人类 SRE 往往需要手忙脚乱地打开几十个 Grafana 仪表盘，手动过滤日志。

谷歌自研的 InvD（自动排障仪表盘，Investigation Dashboards） 彻底终结了这一状态。当收到告警时，InvD 会自动爬取相关的遥测数据，结合历史黄金数据进行推理，自动在网页上渲染出一张“自动故障拓扑图（Automated troubleshooting graph）”（如下图所示）。它能直接指出：这是由于某个新版本的二进制 Rollout 导致的 CPU 节流，并建议立即执行隔离。

数据表明，InvD 的上线，让谷歌受影响服务的平均缓解时间（MTTM）骤降了 44%！

3. Antigravity CLI：用 Go 编写的 AI 运维终端

我们在之前的文章中提到，Go 已经成为了 Google 内部智能体系统的通用语言。在 SRE 领域，这一趋势得到了最直接的印证：谷歌推出了基于 Go 开发的全新核心终端——Antigravity CLI。

通过集成标准的 MCP（Model Context Protocol）协议，Antigravity CLI 让 AI 智能体可以直接通过命令行与谷歌内部庞大的 Borg 系统、日志系统和 Bug 跟踪系统进行交互：

• 自动创建并分配故障单（Create/Assign Bugs）；
• 一键将事故复盘文档导出至 Google Docs；
• 执行底层的流量排干与扩容指令。

终极安全防线：决策与执行的“冷热解耦”

在白皮书中，谷歌提出了一个极其震撼且对所有企业都有借鉴意义的安全架构：“不要让做决策的 AI，直接去碰你的服务器。”

谷歌将这一安全哲学称为 The Safety Trifecta（安全三驾马车），并在底层通过 Actus（Actuation Agent，执行控制智能体） 实现了完美的“决策与执行解耦”：

1. 思考脑：AI Operator（决策智能体）

当系统报警时，AI Operator 会介入调查。在它的控制台（CoT, Chain of Thought）上，它会写下它的思考过程（例如：“检测到内存 OOM，怀疑是由于昨天部署的镜像导致的，建议将其副本数扩容 100% 以平摊压力”）。

2. 安全闸口：Actus（执行校验智能体）

AI Operator 拥有极高的智慧，但它在 Google 内部没有一丁点直接操作服务器的物理权限。

它提出的所有变更请求，必须提交给一个由确定性安全规则和零信任机制控制的物理控制平面——Actus。

• 强制 Dry-Run 支持：任何 AI 提出的 API 修改，Actus 会首先将其置于 dry_run=true 状态进行沙箱模拟，观察系统的报错。
• 智能体断路器（Agentic Circuit Breakers）：Actus 拥有最高级别的限流权限。如果发现某个 AI Agent 陷入了无限死循环、或者短时间内发起了超出 quota 的异常变更，断路器会瞬间切断其所有执行权限，并向人类 SRE 抛出报警。
• 零信任与最少特权：AI 智能体绝对不允许使用其开发者的个人凭证去登录服务器。它们拥有自己高度受控、双重强认证的 Agent Identities，且权限范围窄到极致（比如只允许在特定时间内调配流量，绝对不允许直接 ssh 运行原生 shell 脚本）。

这种将“会犯错的 AI 思考脑（LLM）”与“绝对遵守确定性安全规则的 Actus 控制面”进行冷热解耦的设计，是谷歌敢于将生产系统向 L3/L4 级别自治推进的终极底气。

范式革命：从“救火队员”到“安全架构师”的蜕变

当 AI 编排和 Actus 控制面接管了线上 90% 的基础告警和自动排水后，人类 SRE 应该去干什么？

谷歌给出的答案非常具有前瞻性：人类 SRE 正处于从“操作者（Operator）”向“安全架构师（Architect）”演进的关键节点。

过去，SRE 的价值体现在“手速”和“经验”上——谁能最快登录服务器找到那个坏死的配置，谁就是英雄。

现在，AI 的手速是人类的万倍。人类 SRE 的价值，转而体现在“定义安全边界和Actus策略（Defining Safeguards）”上：

• 设计高质量的 Evaluation Pipeline：设计更好的回归测试集，确保 AI 智能体在上线前不会退化。
• 架构高可用的渐进式发布（Progressive Rollouts）：针对 AI 10倍速的代码产出，设计更加敏感、能够自适应调整分流比例的“渐进式金丝雀发布”机制。

小结

大模型时代的到来，并没有像悲观主义者预言的那样带来软件工程的崩溃。相反，它正在强行将我们从枯燥、重复、高心智负担的“人肉运维”中解脱出来。

正如谷歌 SRE 团队在白皮书结尾所展现出的深邃洞察：

在机器以微秒级吞吐代码、部署服务的时代，人类工程师的价值，不再于手持水枪冲进火场，而在于设计出一套完美无瑕、能够自动防爆的自愈消防网。系统可靠性的终极边界，依然牢牢掌握在那些对生产环境心存敬畏、能够设计出严密安全闸口的系统架构师手中。

AI 负责疯狂奔跑，而我们，负责用优雅的系统工程，为它画出最安全的跑道。

资料链接：

• https://sre.google/resources/practices-and-processes/ai-engineering-reliable-operations/
• https://cloud.google.com/blog/products/devops-sre/how-google-sre-is-using-agentic-ai-to-improve-operations

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/14/stop-saving-tokens-silicon-valley-consensus-waste-compute-shortcut

大家好，我是Tony Bai。

你是不是也曾在写 Prompt（提示词）时斤斤计较，为了省下那几元钱的 Token 而字斟句酌？你是不是也曾疯狂收藏各种“保姆级提示词教程”，试图摸索出调教大模型的“终极秘籍”？

快停下这种低效的行为吧。在真正的硅谷科技巨头和顶级创始人眼里，你这种抠抠搜搜的省钱方式，正在浪费你这辈子最昂贵的资源——时间。

在最新一期的硅谷教父 Naval and Nivi Podcast 闭门在线圆桌会议上，Naval 邀请了三位极其硬核的“前沿造物主”：

• Guillermo Rauch（Gumo）：前端圣经 Vercel 的创始人，正在致力于将 Vercel 打造为智能体时代的“AI 算力云”。
• Blake Scholl：Boom Supersonic 创始人，正在自己的工厂里手搓超音速客机和喷气式发动机。
• Max Hodak：脑机接口独角兽 Science 创始人（前 Neuralink 总裁），正在利用硅基芯片上培育活体神经元来恢复人类视力。

在这场几乎没有水分的对话中，大佬们抛出了一个在当今开发圈极具毁灭性、却又无比清醒的论点：

“别去学那些花里胡哨的提示词技巧了。扔掉预算表，直接用最粗暴的方式把 Claude、Gemini、Codex 砸向同一个问题。垃圾代码万岁，浪费 Token 才是大模型时代的唯一捷径。”

创作者的傲慢：大模型进化得比你快，别再研究“提示词技巧”了

现在的中英文互联网上，充斥着各种教你如何写“完美提示词”的收费课程。但在真正的硅谷巨头眼里，这些技巧无异于“刻舟求剑”。

“我完全无视了那些所谓的‘提示词技巧和框架’，”脑机接口巨头 Science 的创始人 Max Hodak 坦言。

“什么‘使用 Ralph Wigum 模式’、‘引入 OpenClaw’、‘配置这个脚手架’……我全都不管。我默认一个事实：大模型自身进化的速度，远远快于人类摸索提示词技巧的速度。它研究我怎么说话，绝对比我研究它怎么理解要快得多。”

Max 揭示了一个极其粗暴但无比爽快的底层策略：暴力破解（Brute Force）。

当他遇到一个复杂的系统工程问题时，他不会花三个小时去润色一条完美的 Prompt。他会选择直接写几句甚至带着语法错误的、大白话般的意图，然后同时塞给 Codex、Claude 和 Gemini。他不在乎 API 的账单，他只在乎谁先给出对的结果。

“词元（Token）再贵，也比人类的时间便宜。浪费词元，拯救时间，这就是全部的秘密。”

1000x 工程师的复活：软件开发已经变成了“造工厂”

在传统的研发团队中，说某个程序员是 “10x 程序员（十倍效能）”往往会引发极大的争议，因为它挑战了传统的“人人平等”观念。

但 Naval 指出，在数字和虚拟的世界里，人与人的差距从来就不是 10 倍，而是 100 倍、1000 倍甚至无限大。

“发明 JavaScript 的 Brendan Eich，写出 3D 引擎的 John Carmack，创立比特币的 Satoshi（中本聪）——这些都是 1000x 级别的神仙。”

而在 AI 编排引擎的加持下，这种“1000x 程序员”正在以一种全新的形态复活。

Vercel 创始人 Gumo 提出了一个颠覆性的论点：未来程序员的工作，不再是“交付具体的代码代码”，而是“建造生产代码的工厂”。

[传统工程师] ───> 编写 ───> [具体的业务代码 B] (低效，线性)

[1000x 工程师] ───> 建造 ───> [AI 软件工厂] ───> 自动化裂变 ───> [代码 B 到 Z] (指数级)

以前，衡量一个工程师的价值是：他写代码的速度有多快，交出的 Bug 有多低。

现在，衡量一个工程师的价值是：他能否构建起一个自动化、自省的 AI 开发流水线（The Software Factory），让这个工厂去自动产生从 B 到 Z 的无数代码。

在软件工厂（Software Factory）范式下，未来的开发不是写代码，而是设计生产代码的机器。平庸的、只会机械搬砖的程序员会迅速贬值；而那些具备高阶系统设计能力、超强架构直觉的 1000x 工程师，其生产力将被放大到令人颤抖的维度。

Vibe Coding（氛围编程）的本质：你其实一直都是个“氛围架构师”

近两年，硅谷流行起了一个新词——Vibe Coding（氛围编程）。很多人觉得这只是一个娱乐化的自媒体词汇，但 Naval 却一针见血地指出了它的物理本质：

“其实，一个优秀的研发总监或 CTO，在过去几十年的职业生涯里，一直都在进行‘Vibe Coding’。”

想想看，一个资深架构师或 CTO 每天在干嘛？他们并不亲自去写底层的每一行API/数据库调用。他们通过 飞书、Jira、设计文档，向团队传输他们的意志、设计哲学、业务直觉和品味（Taste & Judgment）。

他们给出边界和期望，然后让团队里的初级程序员们去补充细节、去踩坑、去实现。

“现在，人类只是把传递意志的对象，从‘初级程序员’换成了‘AI 智能体’。”

你把大方向和架构考量（比如：不要用 MongoDB，这里我们需要高强度的事务一致性，给我上 PostgreSQL）输入给 Agent，然后让它去疯狂搬砖。这正是最纯粹、最硬核的“氛围编程”。

AI 让所有具备“系统大局观”的人类，在瞬间拥有了数十个不知疲倦、随时待命的虚拟技术团队。

软件已死，积木永生？AI 时代真正的“护城河”在哪里？

如果代码生成已经变得如此廉价，那未来软件公司的“护城河（Moat）”到底在哪里？如果 AI 能够一键生成任何软件，那我们还需要构建底层的软件工程吗？

Gumo 和 Naval 探讨了 Mitchell Hashimoto 提出的 “积木经济（Building Block Economy）” 概念。

“我们绝对不能指望 AI 每次面临一个新任务时，都从第一性原理出发去重新发明一遍轮子。”

如果你的 AI Agent 需要发送一封邮件，它不应该去自己从底层协议重构一个邮件收发系统；它应该去调用已经存在的、在人类社会中经过千万次锤炼的安全积木——比如成熟的 Queue 系统、PostgreSQL 数据库。

大模型最核心的资产不是去搞无意义的“重复创造”，而是重用人类文明已经沉淀好的、高鲁棒性的“技术积木”。

因此，在 AI 时代，真正的壁垒将分化为两个极端：

1. 物理底座与前沿硬核（The Hard Tech）：比如 Max Hodak 正在做的脑机接口、Blake Scholl 正在造的超音速飞机。这些需要肉身与物理实体发生碰撞的领域，是 AI 无法轻松虚拟化的。
2. 极致、干净的高性能底层积木（High-quality Building Blocks）：那些被千万个 AI Agent 每天高频调用、绝对可靠、超高性能的底层中间件与运行时（比如 Redis、Vercel Serverless、甚至是 Go 的底层运行时）。

小结：一场纯粹创造力的解放

在这场硬核的围炉对话中，大佬们用最前沿的视角，为我们描绘了一个充满希望的未来。

Max 提到，他自己已经有 20 年不写代码了。但由于 AI 工具的爆发，他重新找回了年少时在电脑前废寝忘食、疯狂创造的快乐。在过去几个月里，他完全通过 Agent，为自己构建了数个每天都在高频使用的完整软件系统：

“在过去，你写代码时总会卡在某个愚蠢的依赖配置或编译报错里，一卡就是好几天，极其挫伤积极性。而现在，有了 Agent，你永远不会再卡住了（You just don’t get stuck anymore）。”

这是一场属于人类创造力的伟大解放。

当我们不再需要把生命浪费在无休止的“底层配置对齐”和“样板代码套娃”中，当我们学会大把大把地“浪费”廉价的 Token 去换取珍贵的时间，我们才真正夺回了作为“建造者（Builders）”的尊严。

我们不再是手持泥铲、在工地上砌砖的泥瓦匠；我们是坐在直升机上、挥洒着无尽算力、俯瞰整个数字新城拔地而起的巨擘。

资料链接：https://www.youtube.com/watch?v=aiyf-5jmYf0

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/13/linux-maintainer-greg-kh-switched-to-rust-after-35-years-of-c

大家好，我是Tony Bai。

在开源软件的宏大版图中，Linux 内核无疑是那座最古老、最庞大、也最不容有失的钢铁巨塔。它由数千万行 C 语言代码铸就，运行在世界上每一个数据中心、每一台智能手机，乃至公司的投影仪和麦克风里。

在这个由 C 语言统治了三十多年的“神圣领域”，任何关于引入新语言的提议，都曾被视为不可理喻的异端。

然而，巨变正在悄然发生。

在最新一期的 Rust in Production 播客中，两位行业殿堂级人物坐在一起，进行了一场载入 Linux 史册的对话，揭示了 Linux 内核史上最伟大的语言融合：

• Greg Kroah-Hartman：Linux 内核核心维护者，掌管着驱动核心（Driver Core）、USB、TTY 以及所有稳定版本（Stable Kernels）的发布，写了 35 年 C 语言的绝对骨灰级老炮。
• Alice Ryhl：Google Android Rust 团队成员，高并发异步运行时 Tokio 的维护者，将 Rust 引入 Linux 内核的主力军。

在这场深度对话中，Greg 坦言自己曾是一个坚定的“Rust 怀疑论者”，但现在，他不仅公开宣布 “Linux 引入 Rust 的实验已经结束，它已经是正式项目”，更说出了一句让无数技术人动容的话：

“Rust 让我觉得，写程序重新变得有趣了。”

为什么一个掌控着世界底层算力命脉的 C 语言守护神，会被 Rust 彻底征服？在 Linux 这个极致复杂的系统级工程里，Rust 究竟带来了怎样的化学反应？

信任的重构：代码可以出错，但我们必须信任你

在 Linux 内核这样不容许任何安全妥协的底层项目中，引入一门新语言，最大的挑战是什么？

Alice 和 Greg 给出了同一个反直觉的答案：最大的挑战不是技术，而是社会学（Social Challenge）。

“内核的运转，本质上是基于对‘人’的信任。”Greg 解释道。

在 Linux 社区，每天都有几千名开发者提交补丁。资深维护者们并不指望任何人写出完美无缺的代码，因为“我们都会犯错”。

“我们信任你，不是信任你的代码不会出错；而是信任当代码出错、系统崩溃时，你会守在电脑前把它修好。”

在过去的二十年里，有很多系统编程语言（比如 C++）曾试图叩开 Linux 内核的大门，但它们的倡导者写完代码就走了，没有人愿意留下来承担那份沉重、枯燥的长期维护责任。

而 Rust 社区的先驱们用了整整 8 年时间，在内核树外（Out of tree）默默编写驱动、完善基础设施，用实际行动向 Greg 这样的内核守门人证明：“我们不仅能写出安全的代码，而且我们做好了准备，会留在这里和你们一起修 Bug。”

正是这种长期主义的务实精神，建立起了难能可贵的信任（Trust）。

奇妙的化学反应：Rust 的到来，竟然让原有的 C 代码变好了！

当 Rust 真正开始深入内核的毛细血管时，发生了一个极其奇妙、甚至带有一丝讽刺意味的现象：即使你完全不碰 Rust 代码，原本的 C 语言代码也因为 Rust 的到来而变得更好了。

Alice 分享了她们在编写绑定（Bindings）时的技术细节。在 C 语言中，一个指针的定义往往是极其模糊的：

// C 语言中的经典指针返回
struct device *get_device_info(void);

这个指针返回后，调用者需要面对一系列拷问：

• 这个指针代表的是“所有权（Ownership）”的转移，还是仅仅是一次“借用（Borrow）”？
• 它指向的内存在生命周期结束时，是由我来释放，还是由系统释放？
• 它是可变的（Mutable）还是只读的？

在 C 语言的签名里，这些信息全部是缺失的，只能靠开发者查阅文档、或者在脑海里默默推理。

但当 Alice 试图为这段 C 代码编写 Rust 包装器（Wrapper）时，由于 Rust 编译器的强制要求，她们必须在 Rust 签名中明确定义：它是 Arc，是 Box，还是一个简单的引用（Reference）？

为了让 Rust 编译器满意，Rust 团队不得不去倒逼 C 语言维护者厘清这些指针的语义。

“在很多地方，写 Rust 绑定的开发者需要写几百行复杂的代码，就为了兼容某个极其难用的 C 语言接口。”Greg 笑着回忆道，“我看到后说：‘其实我们可以直接修改 C 语言代码，让它变得更简单。’ 那些写 Rust 的人惊呼：‘噢，原来还可以这样！’”

“即便 Rust 在今天突然消失，Linux 的 C 语言代码库也因为 Rust 曾经来过，而变得比以前安全、清晰、健壮得多。” 这是 Greg 给出的极高评价。这种跨语言的协同审视，正在洗礼整个 Linux 内核的工程素养。

纠正偏见：为什么写“驱动”比写“内核核心”难得多？

在很多开发者的刻板印象中，写底层的内核核心（如调度器、内存分配器）是最难的，而写外围的“驱动（Drivers）”是最简单的。

Greg 站出来彻底纠正了这个偏见：“在内核中，写驱动才是最难的。因为驱动虽然看起来是树叶，但它在疯狂地消费整棵树干的养分。”

Alice 在为 Android 编写 Rust 驱动时，深刻体会到了这一点。一个驱动为了运转，必须去调用内存分配（Alloc）、调用 I/O 模块、调用网络包分析、调用文件系统。这意味着，你要写一个 Rust 驱动，你就必须先把这所有涉及到的 C 语言核心模块，全部写出对应的 Rust 绑定。

1. 为什么不能用标准的 Rust 内存分配器？

很多人问，为什么不能直接用 Rust 标准库里的 alloc？

因为 Linux 内核的内存分配（malloc）绝非易事。它不是简单的“要一块内存”，而是充满了极其细微的上下文提示（Gfp flags）：

• “在中断上下文中，不能睡眠，请立刻给我内存”；
• “不要去触发 I/O 写入，直接从那个特定的 NUMA 节点上拿内存”；
• “从这个特定的内存池（Memory Bucket）里分一块给我”。

为了满足这些变态的底层硬件级要求，Rust 用户态标准库那一套内存分配器根本无法工作。Rust for Linux 团队不得不完全剥离了 std，甚至重写了适用于内核特性的定制版 alloc 库。

2. 极致的极客工具：Klint 与编译期“禁眠”检查

为了解决这些极其精细的内核场景，内核团队甚至编写了专属的编译器插件——Klint（Kernel Lint）。

在内核开发中，有一个铁律：在持有某些特定锁或处于中断上下文时，绝对不允许发生系统休眠（Sleep）。如果 C 程序员犯了这个错，系统往往会直接卡死、甚至死机，极难调试。

而 Klint 作为一个 Rust 编译器插件，能够利用编译期的类型系统，在编译时直接扫描整个代码路径，一旦发现你在不允许睡眠的上下文中调用了任何可能触发睡眠（Sleep）的函数，直接报编译错误！

这种在编译期就把低级内存与调度错误彻底掐灭的能力，是传统的 C 语言静态分析工具（如 Coccinelle）在不破坏代码可读性的前提下，永远无法企及的高度。

释怀：35 年 C 老炮被 Rust 治愈的瞬间

当主持人问及，C 程序员能从 Rust 身上学到什么时，Greg 的回答没有滔滔不绝的说教，反而充满了真诚与坦然。

“过去，当我写 C 语言时，如果要在两个模块间传递一个指针，我必须在脑海里进行高强度的思想斗争：这个指针是谁在持有？生命周期对不对？我有没有在别处释放它？”

“当我接触到 Rust 之后，我发现，Rust 帮我把这些繁琐、痛苦、容易出错的 meta-stuff（元认知开销）全部承担了。”

“编译器编译通过了，逻辑看起来也是对的。好了，我现在可以百分之百地把精力放在我的业务逻辑本身，而不需要去担心那些低级的内存越界和空指针问题。”

“写了 35 年的 C，Rust 让我重新觉得，编程是一件纯粹且快乐的事情。”

这或许是一个程序员，对一门新编程语言所能表达的最高敬意。

小结

在对话的最后，现场响起了经久不息的掌声。

Linux 的伟大，不在于它用了 30 多年的 C 语言，而在于它拥有一个极其开放、务实且充满活力的工程文化。当有更好的工具出现时，这些掌控着世界算力命脉的守护者们，没有抱残守缺，而是选择张开双臂，去拥抱改变。

从 Python 狂飙的 AI Agent 调度层，到 Go 统治的云原生 Agent编排底座，再到 Rust 正在接管的 Linux 内核最深处——无论上层的应用和模型如何演进，底层的系统工程（Systems Engineering）依然需要人类最顶尖的逻辑、同理心与工匠精神去雕琢。

我们有幸见证这场跨越语言与时代的融合，更有幸与这些伟大的建设者们同行。

资料链接：

• https://corrode.dev/podcast/s06e04-rust4linux/
• https://www.youtube.com/watch?v=HM-JM4DoYD4

今日开放讨论：

Greg 提到“Rust 绑定的过程，反过来倒逼并简化了 C 语言的原生接口”。在你的项目或日常重构中，是否也曾因为引入了更严苛的约束（如类型系统或静态检查），反而帮助你理清了原本混乱的业务逻辑？

欢迎在评论区分享你的跨语言协作与架构重构故事，我们一起聊聊代码的纯粹之美！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/06/12/zig-father-refuses-funding-bans-ai-why-no-1-0-in-a-decade

大家好，我是Tony Bai。

在技术圈，有一门名为 Zig 的系统级编程语言，它没有铺天盖地的营销，没有背后财大气粗的金主干爹，甚至它的代码仓库在 2025 年末从 GitHub 直接“硬核跑路”到了 Codeberg。

然而，在 JetBrains 发布的“最受敬仰编程语言”榜单中，它赫然位列 Top 5；Uber 用它的编译器解决 Go 的交叉编译难题；大热的 JavaScript 运行时 Bun 用它作为底层的胶水语言（注：近期Bun已经从Zig迁移为Rust实现）；金融级数据库 TigerBeetle 更是基于它实现了比传统方案快上千倍的性能。

为什么在拥有了 C++、Rust 和 Go 之后，世界依然需要 Zig？

最近，JetBrains 团队对 Zig 之父 Andrew Kelley 进行了一次深度专访。在长达一个多小时的访谈中，Andrew 展现出了极度“反主流”的极客态度：坚决抵制 AI 生成的代码（No-AI Policy）、宁可拿 67 万美元的非营利基金也不要上亿美元的投资、10 年不发布 1.0 版本。

今天，我们就来深度扒一扒，这位被称为“最硬核系统语言创造者”背后的狂人哲学。

缘起：“我能比 C++ 做得更好，我也能比 Rust 做得更好”

故事要从一个开发“数字音频工作站（DAW）”的失败尝试说起。

在 2015 年之前，Andrew 试图用各种现有的语言去开发一个专业的 DAW 软件。

• JavaScript？ “太高层了，根本接触不到计算机底层能力来做低延迟处理。”
• Go？ “和 C 库的交互极其痛苦（CGo），而且垃圾回收（GC）在实时音频处理中是致命的。哪怕卡顿一毫秒，在现场演出中都是灾难。”
• Rust（1.0 之前）？ “我为了让字体渲染工作花了一个月，被 Borrow Checker（借用检查器）折磨得生不如死。稍微改动一点代码，就会引发一连串的编译错误，让我彻底卡壳。”
• C++？ “刚开始感觉很高效，但很快，一个小拼写错误就导致了内存损坏（Memory Corruption），花了我几个星期去 Debug。这太慢了！”

即使退回到只用极简 C++（搭配 C 链接器），他依然在不断地“搬起石头砸自己的脚”。

那一刻，年轻的 Andrew 迸发出了极大的傲慢与决心：“我可以做得更好！我可以比 C++ 做得更好，比 Rust 做得更好，比 Go 做得更好！”

于是，Zig 诞生了。

为什么世界还需要 Zig？它凭什么挑战 C 和 Rust？

很多人会问：C 语言统治了底层 50 年，Rust 现在红得发紫，Zig 凭什么挤上牌桌？

Andrew 给出了一个极其精准的定位：“在 Zig 中，你不需要像在 Rust 中那样为了迎合编译器的‘类型理论’而去扭曲你的代码结构；在 Zig 中，你思考的是‘我希望 CPU 做什么’，然后你写出让它这么做的代码。”

1. 为什么它是更好的 C？

“想要替代 C，你不能放弃任何 C 拥有的能力。”Andrew 说道。

Go 放弃了底层的绝对控制权换取了并发的便利，所以 Go 永远无法替代 C 写操作系统内核。

但 Zig 做到了。在 Zig 中，一切都可以像 C 一样高效，但消除了 C 语言海量的“坑（Footguns）”。甚至在细节上，Zig 比 C 更像 C：C 语言只有溢出（Wraparound）的无符号整数，而 Zig 允许你精细控制整数的溢出行为和符号约束。

2. 为什么它不同于 Rust？

Rust 的核心是其宏大的类型系统和基于生命周期/借用的内存管理模型（类似 RAII）。

而 Zig 走的是“显式分配器（Explicit Allocators）”的路线。

在 Zig 中，没有隐式的内存分配，开发者经常针对特定应用使用 Arena Allocator（一次性分配，一次性销毁），以获得极低的延迟和极高的吞吐量。TigerBeetle 数据库就是利用这一点，在启动时预先分配好所有内存，此后运行时零动态分配（Zero Dynamic Allocation），从而实现了恐怖的高频交易性能。

3. 杀手锏：全宇宙最强的 Toolchain

如果你问一个开发者，在 C/C++ 项目里最痛苦的是什么？99% 的人会回答：配置构建环境（CMake、Makefile、装依赖）。

Zig 的杀手锏在于它的工具链：它没有任何外部依赖。 无论你在什么操作系统上，想要编译一个项目，永远只需要一句 zig build。不仅如此，Zig 甚至可以作为一个超级强大的 C/C++ 交叉编译器。Uber 就是用 zig cc 来解决 Go 语言中混合 C 代码在 ARM 架构上的交叉编译难题的。

“AI 代码全是垃圾”：为什么 Zig 坚决封杀 LLM 提交？

在这个“万物皆可 AI 编程（Vibe Coding）”的狂热时代，Andrew 和 Zig 社区制定了一项极其强硬的规则：严禁任何由大模型（LLM/AI）生成的 Issue 和 Pull Request。

为什么这么刚？Andrew 的回答充满了工程师的辛辣与无奈：

“因为那些贡献无一例外，全是垃圾（Invariably garbage）。”

Zig 的核心团队只有 5 个人，却要面对海量的社区贡献。开源项目接受 PR 的核心目的不仅仅是为了拿代码，更是为了“导师制（Mentorship）”——通过 Review 代码，培养出下一代的核心维护者。

但在 Andrew 看来，那些用 AI 批量生成代码然后扔过来的贡献者，不仅没有任何价值，还在疯狂消耗核心团队极其宝贵的 Review 时间。

“这就像是‘贡献者扑克（Contributor Poker）’。用 AI 的人永远只是路过，他们学不到任何东西，也永远不可能成为核心团队的一员。更可笑的是，他们往往只是把报错信息贴回 ChatGPT，然后假装自己修复了问题。这纯粹是在浪费所有人的时间。”

面对满天飞的“AI 编程神器”，Andrew 有着自己极其古典的软件信仰：

“我想要软件拥有‘绝不妥协的完美（Uncompromising perfection）’。我不想看到一个软件仅仅是因为‘出乎意料地没有 Bug’而沾沾自喜，那是一个糟糕透顶的质量标准。”

$670K 的独立基金与 $100M 的诱惑：为什么拒绝做大？

在科技圈，一个流行的开源项目很快就会被大厂收编，或者拿到顶级 VC 的上亿美元融资，然后迅速扩张。

但 Zig Software Foundation (ZSF) 走了一条截然不同的路。它是一个注册在美国的 501(c)(3) 非营利组织。2024 年，整个基金会的总收入只有区区 67 万美元（约合人民币 480 万）。

在这 67 万美元中，Andrew 为自己定下了 15.4 万美元的年薪（相当于纽约一个普通的资深程序员薪水），而剩下的资金的9成以上，全部用来支付另外几位兼职和全职的外包核心开发者。

当主持人犀利地问道：“如果一家大公司给你 1 亿美元的无条件赞助，你会要吗？”

Andrew 的回答展现出了极度的清醒：

“我会拿，但我会把它存进银行，确保我们未来 100 年都不需要再到处筹款。但我绝不会用这笔钱去扩张。我不想管理 100 个人的团队。”

他的逻辑极其自洽：保持一个极度精简、高效的微型组织，能够最大程度地抵御资本的腐蚀（Oxidation）。

“我们不是初创公司，我们没有投资人在背后催着我们变现。如果我们拿了大厂的钱，他们就会有控制权；现在，我们靠着多元化的小额赞助和少数企业的资助活着。如果哪天某个赞助商说‘你必须按我说的做’，我们可以硬气地回答：‘对不起，如果你撤资，我们依然能活下去。’”

这就是他宁可手写报税单，也要死守非营利基金的底层原因——他要为 Zig 争取“对世界说‘不’”的自由。

硬核的代价：离开 GitHub，以及那遥遥无期的 1.0

为了这份独立和自由，Andrew 付出了很多代价。

2022 年，他退出了 Reddit 和 Twitter。2025 年底，当发现 GitHub 的持续集成（CI）服务器对 Zig 极度不稳定时，他更是做出了一个惊世骇俗的决定：将 Zig 的主仓库从 GitHub 彻底搬迁到了一家德国非营利组织运营的平台 Codeberg。

这意味着他主动放弃了 GitHub 带来的巨大流量和打赏（Sponsors）收入。但他毫不在意：“我们是来写软件的。如果 CI 跑不通，我们就换一个能跑通的。Codeberg 是非营利组织，比那些为了下一个财报季奔波的创业公司靠谱多了。”

那么，被粉丝催了 10 年的 Zig 1.0 究竟什么时候出？

Andrew 坦言，1.0 本质上是一个“向后兼容的承诺”。像 Go 这种语言，1.0 之后很久没动过语法；而 Rust 虽早早发布 1.0，却靠着 Editions（版次）机制继续大改特改。

“我们不需要为了迎合风投的胃口，或者为了所谓的‘商业落地指标’去急匆匆地发布 1.0。当 Zig 1.0 发布的那一天，它必须是一份‘毫不妥协的热爱之作’。我们不需要为任何仓促的糟糕决定买单。”

不过，Andrew 也在采访中透露了一个彩蛋：他将全力冲刺即将到来的 0.16 版本 (注：截至发稿时，Zig官网已经发布了0.16.0版本)。在这个版本中，完全摆脱对 LLVM 依赖的自研 x86 后端将迎来爆发——百万级代码库的增量编译将低至恐怖的 50 毫秒！

小结：程序员的乌托邦

在访谈的最后，当被问及“未来 20 年人类还会写代码吗”，Andrew 的眼中闪烁着光芒：

“人们永远不会停止写代码，因为写代码真的太好玩了。”

在他看来，当今世界最好的软件，往往是开发者们在业余时间出于热爱而写的。而那些为了商业目的强加给用户的软件，总是充满了广告、诱导和恶意的参与度指标。

Zig 不仅仅是一门编程语言，它是 Andrew Kelley 献给世界的一份“无条件的礼物”。它在向所有热爱底层、渴望掌控计算机的极客们宣告：

在这个被大厂垄断、被 AI 噪音填满的世界里，我们依然可以凭借几百 K 的预算、五六个人的小团队，用对技术的极致纯粹，造出一把劈开混沌的利剑。

如果你也曾在这个庞大的系统工程世界里感到过疲惫与迷茫，不妨去试一试 Zig 吧。那是一片没有资本催促、没有 AI 噪音的，属于纯粹程序员的乌托邦。

资料链接：https://www.youtube.com/watch?v=iqddnwKF8HQ

✍️ 今日开放讨论

在这个几乎所有人都疯狂拥抱 AI 编程（Claude Code/ Codex /Antigravity Cli等）的时代，Zig 官方明确拒绝 AI 生成的 PR。你认为是 Andrew Kelley 过于“迂腐”，还是他在守护开源软件最核心的“导师制与高质量传承”？

欢迎在评论区留言，分享你对“AI 垃圾代码”以及系统编程语言发展趋势的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.