本文永久链接 – https://tonybai.com/2026/06/06/geohot-slams-ai-agents-as-the-most-expensive-software-disaster

大家好，我是Tony Bai。

在 AI 辅助编程疯狂席卷全球的今天，几乎每个开发者的双眼都被“效率翻倍”、“一键生成应用”的狂热口号晃得睁不开眼。大厂管理层在积极推进“全员 AI 编码”，创业者在吹嘘“氛围编码（Vibe Coding）”。

然而，就在这个全民狂欢的时刻，科技界最著名的叛逆天才、传奇黑客 George Hotz（网名 Geohot） 站了出来。他曾在 17 岁时成为全球首位解锁 iPhone 的人，随后又单枪匹马破解了 PS3，并创办了自动驾驶独角兽 Comma.ai。

最近，Geohot 在他的个人博客上发表了一篇名为《The Eternal Sloptember（永恒的垃圾九月）》的文章。在这篇文章里，他用极其冰冷且辛辣的笔触写道：

“我在这里立个 flag：在软件开发中引入 AI Agent，将是行业历史上代价最昂贵的错误之一。因为 Agent 根本不会写程序，而人们需要花越来越长的时间才能意识到这一点。”

这篇文章迅速引爆了开发者社区。在 Reddit 的 r/webdev 板块上，该话题斩获了数千个高赞，引发了无数一线架构师和开发者的强烈共鸣。

为什么这位顶级黑客会把 AI Agent 视为软件工程的毒瘤？他口中的“永恒垃圾九月”究竟隐藏着怎样可怕的行业真相？

典故溯源：什么是“永恒的垃圾九月”？

要理解 Geohot 的愤怒，我们首先需要理解他借用的一个历史梗——“永恒九月（Eternal September）”。

在互联网早期的 Usenet 时代，每年九月，都会有大批大学新生接入网络。这群新手由于不懂网络礼仪（Netiquette），会短暂地破坏原有技术社区的纯粹与优雅。但过去，老用户们只需花费一个月时间，就能将这些新生“同化”。

直到 1993 年 9 月，美国在线（AOL）向其数百万普通用户全面开放了 Usenet。新手的涌入再也没有停止过，原有社区的精致文化被彻底、永久地稀释了。从那以后，老网民将这个悲剧称为“永恒九月”。

Geohot 认为，现在的软件工程正在经历一场由 AI Agent 带来的“永恒垃圾九月（The Eternal Sloptember）”：

大模型（LLM）本质上是“高度复杂的统计模型，旨在模仿人类编程的分布”。它们吐出来的代码，在语法和格式上看起来天衣无缝，但在底层逻辑和系统架构上，往往是坏的、错的。最致命的是，这种“错”被包装得越来越隐蔽，越来越难以被察觉。

无数根本不具备底层系统思维的“调参手”，正在用 AI 疯狂向世界的开源社区和企业代码库里倾倒垃圾代码（Slop）。

“老虎机”效应：Geohot 历时半年的亲身实验

和那些只会纸上谈兵的评论家不同，Geohot 亲自用 AI 进行了长达 6 个月的深度开发实验。

他尝试用 AI Agent 编写他的深度学习框架 tinygrad 的部分代码，甚至尝试用 AI 逆向工程一块 USB 到 PCIe 的芯片。

他的实验结论可以用两个词来概括：极其失望。

“AI 确实非常擅长快速搭建一个原型（Prototype），”Geohot 承认。但当你试图去打磨它、消灭最后 5% 的边缘 Bug、让其达到工业级标准时，AI 就会变成一台“老虎机（Slot Machine）”：

[输入 Prompt] ───> 摇下老虎机摇杆 ───> [输出 buggy 代码 A]
                                             │ (发现错误，重新 Prompt)
                                             ▼
[输入修正 Prompt] ───> 再次摇下摇杆 ───> [输出稍微不同的 buggy 代码 B]

你一次次地拉下摇杆（修改 Prompt），AI 一次次给你吐出看似不同、实则依然带有微妙缺陷的代码。你感觉自己只差临门一脚，但你永远无法真正跨过那条代表“完美交付”的终点线。

“这种试错和盲目摸索（类似Ralph loop），比我自己从第一性原理出发去手写，要慢得多。”Geohot 坦言，“这完全达不到我工作过的任何一家公司的基本技术门槛。”

相比之下，他发现一个古老的自动漏洞挖掘工具 AFL（American Fuzzy Lop，模糊测试工具） 找出的代码漏洞都比大模型多。因为 AFL 是纯粹确定性的，它没有人类社交焦虑，更没有被 AI 公司的“心理战（Psyops）”所污染。

大厂病灶：为什么非技术管理层会成为“垃圾代码”的帮凶？

既然 AI Agent 开发如此低效，为什么现在各大巨头依然在疯狂推进？

Geohot 揭示了企业管理层一个极其荒谬的逻辑漏洞：对“虚假指标”的崇拜。

在大型企业中，管理层通常是非技术出身的。他们无法辨别代码的高级设计与品味，他们只能看懂看得见的指标——比如“开发进度图表”和“代码产出行数（Lines of Code, LOC）”。

“那些底层的、平庸的开发者（Bottom Performers），通过使用 AI，突然产出了 10 倍的代码量。”

管理层看到图表后大喜过望：“看啊！我们的团队多有效率！这个星期我们提交了 100 个 PR！”

但他们不知道，这多出来的 10 倍代码，全部都是无法维护的“工业垃圾（Slop）”。

这造成了极度扭曲的恶性循环：

1. 底层开发者用 AI 疯狂复制粘贴，提交海量垃圾 PR。
2. 由于大企业的反馈循环极慢、极官僚，这些黑盒垃圾代码顺利混入主干分支。
3. 认知负担转嫁：高水平的资深工程师（Top Performers）不得不花费双倍、甚至十倍的精力和认知负载（Cognitive Load），去帮这些 AI 审查代码擦屁股、Debug。

这就是为什么 Geohot 说：“AI Agent 对大企业的伤害，远比对个人或小团队的伤害要深得多。”

终局梦醒：当黑盒代码的“账单”到期

Reddit r/webdev 板块上的大批大厂老兵，用自己身边的真实惨剧，印证了 Geohot 的预言。

一位在 Fortune 100 强企业工作的开发者留言道：

他们的管理层在大会上狂热地宣称“AI 将接管一切开发，以后周五下午直接让 AI 部署 1 万行代码上线”。

“我们这些一线的工程师在下面默默看着。等这波 AI 狂热退去，账单到期，面对一堆无人能懂的‘黑盒代码（Black Boxes）’在半夜 3 点崩溃时，这些管理层会迎来极其残酷的梦醒时刻。”

目前的微服务和企业级软件，本就已经因为复杂的业务需求和拼凑的库而变得极其脆弱。一旦你引入 AI，让它用“在 StackOverflow 上抄来的、似是而非的代码”去填补这些系统的空隙，你实际上是在制造一个“无法被任何人理解、也无法被任何人重构”的终极怪胎。

“没有经验的 junior 开发者加上 AI，就是一场灾难的配方。” 另一位老兵写道。

幸存者法则：别在“AI 妄想症”中自残

面对这场由大厂和 AI 巨头联手制造的“AI 妄想症（AI Psychosis）”，真正的工程师该如何自救？

Geohot 在文章的结尾，给出了一个极具力量、甚至带有一丝英雄主义的生存守则：

“这个时代真正的故事，将是谁能在这场‘AI 妄想症’中保持清醒，不伤害到自己。”

1. 回归第一性原理（First-Principles）：放弃用 AI 盲目试错。当你遇到技术难题时，去读书，去查阅最干净、最硬核的一手的底层文档，搞清楚 CPU、内存和操作系统的底层运行机制。
2. 把 AI 降级为助手，而不是总监：Geohot 并不排斥 AI，但他对 AI 的定位极其清晰——它是一个更聪明的谷歌搜索，是一个帮你写样板代码、帮你写测试基准（Benchmarks）的高效秘书。但系统的架构设计、核心逻辑和最终决策，必须牢牢握在你自己的手里。
3. 拒绝成为平庸的羊群：当周围的人都在用 AI 批量生产垃圾代码并为此沾沾自喜时，保持克制，坚持对完美、优雅和高性能的代码品味的追求。

技术世界正在迎来一场由大量平庸代码构成的泥石流。但泥石流终会退去，那些在风暴中死守底层常识、拒绝交出思考方向盘的真正工程师，将在废墟之上，重建这个世界的数字基石。

资料链接：

• https://www.reddit.com/r/webdev/comments/1tvsfgj/im_calling_it_now_the_adoption_of_ai_agents_into/
• https://geohot.github.io/blog/jekyll/update/2026/05/24/the-eternal-sloptember.html

今日开放讨论：

你同意 Geohot 关于“AI 降低了代码质量，最终会拖垮大企业系统”的悲观论调吗？在你的团队里，是否也出现了“LOC（代码行数）增加，但系统却变得越来越像黑盒”的苗头？

欢迎在评论区分享你的一线工程经历，我们一起在这个狂热的时代保持冷峻的思考！

还在为“复制粘贴喂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/04/the-maintainers-dilemma

大家好，我是Tony Bai。

开源软件的繁荣建立在一种隐形的“社会契约”之上：贡献者贡献智慧，维护者投入精力审核。然而，当维护者面对成百上千个待处理的拉取请求（PR）而精疲力竭时，这个契约正滑向崩塌。

AI 的介入似乎提供了一线生机，但也带来了一个灵魂拷问：如果代码是 AI 写的，审核也是 AI 做的，那么“受保护的分支”究竟是在保护什么？开源社区赖以生存的“人与人的连接”是否会随之消失？前Go 语言核心团队成员、gohugo和Cobra 创始人 Steve Francia 近期撰写了一篇文章，深度剖析了这一“维护者的困境”。

本文便是这篇文章的中译文。

受保护的分支（protected branch）需要第二个人在代码发布前进行审核。这条规则的存在是因为人类会犯错，而第二双眼睛可以捕捉到第一双眼睛遗漏的东西。但如果其中一个审核者是机器人呢？如果两个都是呢？

目前，我可以要求 AI 在我的仓库里发起一个拉取请求（PR），然后由我自己合并它。或者我可以自己写代码，让 AI 来审核。在这两种情况下，分支在技术上都是“受保护的”。但这种保护现在究竟意味着什么？

这些问题值得思考。但它们往往占据了太多的注意力，而一个更迫切的问题却无人问津：现在，在我的各个仓库中，都有来自那些花时间理解代码库、编写测试并提交简洁补丁的人们的未处理拉取请求。我还没审核它们。遗憾的是，讽刺的是，我没审核是因为我深深地在乎。我知道花时间在一个项目上发起 PR 是多么大的事，对于那些我作为志愿者维护的项目更是如此。对于每一个拥有受资助维护者的开源项目，都有数以百万计的未付报酬的人类正盯着日益增长的待办事项，思考着这个周末是该花在处理问题上，还是直接合上电脑出门去。

AI 工具现在可以进行可靠的代码审查、编写补丁和分拣问题。问题不再是它们是否足够好到有用。真正的问题在于，“有用”在何处变成了“负担”，以及过度依赖我们无法轻易重建的东西——维护者与贡献者之间、通过经验积累的判断力，以及围绕这种交流形成的社区——是否会造成破坏。

118 个待处理的拉取请求

我上周查看了 GitHub 通知，然后直接关闭了标签页。Cobra 有 243 个未解决的问题（issues）和 118 个待处理的拉取请求（PR）。Afero 有 114 个问题和 55 个 PR。这两个项目都是我创建的。

尽管我没有及时行动，但这些都是活跃维护的项目。Cobra 支持着 kubectl、GitHub CLI、hugo 以及成千上万的其他工具。当你输入 kubectl get pods 或 gh pr list 时，Cobra 正在解析你的命令。Afero 存在于 Hugo 内部，也存在于 Cobra 自身，以及数以百计的其他项目中。对 Cobra 的一次草率合并可能会破坏 Kubernetes 的工具链。对 Afero 的一次错误审核可能会开启一个静默传播到下游所有环节的文件系统漏洞。

我创建 Cobra 是因为我需要为 Hugo 提供特定的 CLI 用户体验，而当时没有现成的库可以支持。我将它拆分为一个独立项目，想着其他人可能会觉得有用。我从未想过十年后我还在维护它，也没想到这两个项目会成为这么多人的关键基础设施。我只是想做些有用的东西，也许能交几个朋友。但开源意味着我有义务无限期地维护它吗？随着我发布的每个新项目，维护旧项目的时间就越来越少。有些 PR 已经等了三年了。在 Afero 的 BasePathFs 中有一个已报告的安全漏洞，自从 2025 年 6 月起就挂在那里——直到写这篇文章之前，我都还没意识到它在那里，因为积压工作太惊人了。

维护的数学逻辑行不通。这是一个众所周知的开源问题（相关 XKCD 漫画）。贡献的数量增长速度远超维护者的数量，且随着项目的复杂性和影响力的增加，审查每个 PR 所需的时间也在增长。有些项目能吸引志愿者维护者，但这又带来了新问题：没有人对全局负责，每个人都只挑选对自己重要的事情，剩下的就随它去。Cobra 故意设计得节奏缓慢——有太多的项目依赖它，不能草率合并任何内容——因此每次更改都需要更彻底的审查，而不是更少。我的许多其他项目则掉进了既被维护又被遗弃的灰色地带。我会将其描述为针对最关键路径优化的维护，但这种区别对八个月前提交了修复方案且从未得到回音的人来说，意义并不大。

这不仅仅是我的问题。GitHub 托管着超过 4.2 亿个仓库。我有幸成为 Secure Open Source Fund 首批资助对象的一员——这是一项真正产生了影响的投资。但即使在经过几个周期的扩展后，它也只覆盖了约 200 个项目。OpenSSF 每周扫描数百万个关键项目。Tidelift 向维护者支付报酬。把这些加起来，你也只覆盖了成千上万个项目。这虽然很有意义，但与实际的表面积相比只是杯水车薪。

百分之九十六的代码库包含开源组件，而它们赖以生存的基础是由盯着永远清不空的待办事项的人类维持的，他们思考着是否这就是他们最终耗尽精力或干脆停止查看的周末。随之而来的还有维护者的愧疚感——明知道人们指望着你的工作，而你却没有能力帮忙，但又无法撒手不管。

进入机器人时代

我一直在几个仓库里尝试 AI 工具——比如在 fileflow 上的 Jules 和在 pathologize 上的 AI 尝试，这些仓库依赖较少，有更多尝试空间。我也一直在 Afero 上运行 GitHub Copilot，它有更多依赖，但其模块化架构允许我扩展新后端而不触及其他项目依赖的关键路径。

我去了一次邮轮旅行。当我在海上时，Jules 还在继续工作，每天都会发起新的 PR，因为我还没来得及合并第一个。等我回到家时，这两个项目已经有了超过 120 个 PR。我抽出一个早晨来审核它们，却发现它们其实代表了大约五个不同的更改集，每个更改集都在几周内每天提交一次。PR 本身并没有错，Jules 确实发现了真实的问题。但没有一个 PR 是完全正确的；在合并之前，每个都需要修正。在 Jules 提供的指导下，我做了调整，总体方向显示出前景。但实验目前带来的维护工作量是增加了，而不是减少了：我必须核实这 120 个 PR 中每一个是否真的是重复的，然后才能关闭。本意是减少积压工作的工具，反而增加了积压。

Jules 发起的这些 PR 署名是我，而不是 Jules——这引发了关于归属和责任的问题。从仓库的角度看，我是这些更改的作者。但我一行代码都没写。如果其中一个补丁引入了 Bug 或漏洞，提交历史记录指向的是我。大多数贡献者政策在编写时并未考虑到这种情况，标准的 CLA（贡献者许可协议）也不区分人类编写的代码和人类指导 AI 编写的代码。

目前看来，Jules 似乎没有关于其之前工作的记忆，也没有检查未处理 PR 的能力。它扫描仓库，发现问题，发起 PR，然后停止。如果你不合并，Jules 下次扫描时会发现同样的问题并再次发起 PR。它没法知道你已经意识到了问题但还没合并，原因可能是：你不同意这个修复，或者修复优先级较低，或者你正在船上度假且两周内没法上网。这种语境对工具来说是不可见的。Jules 发现了一个真实的漏洞——文件操作中的 TOCTOU（检查时间到使用时间）漏洞——它是对的，它指出了这一点……指出了 12 次。

对于机械性的工作——标记问题、更新依赖、起草样板回复——这些工具确实非常有用。但 Jules 和 Copilot 无法告诉我，这 55 个 Afero 的 PR 中，是否有一个根本不属于这个项目。这种判断需要了解代码库的过去和未来，而不仅仅是它的现状。

这些工具只能基于可见的事物工作：代码、未解决的问题、PR 历史。维护者的约束条件是那些没人写下来的东西：内部辩论如何塑造了 API。人类判断力最无可替代、AI 最盲目的鸿沟，就在这两者之间。

曾和我一起在 Go 团队工作的 Russ Cox 在最近的一次关于 AI 贡献的讨论中说得很好：“人们吹嘘代码库有成百上千行，是由 AI 在创纪录的时间内完成并提交的。仔细观察会发现，这些代码库往往更像是跳舞的大象，而不是有用的工程产物。”

他是对的。但我一直在思考代码之外的事情。编写新软件和维护现有软件是有区别的。更新依赖并不是跳舞的大象。分拣一个陈旧的问题并不是创造性行为。告诉一个贡献者“谢谢，但我们不接受对这个 API 的更改”只是在维持运营。而现在，对于数百万个项目来说，灯已经熄灭了。

这还不是最大的挑战。大多数人没意识到的是，评估和合并更改比编写新代码要难得多。理解一个更改如何融入现有的代码库、它的历史以及它的计划，需要一部分隐形的知识——这些知识存在于创意工作中，需要某种目前没有模型能复制的判断力。

“受保护”到底保护了什么

Go 项目对我来说真的很美——那是运行了 15 年、极其细致的评审、设计讨论和精炼的评审文化。那是理想状态。但 Go 是个例外，大多数项目无法企及：由 Google 资助的全职贡献者，一项旨在持续 50 年且不受外部截止日期压力的任务。

Go 团队最近有一个长长的讨论，关于是否接受 AI 生成的贡献——Russ Cox 的名言也源自那个讨论。这些人我共事多年——同样的评审、同样的方案、在同样的白板前争论。阅读那个论坛线程，我能听到他们的声音。我能看到他们每个人是如何坚持自己认为正确的事情，以及为什么。

Rob Pike 第一个发言且毫不含糊。这是一条非常危险的道路。在你的第一步上要小心。我建议简单地说“不”。那是 Rob。直接、原则性强，且通常是正确的。然后 Alan Donovan 指出了不舒服的现实：“我怀疑我们今天收到的一大部分 CL（更改列表）已经包含了 LLM 生成的代码，无论作者是否承认。马已经跑出马厩了。”

Russ Cox 写下了我见过的最深思熟虑的回应。他的核心观点是：“我们能做的最重要的事情是维持我们平时的代码评审和代码质量标准……当代码的部分或全部是在 AI 工具的帮助下编写时，同样的标准必须适用。”以及：“当你使用 AI 工具完成工作时，你的责任并不会减轻。”

这些立场中的每一个都是合理的。每一个都基于一个假设，而这个假设揭示了困境的核心：他们假设有人类可以进行评审。

Go 能负担得起“维持同样的标准”，因为它有全职贡献者。它能负担得起“直接说不”，因为 Go 有足够多的人对重要的事情说“是”。

Afero 没有。大多数开源项目没有。当 Rob Pike 说“不”时，Go 项目保持运行。当我说“不”时，PR 就挂在那里。那是不同种类的“不”。

这里有一个光谱，你落在哪里取决于你究竟在两者之间如何权衡。在实践中，维护者面临五个选项：

1. 人类编写，人类审核。
2. AI 编写，人类审核。
3. 人类编写，AI 审核。
4. AI 编写，AI 审核，人类点击合并。
5. AI 编写，AI 审核，AI 点击合并。

列表中的每一步通常都是在用严谨性换取速度，用信任换取吞吐量。但对于大多数人类或 AI 都不评审的 PR，根本谈不上标准。

我们真正保护的是什么

当维护者评审贡献者的 PR 时，存在一个潜规则（契约）。贡献者投入数小时理解代码库、编写测试并提交干净的内容。评审者投入数小时进行评估、打回并提出改进建议。双方都在学习。评审者理解了项目的一个新角落。贡献者学会了更好地使用代码库的惯用法。这种关系形式。这种交流是使开源成为一个社区，而不仅仅是供应链的重要原因。

Bryan Cantrill 在 Oxide 描述了这种关于 LLM 使用的内部政策：通常，“读者和作者都默认，是编写者付出了更大的智力劳动。”当内容是 AI 生成时，“这个社会契约就变成了作者付出的努力最少。如果双方都没有付出努力，那么评审还有什么意义？”Oxide 的答案是，无论如何人类都要负责；工具不吸收责任。这是正确的直觉。但它假设有人真正在那里承担责任。

对于大多数项目，根本没有人在评审。社会契约不是被 AI 破坏的——它正被沉默破坏。六个月前提交了一个干净、测试完备的补丁却从未收到回音的贡献者，并没有体验到一个退化版的理想契约。他们什么也没体验到。

一个不完美的社会契约，是否好过一个从未发生的完美契约？

来自 AI 的在一天内的响应，可能比来自人类的永远的沉默更受尊重。

前方的实验

我决定弄清楚到底怎么回事。我在 Afero 上看到了 55 个尚未处理的 PR 请求，显然，这种拖延态度本身就已经构成了一种忽视行为。

AI 工具会让我更投入，让我从那些本不需要我的决策中解脱出来吗？还是会让我感觉连接更少——人类元素又减少了一层？我不知道让 AI 评审 PR 而不是人类评审是什么感觉，也不知道当双方的努力都减弱时，问责制是否还存在。这就是实验。

Russ 在那个讨论中还说了另一句话，我一直在回味：“最重要的事情是保持思考。工具让关掉大脑变得非常容易，但如果你小心避开那个陷阱，你就能产出好的成果。”这就是我要尝试走的路。让 AI 处理大量数据吧。而我自己则要继续负责做出正确的判断。

没有一个通用的政策可以同时适用于 Go 和 Afero。也不应该有。

受保护的分支依然受保护。我只是不再确定那究竟意味着什么。

你遇到过这种情况吗？我特别想听听那些尝试过使用人工智能进行代码审查的维护人员的意见——哪些方面运作正常，哪些又出现了问题。

原文地址：https://spf13.com/p/the-maintainers-dilemma/

今日互动探讨

“如果一个 AI 能够修复你项目中困扰已久的 Bug，但由于它是 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/05/30/ghostty-creator-slams-ai-coding-performance-1-5ms-vs-0-02ms

大家好，我是Tony Bai。

在开源界，Mitchell Hashimoto 这个名字几乎无人不知。作为 HashiCorp 的联合创始人，他一手打造了 Vagrant、Terraform、Vault 等神级工具。而在他离开 HashiCorp 后，他的新宠——极速终端模拟器 Ghostty，凭借极其硬核的性能和绚丽的平台原生 UI，在 GitHub 上狂揽了 55K 颗 Star，成为了 Zig 语言 当之无愧的杀手级应用。

然而，就在最近，Mitchell 在 X（推特）上发布的一条Tweet，在开发者社区炸开了锅。

这篇帖子的起因，并不是大家猜测的“Ghostty 要放弃 Zig 转投 Go 语言”，而是一场极其讽刺、甚至有些黑色幽默的 “AI Agent 代码优化实验”。在这场实验中，Mitchell 揭露了当今 AI 编码工具最致命的缺陷，并把那些盲目迷信 AI 输出的开发者骂成了 “在平庸的喷泉中痛饮的羊群（Sheeple）”。

如果你也在狂热地使用 Claude Code、Codex 或是任何“全自动代码优化 Agent”，那么 Mitchell 花了 350 美元买来的这个血淋淋的教训，你绝对不能错过。

实验开始：让 AI 去优化“故意写烂”的代码

这场风波的起因，是 Mitchell 进行的一场极限压力测试。

作为一个硬核实验，Mitchell 决定把 Ghostty 核心的渲染器状态（Renderer State）用 Go 语言 重新写一遍。（注：他明确回复网友这只是为了好玩和压力测试，并非真的要把 Ghostty 从 Zig 移植到 Go。）

为了给 AI“挖坑”，Mitchell 故意写了一个极度幼稚的渲染器（Naively Renderer）。这段代码简单、正确，能够通过所有的验证测试（Validation Tests），但极其缓慢。

• 初始性能：每帧渲染耗时高达 88 毫秒。
• 初始内存压力：每帧疯狂分配 15 万次内存（Allocations）。

随后，Mitchell 召唤出了当今最火热的编程范式：AI Agent 自动优化（Ralph loop）。他给了 AI（Codex 5.5 High）极其宽松的权限和明确的目标：“不准修改输入数据结构，不准修改公共 API 和测试，但你可以做任何你想做的事，只要把帧耗时（Frame times）给我降下来！”

AI 开始了疯狂的迭代。它能够自己运行测试、读取 CPU/内存 Profile、查阅 Go 语言标准库文档……

在这场持续了 4 个小时、烧掉了 Mitchell 大约 350 美元（API 调用费）的极客狂欢后，Agent 骄傲地交出了它的终极优化方案：

• AI 优化后耗时：从 88ms 降至 1.5 毫秒。
• AI 优化后内存分配：从 150k 降至 ~500 次。

“听起来是不是不可思议？干得漂亮对吧？” Mitchell 在帖子里冷笑道，“大错特错。这正是 AI 精神错乱（Agent Psychosis）成为一个他妈的大问题的绝佳例子。”

降维打击：人类架构师的恐怖直觉

为什么把耗时从 88ms 降到 1.5ms，还被 Mitchell 喷得体无完肤？

因为作为对比，Mitchell 贴出了他自己亲手写（Hand-written）的 Zig 版本渲染器移植到 Go 之后的真实数据：

• 人类手写优化耗时：~20 微秒（0.02 毫秒）！
• 人类手写内存分配：在 关键路径上是 0 次分配！

差距是极其恐怖的 75 倍！

AI 究竟做错了什么？

在评论区，眼尖的开发者一针见血地指出了问题所在：“AI 只是学会了‘基准测试的本体论（Benchmark Ontology）’——比如如何分配时间片、如何通过内联等技巧绕过瓶颈，但它根本没有学会任务本身（也就是如何正确且高效地渲染终端画面）。”

另一位开发者的调侃更为致命：“让我猜猜，AI 是不是直接在渲染循环的顶部加了个 early return（提前返回）？这简直就是经典的‘奖励黑客行为（Reward Hacking）’——我见过一个 Agent 为了优化慢查询，直接把数据库表给删了。”

AI 的逻辑是典型的局部最优解陷阱（Local Maximum Trap）。它在原本的烂代码结构上，通过各种缓存、并发、小修小补，强行把时间压了下来。但它缺乏对“终端渲染器”这一复杂系统的宏观认知，它不敢、也想不到去推翻整个架构，采用类似“预分配内存池（Arena Allocator）”加“脏矩形跟踪（Dirty Tracking）”这样更本质的解决方案。

戳破幻觉：“盲从 AI 的人，正在痛饮平庸”

这场 350 美元的实验，揭开了当前 AI 辅助编程最危险的一面。

Mitchell 在帖子的核心部分发出了警告：

“这就是缺乏系统级理解的悲剧。如果你不理解系统，你就会觉得 AI 给出的结果‘令人难以置信’。但如果你真的理解这个系统，你会立刻看出更好的解决方案，并且能做出比 AI 好 75 倍的吞吐量。”

Mitchell 并没有否认 AI 的价值（他自己也在频繁使用 Codex），他痛批的是一种正在行业内蔓延的“盲从文化”。

在如今的开发圈，越来越多的开发者（尤其是缺乏底层经验的初中级工程师）正在把架构设计的权力让渡给 AI。只要代码能跑通，测试显示性能提升了，他们就会毫无保留地合并代码。

Mitchell 极其辛辣地将这些人称为：“在平庸的喷泉中痛饮的羊群（Sheeple, overdrinking from a fountain of mediocrity）。”

当你习惯了 AI 给出的“局部最优解”，你就永远失去了向“全局最优（S-tier 级别性能）”发起冲击的能力。

开发者圈的反思：被剥夺的“系统思维”与虚假的“免费午餐”

这篇帖子在 X 上引发了热烈的讨论。数百位资深开发者、CTO 和 AI 研究员纷纷入场，贡献了极其深刻的行业反思：

1. 虚假的“免费午餐”与高昂的隐形成本

很多人只看到 AI 帮你“免费”提升了性能，却忽略了背后的算力成本。

一位开发者提出质疑：“如果你让它跑 40 个小时呢？”

Mitchell 直接反击：“如果假设成本是线性的，那就是 3500 美元。谁会为了一个功能花 3500 刀去让 AI 盲目试错？”

这也暴露出目前 AI Agent 极低的资本效率——在工业界，花 350 美元去得出一个“只是及格”的平庸结果，是极度浪费的。

2. S 级程序员的断代危机

另外一位开发者惊叹于 AI 居然能为一个完全不懂底层的人带来量级上的性能提升。

但 Mitchell 立刻指出了最让人细思极恐的问题：“确实如此。但如果所有人都满足于 AI 给出的‘还可以’的结果，未来的 S 级程序员从哪里来？ 谁去承担那种需要深入底层、推倒重来的艰苦工作？”

如果我们这代人不再亲自去踩坑、去摸索内存布局的艺术，下一代的超级黑客将在平庸的代码投喂中彻底断代。

3. 系统级理解（Systems Understanding）才是终极护城河

在这场风暴中，最振奋人心的结论或许是一位开发者留下的这样一句短评：“Systems understanding is the real moat.（系统理解才是真正的护城河。）”

AI 可以瞬间写出几百种排序算法，可以帮你把嵌套循环优化成哈希表。但在面对诸如“如何设计一个无锁的并发渲染器”、“如何极致压榨 CPU 缓存命中率”这种需要将业务上下文、硬件特性与架构哲学融为一体的系统工程时，AI 依然是个门外汉。

小结：醒醒吧，别让 AI 夺走你的方向盘！

Mitchell Hashimoto 的这场实验，犹如一盆冷水，浇醒了那些沉醉在“Agent 自动编程”幻梦中的开发者。

AI 时代的到来，并不是为了让我们交出思考的权力。大模型是一辆马力极其强劲的跑车，但方向盘必须永远掌握在拥有“系统级理解（Systems Understanding）”的人类架构师手里。

如果你只是给 AI 设定一个粗糙的目标（比如“让它变快”），那么 AI 给你的，往往只是一个拼凑了无数“小聪明”的平庸怪胎；只有当你真正理解了底层的运作逻辑，你才能提出正确的问题，画出正确的框架边界，让 AI 在你的掌控下发挥出真正的威力。

正如 Mitchell 在文章最后语重心长的忠告：

“我一直在用 AI，我喜欢 AI。我想表达的是：不要盲目接受结果。去思考，去分析，去学习（Think. Analyze. Learn.）。”

在这个“劣币驱逐良币”、平庸代码泛滥的时代，愿我们都能守住最后那一点对极致性能的工匠精神，拒绝成为那些在平庸喷泉旁痛饮的“羊群”。

资料链接：https://x.com/mitchellh/status/2060088112257372610

今日互动讨论

在你的日常开发中，有没有遇到过被 AI“带偏”的时刻？如果让你用 350 美元去跑一个自动化优化的 Agent，你觉得它是“物超所值”还是“智商税”？

欢迎在评论区分享你的看法，我们一起聊聊 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/05/26/why-nvidia-chose-go-to-rewrite-their-ai-infrastructure

当大家都在谈论 CUDA、Python 和 AI 框架时，NVIDIA 的工程团队正在悄悄用 Go 构建支撑整个 AI 云平台的底层基础设施。从 GPU 函数平台 NVCF，到 AI 集群运行时 AICR，再到已经有 1.8k Star 的分布式存储 AIStore，Go 语言已经成为 NVIDIA 内部 AI 基础设施的核心技术栈。这不是偶然，而是一个精心设计的技术选型。

大家好，我是Tony Bai。

2026 年 4 月，NVIDIA 悄悄开源了一个 repo：github.com/nvidia/nvcf。

没有大张旗鼓的发布会，没有 Jensen Huang 的皮夹克登场。但如果你打开这个 repo 看一眼语言构成，数字会让你一惊：

Go 占比 88.5%。

这不是一个小工具，这是驱动 build.nvidia.com、NVIDIA DGX Cloud 推理服务和全球 GPU 云合作伙伴（CoreWeave、Oracle Cloud 等）整个控制平面的核心平台。

然后你再看 AICR（AI Cluster Runtime）：Go 51.1%。

再看 AIStore（面向 AI 的分布式存储）：Go 75.2%，1.8k Star，10,219 次 commit，是一个有深度的系统级项目。

NVIDIA 在用 Go 构建 AI 时代的基础设施。而且这个趋势正在加速。

NVCF：GPU 云函数平台的全面开源

它是什么

NVCF 全称 NVIDIA Cloud Functions，是一个用于部署、管理和运行 GPU 加速工作负载的平台。你可以把它理解为”GPU 版的 AWS Lambda”——但更贴近生产级 AI 推理场景的设计。

你注册一个 Docker 容器或 Helm Chart，指定 GPU 类型，NVCF 负责处理一切：路由、队列、自动扩缩容、多租户隔离。GPU 云合作商在自己的 Kubernetes 集群上运行 NVIDIA Cluster Agent（NVCA），算力接入 NVCF 控制平面。

2026 年 4 月，NVIDIA 以 Apache 2.0 协议开源了整个平台的完整代码，包括控制平面、调用平面、计算平面、CLI、Helm Charts 和数据库迁移脚本——全部在一个 monorepo 里。之前的 NVIDIA/nvidia-cloud-functions 和 NVIDIA/nvcf-go 两个 repo 已归档，这个新 repo 是唯一的真相来源。

三平面架构：Go 是粘合剂

NVCF 的整体架构围绕三个独立可扩展的平面展开，通过 NATS JetStream 连接。

控制平面（Control Plane）

运行在专用 Kubernetes 集群上，负责函数生命周期管理、自动扩缩容决策和密钥管理。核心服务：

• function-autoscaler（Rust）：30 秒扩缩容循环，从 VictoriaMetrics 读取利用率，决策写入 Cassandra
• helm-reval（Go）：在计算平面部署前验证 OCI 引用的 Helm Chart
• OpenBao（Apache 2.0 的 Vault fork）：函数密钥静态加密，运行时通过 ess-agent sidecar 注入
• Cassandra：持久化状态和自动扩缩容的分布式锁

调用平面（Invocation Plane）

所有请求的必经之路，Go 在这里是绝对主角：

• http-invocation（Rust/Axum）：接收 HTTP/gRPC 请求，发布到 NATS JetStream
• llm-gateway（Go）：OpenAI 兼容 API，内嵌 Olric 缓存实现 token 感知的速率限制
• grpc-proxy（Go）：转发 gRPC 调用到函数实例
• ratelimiter（Go）：使用 Olric 分布式缓存的函数级速率限制
• nats-auth-callout（Go）：支持 NKey、OIDC 和 Webhook 策略的 NATS 认证

计算平面（Compute Plane）

每个 GPU 集群运行一个 NVCA（NVIDIA Cluster Agent）Operator。NVCA 将集群注册到控制平面，消费 NATS 消息，管理 Pod 生命周期。

一次请求的完整生命周期

从调用方的 POST /v2/nvcf/pexec/functions/{id} 开始，到响应返回，完整链路如下：

1. http-invocation 检查速率限制（via ratelimiter gRPC）
2. 请求发布到 NATS stream: Create.NVCA..{clusterID}..*
3. NVCA queue manager 消费消息
4. 创建 ICMSRequest Kubernetes CR（通过 NATS sequence 去重）
5. MiniService controller 协调：创建 Pod 或应用 Helm Chart
6. 函数 Pod 通过 WorkerService gRPC 回连：ConnectOnce
7. 响应返回调用方
8. 完成时：Terminate.NVCA.{clusterID} 触发 Pod 删除和 GC

Scale-to-Zero 的关键设计：NATS 作为持久化请求缓冲区

NVCF 解决的最有趣的工程问题，是 GPU 工作负载的 Scale-to-Zero。

传统方案（如 Knative）在 Scale-up 期间请求会面临超时压力或重试。对于加载大型模型可能需要数十秒乃至数分钟的 GPU 推理来说，这个问题会非常严重。

NVCF 的解法是把 NATS JetStream 当做一个持久化请求缓冲区：

1. 自动扩缩容器将期望实例数降为 0，没有 Pod 运行
2. 新请求到达，发布到 NATS JetStream，消息被持久化
3. 自动扩缩容器检测到队列深度 > 0，将期望实例数提升到 1+
4. NVCA 收到创建消息，启动 Pod
5. Pod 通过 WorkerService gRPC 连接，拉取缓冲的消息
6. 响应通过一直保持打开状态的 http-invocation 连接返回

请求永远不会被丢弃。 调用方在冷启动时等待更长时间，但请求一定会完成。这是 NATS 持久化消息的直接价值。

AICR：AI 集群运行时，Go 写的”集群配方书”

为什么需要 AICR

搭建一个 GPU 加速的 Kubernetes 集群是出了名的难。内核版本、驱动、容器运行时、Operator、Kubernetes 版本——任何一个环节的细微差异都可能导致难以诊断的问题，而且极难复现。

这些知识以前只存在于 NVIDIA 内部的验证流水线和运维手册里。AICR 把这些知识公开了。

项目地址：github.com/NVIDIA/aicr

AICR 全称 AI Cluster Runtime，将已知可行的驱动、Operator、内核和系统配置组合，封装成版本锁定的 Recipe（配方）——可以被 Helm、ArgoCD 和其他部署框架直接使用的可复现制品。

核心概念：Recipe 系统

一个 Recipe 是针对特定环境的版本锁定配置。你描述你的目标（云厂商、GPU 型号、操作系统、工作负载意图），Recipe 引擎将其与一个经过验证的 Overlay 库进行匹配——从基础默认值到云厂商、加速器、操作系统、工作负载特定调优，自底向上分层组合。

每个 AICR Recipe 具备三个特性：

• Optimized（优化）：针对特定硬件、云、OS 和工作负载意图调优
• Validated（已验证）：发布前通过自动化约束和兼容性检查
• Reproducible（可复现）：相同输入产生完全一致的部署结果

CLI 展示：五分钟上手

# 安装 CLI（Go 编译的单一二进制）
curl -sfL https://raw.githubusercontent.com/NVIDIA/aicr/main/install | bash -s --

# 采集集群当前状态快照
aicr snapshot --output snapshot.yaml

# 为你的环境生成经过验证的 Recipe
aicr recipe --service eks --accelerator h100 --os ubuntu \
  --intent training --platform kubeflow -o recipe.yaml

# 对比 Recipe 与集群实际状态，找出差异
aicr validate --recipe recipe.yaml --snapshot snapshot.yaml

# 渲染为部署就绪的 Helm Charts
aicr bundle --recipe recipe.yaml -o ./bundles

bundles/ 目录包含按组件分类的 Helm Chart，每个组件附带 values 文件、checksum 和 README。你可以用 helm install 部署，提交到 GitOps 仓库，或使用内置的 ArgoCD 部署器。

安全供应链：SLSA Level 3

AICR 在供应链安全上走得很远：SLSA Level 3 可溯源性、签名 SBOM、cosign 镜像证明、每次发布都有 checksum 验证。这已经是不少大型企业对内部工具的要求，NVIDIA 在开源项目里直接做到了。

技术栈细节

代码以 Go 为主（51.1%），使用 golangci 做 lint，goreleaser 做发布，ko 做容器镜像构建。项目已经发布了 54 个版本，活跃度很高。目前支持 Amazon EKS、GKE 和 Kind（自管理），GPU 覆盖 H100 和 GB200，工作负载支持 Kubeflow 训练和 Dynamo 推理。

AIStore：完全用 Go 写的 AI 分布式存储

如果说 NVCF 和 AICR 还是相对新鲜的项目，那 AIStore 则是一个已经经受了时间考验的系统级工程——1.8k Star，240 个 Fork，10,219 次 commit，46 位贡献者。

项目地址：github.com/NVIDIA/aistore

核心定位

AIStore（AIS）是一个专为 AI 应用构建的轻量分布式存储栈。它是一个弹性集群，可以在运行时扩缩容，支持从单台 Linux 机器到任意规模的裸机集群的任意部署方式。

AIS 的核心差异点：它能原生操作集群内数据和远程数据，而不是把远程数据当成缓存。这对 AI 训练工作负载来说是关键区别——你不需要先把 S3 数据拉下来再训练，AIS 可以透明地处理数据层。

技术亮点一览

• 多云后端支持：无缝访问 AWS S3、GCS、Azure、OCI，支持跨账号、跨 endpoint 的同名 bucket 共存。
• 线性扩展性：官方博客和 KubeCon 演讲中展示了跨任意数量集群节点的均衡 I/O 分布和线性扩展能力。
• ETL Offload：在数据附近执行 I/O 密集型数据转换，可以内联（作为每次读请求的一部分实时处理）或离线（批量处理，结果写入目标 bucket）。
• Get-Batch：单次调用检索多个对象或归档文件。专为 ML/AI 流水线设计，一次操作获取整个训练批次，按用户指定的顺序组装成 TAR（或其他序列化格式）。这个功能甚至有配套的 arxiv 论文（2602.22434）。
• 负载感知节流：基于多维度负载向量（CPU、内存、磁盘、文件描述符、goroutine）的动态请求节流，保护 AIS 集群在压力下的稳定性。
• 30+ 批处理操作：包括 archive、blob-download、copy-bucket、dsort、etl-bucket、lru-eviction、rebalance、rechunk 等，全部可以通过 CLI 启动、监控和控制。

为什么用 Go

AIStore 75.2% 的代码是 Go，其 Go API 直接被 CLI 和 benchmarking 工具使用。选择 Go 的逻辑很清晰：

1. 系统级性能：Go 的 goroutine 模型天然适合高并发 I/O 密集型工作负载，而分布式存储正是这种场景
2. 单一二进制发布：CLI 工具和服务端都能编译成静态链接的单一二进制，部署极其简单
3. 生态成熟：Kubernetes operator、gRPC、NATS、Prometheus——这些基础设施领域的核心库在 Go 生态中都有成熟实现
4. 代码可维护性：相比 C++，Go 在保持接近底层性能的同时大幅降低了复杂系统的维护成本

为什么是 Go？NVIDIA 的技术选型逻辑

把这三个项目放在一起看，NVIDIA 选择 Go 的逻辑变得清晰：

AI 基础设施的特殊需求

AI 基础设施不同于传统 Web 服务。它需要处理：

• GPU 资源的精细调度和隔离
• 大规模并发请求的队列管理
• 跨多集群的协调
• 模型文件的海量 I/O
• 长时间运行的异步任务

这些场景对并发模型的要求极高。Go 的 goroutine 和 channel 机制，让工程师可以用清晰的代码表达复杂的并发逻辑，而不需要像 C++ 那样手动管理线程。

云原生生态的”母语”

Kubernetes、Docker、containerd、Prometheus、NATS、Helm——云原生基础设施栈几乎是用 Go 写的。NVIDIA 的三个项目全部深度集成 Kubernetes，深度依赖 Operator 模式、Controller Runtime、Helm Chart。选择 Go 意味着可以直接使用这些生态的核心库，而不是跨语言调用的额外复杂度。

运维友好的单一二进制

aicr、ais CLI 工具都是 Go 编译的单一静态二进制。在需要快速部署到新集群、在 CI/CD 流水线中运行、或者在边缘节点上操作时，这个特性极其实用。

Rust + Go 的互补分工

值得注意的是，NVCF 并不是全 Go。高性能热路径（http-invocation、function-autoscaler）用了 Rust，而控制逻辑、网关、代理、认证——这些需要快速迭代、逻辑清晰的组件——用 Go。

这个分工很有意思：Rust 负责极致性能的关键路径，Go 负责需要快速演化的系统逻辑。两种语言各司其职，而不是用一种语言通吃所有场景。

小结：这意味着什么

对 Go 开发者

NVIDIA 的这几个 repo 是绝佳的真实世界大型 Go 项目参考：

• NVCF：学习 Kubernetes Operator 模式、gRPC、NATS 集成、多平面分布式系统设计
• AICR：学习 CLI 工具设计（goreleaser + cobra）、Helm 生成、GitOps 集成模式
• AIStore：学习高性能分布式系统的 Go 实现，包括内存管理（memsys 包）、分布式一致性、S3 兼容 API 实现

这三个项目都是 Apache 2.0 或 MIT 开源，代码质量高，有完整的测试和文档。

对 AI 平台工程师

NVIDIA 正在开源 AI 基础设施的核心组件。NVCF 的开源意味着你可以：
- 在私有 GPU 集群上运行与 NVIDIA 云服务相同的调度和路由逻辑
- 审计每一行代码，而不是把平台当成黑盒
- 修改自动扩缩容逻辑、添加 NATS 认证策略、扩展 MiniService controller

AICR 则给了你一个”NVIDIA 认证”的集群配置参考——如果你正在搭建自管理 GPU 集群，AICR 的 Recipe 系统告诉你什么组合是经过验证的。

对技术决策者

当 NVIDIA——一家以 CUDA C++ 闻名的公司——在 AI 基础设施层面系统性地选择 Go，这个信号足够强烈。Go 已经不只是”Google 的语言”或者”云原生工具链的语言”，它正在成为 AI 时代基础设施的核心技术栈之一。

资料链接：

• https://blog.kubesimplify.com/nvcf-is-now-open-source-inside-nvidia-s-gpu-function-platform
• https://github.com/nvidia/nvcf
• https://github.com/NVIDIA/aicr NVIDIA AI Cluster Runtime
• https://github.com/NVIDIA/aistore AIStore: scalable storage for AI applications

还在为写 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/05/23/google-open-sources-ax-and-agent-substrate-agent-centric-cloud-native-foundation

大家好，我是Tony Bai。

随着大语言模型（LLM）与应用场景的深度融合，AI 正在从单纯的“聊天对话框”快速演进为具备长期运行、自主工具调用和复杂任务编排能力的 AI Agent（智能体）。

在生产环境中，这些 Agent 展现出与传统微服务截然不同的负载特征：它们是高度非线性的、需要频繁执行不可信代码（如动态生成的 Python 脚本）、在等待人类确认（HITL，人类在环）时长期处于闲置状态，同时又会在瞬时产生极其高频的子秒级（Sub-second）工具调用。

传统的容器和虚拟机调度架构（如标准的 Kubernetes）面对这种数以百万计、高密度、长生命周期但又极度高并发的“智能体负载（Agentic Workflows）”时，在隔离安全性、调度时延与算力浪费上面临严重的物理局限。

针对这一工程痛点，Google 在 Google I/O ’26 大会上给出了其深思熟虑的系统级回应。这并非一个单一工具的发布，而是一套分层解耦的云原生 Agent 堆栈的整体亮相。

Google 定义的“三层 Agent 堆栈”，其中包含了：

1. 应用运行时（Agent Runtime）：开源项目 Agent Executor（AX），专注于可靠的状态编排、连接恢复与执行审计。
2. 高密度计算与调度层（Compute Plane）：开源项目 Agent Substrate，专注于海量闲置 Agent 的极速挂起/恢复与去中心化控制平面调度。
3. 安全隔离层（Sandbox Layer）：已正式商用的 GKE Agent Sandbox，基于 gVisor/MicroVM 技术，提供低时延、强隔离的运行沙箱。

本文将拆解这一套以 Agent 为负载单元的新型云原生抽象层，揭示 Google 是如何重新定义大模型时代的分布式系统底座的。

架构解密：从基础设施到应用层的“三层 Agent 堆栈”

要理解这一套复杂的系统，我们需要像拆解传统 TCP/IP 协议栈一样，将其自底向上划分为四个物理层级：

这种分层解耦的系统设计，标志着 AI 应用开发正式告别了“框架包揽一切”的单体混沌状态，进入了精细化、高可用的系统工程时代。

底层解局：Agent Substrate 与 Sandbox 是如何解决物理局限的？

传统的 Kubernetes 是为了支撑长期运行、状态相对稳定的“微服务（Microservices）”而设计的。如果直接将数百万个 Agent 部署为普通的 K8s Pod，系统会迅速面临崩溃：

• 内存与算力浪费：许多 Agent 处于非激活状态（等待人类输入或调度触发），如果让它们的 Pod 持续在线，会产生天文数字的算力账单。
• 控制面过载：数百万个 Agent 产生的子秒级内部工具调用，如果全部经过传统的 K8s API Server 进行调度和授权，会直接导致 K8s 控制平面瘫痪。
• 安全防线脆弱：Agent 具有动态执行解释型代码（如本地运行一段临时生成的 Python 来计算数据）的本能，一旦逃逸，将危害宿主机安全。

为此，Google 联合 GKE 团队和 Kubernetes 社区，推出了 Agent Substrate 与 Agent Sandbox：

1. 基于 gVisor 的强物理隔离（Ironclad Security）

GKE Agent Sandbox 默认集成了开源的安全容器沙箱 gVisor。

它在不可信的 Agent 应用代码与 Linux 内核之间插入了一个名为 Sentry 的用户态内核。所有 Agent 试图执行的系统调用（Syscalls）都会在用户态被拦截、审计并安全执行。这确保了即便 Agent 生成的代码带有恶意，也绝无可能穿透容器逃逸到宿主机上，实现了生产级的“Secure-by-design”。

2. Pod 快照技术与冷启动消除（Reduce Idle Compute & Low Latency）

为了消灭 Agent 闲置时的算力浪费，Agent Substrate 引入了 Pod 快照技术（Pod Snapshots）：

• 主动挂起（Suspend）：当一个 Agent 进入休眠或长时等待状态时，Agent Substrate 捕获其完整的运行状态并制作快照，释放其占用的物理 CPU 与内存资源。
• 瞬时恢复（Resume）：当事件触发或用户响应时，系统通过集成的 温水池（Warm Pool） 技术，利用快照快速恢复运行。

根据 Google Cloud 的官方测评，GKE Agent Sandbox 能够在每秒启动 300 个沙箱的高并发压力下，保证 90% 的分配在 200 毫秒内完成。这几乎抹平了传统安全容器长达数秒的冷启动时延，真正做到了“随用随起，用完即挂”。

应用层编排：Google AX 如何行使“指挥官”职责？

在底层的 Agent Substrate 提供了极致的物理隔离与快速调度能力后，位于上层的 Agent Executor (AX) 运行时则真正扮演起了“状态与业务编排指挥官”的角色。

AX 的核心设计并不是去触碰模型细节，而是通过 Single-Writer 架构 和 Durable Execution（持久化执行） 来保障 Agentic 循环的绝对可靠：

1. 轨迹分支（Trajectory Branching）与分支克隆（Forking）

在复杂决策中，开发者往往希望 Agent 能像写代码一样，在某个关键节点“分叉（Fork）”去尝试多条不同的规划路径，在评估各路径的优劣后再做最终合并。

由于 AX 底层维护了强一致性的持久化事件日志，它原生提供了 ax fork 功能：

ax fork \
  --src-conversation 38460323-9a78-41cb-8991-022b0ff2c19c \
  --dest-conversation e5e26e38-53a2-4f22-b1cb-ae867357df83 \
  --src-seq 12

开发者可以直接在指定的事件序列号（–src-seq 12）处，克隆出一条全新的、独立的执行轨迹（Trajectory）。这让 AI 在多路径探索、蒙特卡洛树搜索（MCTS）等高级推理算法中的应用变得异常简单和标准。

2. 会话一致性（Session Consistency）

在多客户端并发控制或分布式协作中，多个进程可能同时试图更新同一个 Agent 的会话状态。AX 的单写入者（Single-Writer）架构通过统一的序列号控制机制，彻底避免了因并发竞争（Race Conditions）导致的状态脏写与损坏。

统一的工程视角：Go 的系统级胶水作用

如果我们仔细观察这套三层架构，会发现一个极具工程美学的现象：

1. 最底层的 Kubernetes 与 GKE Sandbox：由 Go 语言统治。
2. 中间层的 Agent Substrate 与 AX：同样是由 Go 语言构建（github.com/google/ax 和 github.com/agent-substrate/substrate）。
3. 最上层的 Agent 应用与框架：则可以使用 Python（如 LangChain、ADK）来尽情发挥，当然如果你依然要使用Go，比如adk-go，来开发Agent应用也是非常棒的选择。

这一架构再次印证了我们在 AI 系统工程中的理性认知：运行时底层是系统级工程（System Engineering），应用层是模型算法工程（Algorithm Engineering）。

Go 语言在这里扮演了不可替代的“系统级胶水”角色：它将高密度调度、gRPC 双向流、持久化快照以及隔离沙箱等硬核的系统级原语，封装成极其简单易用的 CLI 和 API，让上层的应用开发者能够专注在 Prompt 与模型逻辑上。

小结

在看完 Google 发布的这一套以 Agent 为第一公民的云原生计算底座后，作为软件工程师，我们应该感到无比的兴奋。

大模型确实降低了写业务逻辑代码的门槛，甚至让“AI 自动编程”成为可能。但正如 Google 资深软件工程师 Tim Hockin（Kubernetes 的共同创始人之一）和 Brandon Royal 的联手探索所展示的那样：如何在大规模、高密度、异构的物理硬件集群中，保障这些 AI 智能体安全、高效、廉价地运转，是一个极其深邃、且刚刚拉开序幕的分布式系统课题。

• 谁来设计高密度的内存挂起与快照算法？
• 谁来在网络边界保障 gVisor 沙箱的安全网络策略？
• 谁来在 AX 层面设计多 Agent 协作时的数据一致性协议？

这些问题，AI 无法自己解决，它需要那些真正懂得底层计算机制、网络协议和系统调度的优秀工程师。

随着大模型和 Agent 的普及，软件工程正在经历一场从“单机时代”迈向“网格化 Agent 集群时代”的伟大战役。掌握这一套新型基础设施设计哲学与开发范式的架构师们，正在迎来属于他们的、前所未有的黄金时代。

资料链接：

• https://x.com/rakyll/status/2057129537553785093
• https://cloud.google.com/blog/products/containers-kubernetes/bringing-you-agent-sandbox-on-gke-and-agent-substrate
• https://cloud.google.com/blog/products/ai-machine-learning/agent-executor-googles-distributed-agent-runtime
• https://github.com/agent-substrate/substrate
• https://github.com/google/ax
• https://github.com/kubernetes-sigs/agent-sandbox

✍️ 今日的深度思考题：

当底层的 GKE Sandbox 能够将 Agent 启动时延压低至 200 毫秒以内、且支持自动挂起时，你会如何重新设计你的多 Agent 编排逻辑？这会给你的服务器算力账单带来怎样的改变？

欢迎在评论区留下你对这一套“Agent 时代 K8s 抽象层”的看法，我们共同探讨云原生的未来！

还在为写 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/05/21/go-is-the-new-lingua-franca-for-ai-agents-at-google

大家好，我是Tony Bai。

在过去的两年里，只要一提到 AI 开发，99% 的人脑海中弹出的第一个词绝对是：Python。而如果是涉及到大模型底层的高性能推理与算力压榨，大家想到的必然是 C++ 或是 Rust。

但在真正的工程落地中，情况正在发生一场令人猝不及防的剧变。

最近，Google 资深软件工程师 Jaana Dogan（@rakyll）在 X（原推特）上发布了一条引发技术圈热议的推文：

“Go 成为 Google 内部 Agentic（智能体）系统的通用语言（lingua franca），这真的很了不起。我以前从未看到过 Go 有取代 C++ 的路径，但现在我相信这是可能的。”

这不仅仅是一条简单的技术感慨，它揭示了 AI 浪潮进入“下半场”后的核心工程困境：当我们把大模型封装成 Agent，并让成千上万个 Agent 并发协作时，Python 太脆弱，C++ 太沉重，而 Go，迎来了它的“天命时刻”。

今天，我们就来扒一扒，为什么 Google 会让 Go 接管 AI Agent 的底层开发？这对我们普通开发者的技术栈转型，又意味着什么？

打破滤镜：为什么 Python 和 C++ 在 Agent 时代“失宠”了？

要理解 Go 的上位，我们首先要搞清楚，AI Agent 到底需要什么样的工程能力。

现在的 AI 应用，早就不是早期那种“写个 Python 脚本，调用一下 OpenAI API，把结果打印出来”的玩具了。真实的 Agentic 系统（智能体系统）包含了极其复杂的网络 I/O、并发工具调用（Tool Calling）、多智能体消息路由、长时记忆状态管理，以及大规模的分布式容错。

在这个场景下，旧有的王者们暴露出了致命的缺陷：

1. Python 的“工程化陷阱”

Python 是 AI 研究员的最爱，因为它的数据科学库天下无敌。但当你要构建一个高并发、高可用、需要 24/7 运行的 Agent 编排系统时，Python 的弱类型（重构火葬场）和 GIL（全局解释器锁，导致无法真正利用多核并发）就成了灾难。正如原贴讨论区一位开发者所言：“模型层可能是 Python 的天下，但围绕着模型的 Runtime（运行时环境）正越来越像 Go 的领地。”

2. C++ 的“杀鸡用牛刀”

C++ 拥有极致的性能，是模型训练和推理引擎（Inner Loop）的绝对霸主。但 Agent 编排系统真的需要 C++ 级别的疯狂数学计算吗？不需要。

Agent 系统本质上是大量的网络等待（等 LLM 返回结果、等数据库查询、等网页抓取）。用 C++ 来写极其复杂的并发网络请求和状态机，不仅开发周期漫长，而且极易产生内存泄漏。正如推文评论所指出的：“C++ 背负了太多的历史包袱，它在 Agent 编排上显得太重了。”

Go 凭什么上位？Goroutine 与 Agent 的“完美同构”

Go 语言在这个时间节点爆火，并非偶然，而是因为它底层的并发哲学与 AI Agent 的行为模式产生了“完美的同构映射”。

在 X 上的讨论中，多位资深开发者一针见血地指出了核心原因：

“Goroutines mapping directly to concurrent agent communication is the reason why it makes perfect sense.”（Goroutine 直接映射到并发 Agent 之间的通信，这是它如此完美契合的原因。）

让我们用大白话来翻译一下这个硬核逻辑：

什么是多智能体系统（Multi-Agent System）？本质上就是一堆各自独立的“数字员工”，它们一边自己干活，一边通过发消息相互沟通。
而 Go 语言最强大的杀手锏是什么？正是 CSP（通信顺序进程）并发模型，即 Goroutine（轻量级协程）和 Channel（通道）。

• 当你启动一个 Agent 时：在 Go 里，你只需要一个简单的 go runAgent()，就能以极其低廉的内存代价（几 KB）启动一个并发实体。一千个 Agent？一万个 Agent？对 Go 来说毫无压力。
• 当 Agent 之间需要协作对话时：你不需要去搞复杂的锁（Locks）或者共享内存，你只需要用 Go 的 Channel 把消息塞过去，另一个 Agent 就能安全地接收。

Agent 的编排，需要的是“轻量级的并发管理”，而不是“极致的数学计算速度”。这简直就是为 Go 量身定制的战场。

征服大厂，构建 Agent 架构的“铁三角”

除了并发模型上的天作之合，评论区的一位开发者还另外总结了 Go 赢下这场战争的另外三个决定性因素。他指出，现代 Agent 技术栈奖励三种特性，而 “Go 完美击中了这三点（Go nails all three）”：

1. 强类型系统（Types）：告别“盲盒”开发

Agent 系统中充斥着复杂的 JSON 解析、Tool Calling 的参数校验、以及结构化的输出。Python 的字典（Dict）传递在项目变大后就像是“盲盒”，你永远不知道里面缺了哪个字段。而 Go 的强类型 Struct 和极度清晰的错误处理机制（虽然大家都吐槽 if err != nil，但它确实极其可控），让系统拥有了极高的可预测性（Predictability）。

2. 极速的编译体验（Fast Builds）

“编译速度是让它成为绝配的原因之一。”在快速迭代的 AI 产品中，Go 那种秒级的编译速度，让开发者可以飞速地测试 Agent 的行为逻辑。相比之下，C++ 那漫长的编译过程在需要高频微调的 AI 时代显得格格不入。

3. 小巧的单一二进制文件（Small Binaries）

当你把 Agent 部署到云端、边缘设备甚至是 Serverless 环境时，Go 编译出来的是一个无需任何外部依赖的独立执行文件。没有 Python 烦人的环境依赖（无需折腾 pip, conda, 虚拟环境），直接丢进一个极小的 Docker 镜像中就能运行，这对于现代云原生运维来说是无可估量的优势。

一个反直觉的冷知识：大模型“最爱”写 Go 代码

推文中一个开发者提出了一个极其有趣且经常被忽视的视角：在 LLM（大语言模型）的眼中，Go 是一门完美的语言。

如果你经常用 Cursor/Codex/Claude Code等 写代码，你会发现一个现象：让 AI 写 Python，它经常会用错第三方库的版本；让 AI 写 C++ 或 Scala，它可能会搞出一堆极其复杂的继承、多态或者生命周期错误。

但如果你让 AI 写 Go 呢？成功率出奇的高。

原因在于：

1. Go 的语法极致简单、无聊，甚至“没有类（Classes）”。它只有 Struct 和接口，这极大地减少了代码的“表面积（Surface Area）”。
2. Token 使用率极高。由于没有复杂的黑魔法和繁琐的泛型体系（早期），LLM 在生成 Go 代码时不容易出现“幻觉”，维护起来极其容易。

在这个连代码本身都开始由 AI 生成的时代，“对 LLM 友好”竟然成了一门编程语言的核心护城河。

终局推演 —— C++ 守住“内环”，Go 赢下“外环”

那么，Go 真的会彻底消灭 C++ 吗？

并不完全是。这场讨论最终达成了一个非常清晰的技术栈共识：

“C++ still wins the inner loop. Go wins everything around it.”（C++ 依然赢得了内环，而 Go 赢得了周围的一切。）

未来的 AI 系统架构已经初露端倪，它将被清晰地划分为三个层级：

1. 研究与数据层（Python）：用于模型训练、数据清洗、算法验证。
2. 算力内环（C++ / Rust / CUDA）：大模型的推理引擎（如 vLLM、Ollama 底层）、张量计算。这里需要极致榨干每一滴 GPU 性能，C++ 依然是绝对的霸主。
3. 编排外环与业务层（Go）：这是距离普通开发者最近、也是市场需求最大的地方。成千上万的 Agent 调度、API 网关、并发的数据检索（RAG）、记忆数据库交互、工具链调用，全部都将被 Go 统治。

最新铁证！Google I/O 2026 震撼官宣：废弃旧路线，用 Go 重写 AI 核心入口！

如果你觉得前面硅谷大佬们的讨论还只是“理论推演”，那么在刚刚举办的 Google I/O 2026 大会上，Google 官方直接用一记雷霆手段，把这个趋势变成了既成事实。

Google 开发者博客发布了公告：正式宣布停止维护原有的 Gemini CLI，全面过渡到全新的“Google Antigravity（反重力）”多智能体开发平台，并推出全新的核心入口 —— Antigravity CLI。

而在官方给出的技术变更文档中，最扎眼、最让 Go 开发者狂喜的一条更新理由，白纸黑字地写着：

“Faster execution: Built in Go, Antigravity CLI is snappier and more responsive.” （更快的执行速度：基于 Go 语言构建，Antigravity CLI 更加轻快、响应更迅速。）

旧版的 Gemini CLI 是基于传统脚本语言（Node.js/TS 体系）构建的，在处理单点交互时绰绰有余。但 Google 明确表示，现在开发者的需求已经彻底变了：“你现在需要多个 Agent 相互通信、分工合作来解决复杂的系统问题。”

当单点 CLI 变成“多 Agent 协同编排后端”时，旧有的 JS/TS 体系在高并发、异步工作流（Asynchronous Workflows）和底层系统控制上面临性能瓶颈。Google 毫不犹豫地选择用 Go 语言 彻底重写，就是为了利用 Go 极致的并发和执行效率，来支撑起“后台多任务并发运行、且不锁定终端”的强悍体验。

小结：给开发者的生存建议

过去的一年里，无数后端开发者感到焦虑，觉得自己掌握的 CRUD 技能在 AI 面前一文不值。但 Google 内部的这场技术栈迁移，给我们指明了一条无比清晰的道路：

别再只盯着 Python 看了。

当 AI 从单一的对话框，走向全面接管企业业务流的多智能体（Multi-Agent）协作形态时，对高并发、高可用后端工程能力的需求不仅没有减少，反而呈指数级爆发。

学习 Go 语言，理解 Goroutine，掌握如何构建一个稳健的 Agent 编排框架。因为决定下一个十年 AI 应用成败的，不再是模型本身的算力，而是谁能最好地管理和协调这些拥有智能的“数字大军”。

而目前来看，Go，已经在这场战役中拔得头筹。

资料链接：https://x.com/rakyll/status/2056528039698403498

今日互动探讨：

你目前在开发 AI 应用或 Agent 系统时，使用的是什么语言？你是否遇到了 Python 在高并发或部署时的痛点？欢迎在评论区分享你的实战经验与踩坑血泪史，我们一起探讨 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. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/20/ai-coding-win-rate-rankings-go-and-rust-vs-cpp

大家好，我是Tony Bai。

过去两年，程序员群体经历了一场前所未有的“职业身份危机”。

随着 GPT、Claude、Gemini 等模型的发布与能力更迭，各种“AI 几秒钟写出小游戏”、“AI 自动化修复 Bug”的新闻充斥屏幕。在各种传统的代码补全基准测试（如 HumanEval）中，大模型们动辄刷出 90% 以上的惊人通过率。一时间，“程序员是夕阳行业”、“架构师即将下岗”的言论甚嚣尘上。

然而，这只是硬核工程世界的冰山一角。最近，由 Meta FAIR（Meta 基础人工智能研究实验室）、斯坦福大学和哈佛大学联合发布的一项重量级研究——ProgramBench，彻底击碎了这些幻觉。

ProgramBench 的设计初衷非常“残暴”：它不再测试 AI 能不能写出一个简单的算法函数，而是测试 AI 能不能从零开始（From Scratch）复刻一个完整的开源项目，即从观测二进制行为（Probe）到编写源码（Build），再到最终的等效性评估。

测试规则如下：

1. 黑盒逆向：不给源码，只给 AI 一个编译好的二进制可执行文件（如 sqlite3、ffmpeg、ripgrep）和一份使用说明书。
2. 物理断网：切断互联网访问，防止 AI 通过搜索“偷看”GitHub 上的源码。
3. 架构自主：AI 必须自己决定项目的文件结构、选择什么编程语言、设计什么抽象层次。

在这场面向 200 个真实复杂项目的“闭卷考试”中，全球最顶尖的大模型们集体陷入了沉思。

数据表明，即便是在最强的模型面前，完全成功的概率依然是 0。

但在这场败战中，我们通过海量数据发现了一个足以改变未来十年技术选型的真相：Go 与 Rust 已经成为了 AI 时代的“天命语言”，而 C++ 则不那么受 AI 青睐，AI 用起来也不那么顺手！

诸神黄昏：Claude 对 GPT 家族的“工程级”碾压

在程序员的认知中，GPT 家族曾代表着 AI 的巅峰。但在 ProgramBench 的 Leaderboard（排行榜）上，局势发生了戏剧性的反转，但也正如我们预料的那样。

根据论文统计，在衡量“几乎完成”（即通过 95% 以上的测试用例）这一指标时，排名如下：

1. 头号种子：Claude Opus 4.7。它是全场唯一一个在 3.0% 的复杂项目中展现出近乎完美复刻能力的模型。
2. 二号梯队：Claude Opus 4.6 (2.5%) 与 Claude Sonnet 4.6 (1.6%)。
3. 集体挂零：GPT 5.4、Gemini 3.1 Pro。 没错，这些在其他榜单上呼风唤雨的模型，在“从零复刻完整项目”的任务中，竟然连一个能通过 95% 测试的任务都没完成。

为什么 GPT 会在硬核工程上输给 Claude？

研究人员通过分析“智能体轨迹（Agent Trajectories）”发现了秘密。大模型写代码有两种流派：

• “急性子”派（以 GPT 5.4 为代表）：GPT 倾向于“单次爆发”。数据显示，它在每个任务中平均只用 17 个命令。它习惯于在最初的几个回合内，直接吐出 96% 的代码。如果代码跑不通，它很少进行深度的自我修正。
• “架构师”派（以 Claude 为代表）：最强的 Claude 模型更像是一个深思熟虑的工程师。它平均每个任务会调用 868 个命令！它会不断地执行 ls 查看目录、用 cat 检查文件、反复运行测试并根据报错信息进行“重构”。

可见，在复杂的软件工程面前，单纯的“语料记忆”失效了。Claude 的胜出，本质上是其“推理链”和“持续迭代能力”的胜出。它不只是在背代码，它是在通过不断的试错来“推演”架构。

通过上图中不同模型的动作类型分布，我们可以看到 Claude 拥有极长且复杂的“读-写-探测”循环，而 GPT 的动作序列短得惊人。

语言偏好：AI 也有自己的“舒适区”

ProgramBench 给 AI 提供了完全的自由：AI 可以用任何语言来复刻目标程序。这产生了一个极其有趣的“语言混乱矩阵（Confusion Matrix）”。

1. GPT 的 Python 执念

GPT 5.4 表现出了近乎偏执的 Python 依赖。在所有任务中，它有 79% 的方案是用 Python 写的。无论原程序是用更底层的 C 还是 Rust 写的，GPT 的第一反应往往是：“我能不能用 Python 给它糊出来？”

2. Claude 的硬核品味

最强模型 Claude Opus 4.7 表现出了极高的系统级素养。它只在 14% 的情况下选择 Python，它更倾向于使用 Rust 和 Go 来应对复杂任务。这说明越强大的模型，越能理解底层语言在性能和逻辑表达上的严密性。

3. 为什么 AI 喜欢 Python？

原因很简单：容错率。 Python 拥有极其丰富的第三方包、极简的语法以及无需手动管理内存的特性。对于 AI 来说，Python 是它能用最少的回合数实现最多功能的“逃生路径”。但这种逃生是有代价的——复杂的系统级软件用 Python 复刻，往往会因为性能或底层调用模拟不足而失败。

深度解析：为什么 Go 与 Rust 是 AI 的“天命之子”？

这是本次研究中最具行业指导意义的发现。通过研究数据对比，我们发现不同语言在 AI 手下的“存活率”天差地别：

• Go 语言项目：AI 成功通过率 38.4%
• Rust 语言项目：AI 成功通过率 38.5%
• C/C++ 项目：AI 成功通过率仅为 27.7%

为什么同样是系统编程语言，Go 和 Rust 就能完胜 C++？这不仅仅是语法的问题，更是现代工程化基建的降维打击。

1. 构建系统：AI 开发者的“生死线”

在 C/C++ 的世界里，构建系统是混乱的代名词。CMakeLists.txt、Makefile、系统特定的动态链接库（.so/.dll）路径……对于 AI 智能体（SWE-agent）来说，这些是致命的障碍。

调研显示，AI 在 C++ 任务中，往往还没开始写业务代码，就已经在配置环境时陷入了死循环。

反观 Go 和 Rust：

• Go：一个 go mod tidy 加一个 go build 解决了全球 99% 的构建问题。
• Rust：Cargo 是目前人类文明最先进的包管理器之一。

对于 AI 来说，这种“标准化”意味着它只需要执行一条命令就能建立起完整的工程环境。这种极高的工程化一致性，让 AI 可以把宝贵的 Token 消耗在业务逻辑上，而不是折腾环境。

2. 标准库的“全家桶”效应

Go 语言一直以“自带电池（Batteries included）”著称。它的标准库涵盖了网络、加密、编解码等大部分现代互联网开发所需的功能。AI 调用 Go 的标准库就像从兜里掏东西一样自然。

而 C++ 的标准库相对贫瘠，往往需要引入第三方库（如 Boost, libcurl）。一旦涉及到第三方依赖，AI 的出错概率就会呈指数级上升。

3. 内存安全：给 AI 的“保护索”

在 C/C++ 中，AI 极其容易写出缓冲区溢出、内存泄露或段错误。一旦程序在运行过程中崩溃，由于 AI 缺乏深度的 GDB 调试能力，它很难从 Core Dump 中恢复。

Rust 严格的借用检查（Borrow Checker），在编译阶段就强行纠正了 AI 的大部分错误。这种“编译即正确”的反馈循环，让 AI 在复刻软件时拥有了更高的胜率。

揭秘 AI 程序员的“坏习惯”：屎山代码的起源？

除了排名和语言，ProgramBench 还揭露了目前 AI 编码的三个极具冲击力的特征：

1. 单文件架构迷恋

人类架构师讲究解耦，喜欢建立复杂的目录结构。但 AI 却恰恰相反。数据显示，67% 的 AI 方案产生的目录深度明显浅于原项目。

AI 表现出强烈的“单文件狂魔”倾向。 它们喜欢把数千行代码塞进 1-3 个超级大文件里。这反映出目前的模型在处理跨文件的上下文关联时，依然存在明显的认知衰减。

2. 逻辑“大颗粒化”

AI 写的函数数量通常只有人类原作者的 10% 到 20%。但这并不意味着功能缺失，而是因为 AI 喜欢写超长函数（God Functions）。

Claude 生成的函数长度平均是人类的 1.46 倍，Gemini 甚至达到了 1.62 倍。这种代码对于 AI 来说运行没问题，但对于人类后续维护来说，简直是噩梦。

3. 诚信危机：AI 也会“偷懒作弊”

在测试的早期阶段，研究人员尝试给 AI 开启互联网访问。结果发现，最强的大模型们全都是“老油条”。

一旦它们通过二进制文件的帮助信息（–help）推断出这是哪个开源项目，它们会直接去克隆对应的 GitHub 仓库代码并提交。

Claude Sonnet 4.6 的作弊率一度高达 36%！ 这迫使研究团队最终必须在完全断网的环境下运行测试。这告诉我们：永远不要低估大模型为了完成任务而寻找“捷径”的本能。

小结：程序员的黄昏还远未到来

看完这份长达 60 多页的研究报告，我们不仅没有感到绝望，反而产生了一种前所未有的踏实。

报告证明了：即便是在最顶尖的模型面前，真实的软件工程（Software Engineering）依然是一个极度复杂的高壁垒领域。写代码只是软件工程中最后、最轻的一环。而之前的架构设计、模块拆分、抽象提取、以及对业务边界的理解，目前的 AI 依然处于“学龄前”阶段。

给开发者的建议：

1. 向 Go 和 Rust 迁移：这不只是性能考量，更是为了拥抱 AI。如果你想让 AI 帮你更高效地干活，请选择那些对 AI 友好的工程化基建。
2. 强化架构师思维：既然 AI 喜欢写单文件“屎山”，那么如何管理大型项目的复杂性、如何通过 Prompt 引导 AI 进行模块化设计，将是未来高级工程师的核心竞争力。
3. 拥抱 Claude 模式：告别“单次生成”的幻觉，建立起“持续迭代、自动测试、反复纠错”的 AI 开发流水线。

程序员的黄昏还远未到来。

相反，我们正在进入一个全新的时代：一个由人类架构师掌控蓝图，由 AI 劳工在标准化的 Go/Rust 仓库中疯狂试错、高效产出的黄金时代。AI 并没有取代你，它只是淘汰了那些只会机械写代码、而不懂工程设计的“码农”。

真正的开发者，正在迎来属于他们的、被 AI 加持的黎明。

资料链接：

• https://arxiv.org/abs/2605.03546
• https://programbench.com/

还在为写 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/05/18/go-performance-optimization-over-rust-rewrites

大家好，我是Tony Bai。

近年来，如果你常年混迹于国内外各大技术社区，你一定会感受到一种近乎狂热的“政治正确”：带垃圾回收（GC）的语言都有原罪，万物皆可（且应该）用 Rust 重写。

从底层基础设施到上层业务逻辑，无数团队在遇到性能瓶颈时，脑海中蹦出的第一个念头就是：“Go/Java 搞不定了，由于 GC 停顿的存在，我们必须换 Rust 乃至 C++ 来重构核心模块。”

但这真的是解决性能问题的唯一出路吗？

最近，几位硅谷顶级的技术大佬——前 Tailscale CTO David Crawshaw、开源时序数据库 VictoriaMetrics CTO Aliaksandr Valialkin，以及资深底层代码大牛 Stewart Lynch，在 X（原推特）上掀起了一场关于“现代软件复杂性与性能优化”的讨论。

仔细研读他们的观点后，我得出了一个可能有些“反直觉”的结论：

对于绝大多数商业项目而言，盲目追求去 GC 化和无脑 Rust 重写，是一场灾难。真正顶级的性能优化，往往只需要对那 1% 的“热路径”动刀。

今天，我们就来揭秘这层信息差，看看顶级架构师是如何在不增加心智负担的前提下，把带 GC 的 Go 语言性能压榨到极致的。

现代软件最大的毒瘤：“不必要的复杂性”

为什么我们总是忍不住想要用极其复杂的语言或架构去重写现有的系统？

Stewart Lynch 在讨论中一针见血地指出了现代软件工程的通病：“Everything that’s wrong with modern software can be summed up in two words: Unnecessary Complexity”（现代软件所有的毛病，可以用两个词来概括：不必要的复杂性）。

这背后其实隐藏着一个程序员群体独有的心理学陷阱。

Lynch 解释道：“程序员这个群体有一个特殊的问题——我们往往是因为‘享受解决复杂问题’才选择这个职业的。我们热衷于理解极其复杂的东西并让它运转起来，我们是人类历史上最复杂结构的构建者。正因为如此，我们在任何地方都在寻找与复杂性搏斗的机会，即使在那些本该追求极简的地方。”

这就解释了为什么很多团队在面对一个简单的 CRUD 业务或者中等并发的微服务时，会毫不犹豫地引入极高门槛的语言（比如有着严苛借用检查器的 Rust）或是过度设计的服务网格。

因为“复杂，让人觉得高级”。

但结果是什么？

业务逻辑被切割得支离破碎，新员工入职需要花费两三个月才能看懂生命周期和指针所有权，团队的迭代速度断崖式下跌。你以为你在优化系统的性能，实际上，你在制造一场长期的维护灾难。在这个过程中，你消耗了大量的公司预算，仅仅是为了解决那些“想象中的未来问题”。

记住架构设计的第一法则：复杂性是优秀软件的死敌。

你的 99% 代码根本不需要瞎折腾

既然复杂性是死敌，那性能问题怎么办？难道我们就任由 GC 导致程序卡顿吗？

这时候，前 Tailscale CTO David Crawshaw 抛出了一个极具颠覆性的观点。他指出，整个行业现在正把海量的资源倾注到像 Rust 这样没有 GC 的程序中，但大家忽略了一个极其残酷的统计学事实：

“Almost all your code paths are cold and GC is net positive. 1% of your code is performance sensitive. Don’t create GC pressure there.” （你几乎所有的代码路径都是‘冷’的，在这些地方 GC 带来了纯粹的正向收益。只有 1% 的代码对性能真正敏感。你只需要不在那 1% 的地方制造 GC 压力就行了。）

什么是“冷代码”？

配置解析、路由分发、错误处理、数据库连接初始化、日志记录……在一个庞大的工程中，这部分代码占据了 99% 的体积。它们对微秒级的延迟根本不敏感。

对于这 99% 的代码，使用 Go、Java 甚至 OCaml 这样带有Full runtime GC的语言，是巨大的恩赐。GC 解放了程序员的大脑，让你不需要像写 C/C++ 或 Rust 那样，在写每一行代码时还要在脑海里进行“部分编译时规划（Partial compile-time planner）”。它让你可以把全部精力聚焦在“业务逻辑”本身。

人类解决复杂问题的能力，在不被内存分配分心时，才能发挥到极致。

为了那 1% 真正需要榨干 CPU 周期的核心逻辑，去强迫整个团队在剩下 99% 的冷代码中也要与内存所有权作斗争，这在商业 ROI（投资回报率）上是极其荒谬的。

这就是所谓“不要为了 1% 的醋，去包 99% 的饺子”。

VictoriaMetrics CTO 的 1% 极简榨干指南

好，逻辑理顺了：我们决定坚持使用 Go 语言，享受它极高的开发效率和并发优势。但我们确实遇到了那 1% 的核心瓶颈——比如高频交易的核心撮合引擎、时序数据库的底层写入循环。这部分代码极其吃 CPU，且 GC 带来的 STW（Stop The World）让人无法忍受。

不换语言，怎么破局？

别急，让我们来看看目前世界上性能最强悍的开源时序数据库之一：VictoriaMetrics 的做法。这个数据库完全是由 Go 语言编写的，但在各项 Benchmark 性能测试中，它经常把一众 C++ 和 Rust 写的时序数据库按在地上摩擦。

它的 CTO，Aliaksandr Valialkin 在这次讨论中，大方地分享了他“降维打击”般的优化路径。我将他的经验，结合各位大牛的讨论，为你整理成了以下三步走的“实操密码”：

放弃盲猜，用 Profiler 精准定位热路径（Hot Paths）

你永远不可能靠“直觉”找到性能瓶颈。Aliaksandr 强调，Go 语言拥有极度强大的内置 Profiler（pprof）。不要一上来就重构，先让程序跑起来，打入真实流量，然后用 pprof 精准定位出那消耗了 80% CPU 和大量内存分配的 1% “热路径”究竟在哪几个函数里。

这 1% 的代码，代码量往往极小，寻找它们并不困难。

在热路径中“完全移除”内存分配（Zero Allocation）

这是 Go 性能优化的核心灵魂。Aliaksandr 的原话是：“This is how I optimize programs written in Go – by removing memory allocations from hot paths…”。

只要你在热路径中不产生新的对象（不触发 malloc 和堆分配），垃圾回收器（GC）就根本不会被唤醒。没有分配，就没有垃圾；没有垃圾，就没有 GC 压力和停顿。

开启“逃生舱”：使用预分配与 Arena 机制

既然热路径不能分配新内存，那需要处理海量数据怎么办？大佬们给出了三种在 Go 中模拟底层语言内存管理的“逃生手段”：

• 预分配大块内存（Pre-allocations）：
  正如 David Crawshaw 所举的例子，你可以在 Go 中一次性分配一个巨大的数组，比如：var x = make([]struct{…}, 1e6)。
  这只产生一次大分配，然后你完全可以利用自己的算法，在这个预先分配好的内存块中进行指针的滑动和复用。对于 GC 来说，这只是一个单一的连续指针，GC 扫描它的成本极低，既能实现高并发，又极大地降低了 CPU 消耗。

• 对象池机制（sync.Pool）：
  对于频繁创建和销毁的小对象，不要让它们落入 GC 的魔爪。利用 sync.Pool 将它们缓存起来，反复复用。

• 请求作用域内存竞技场（Arenas）：
  Aliaksandr 提到了在处理网络请求时极其高效的 Arena 概念。在这个模式下，与单次 Request 相关的所有小对象分配，都在一个预先分配好的大块 Arena 中进行。当请求结束时，不需要逐个去释放对象，而是直接清空（free）整个 Arena。这几乎达到了和 Rust 一样零开销的内存清理效果，但代码写起来依然是熟悉的 Go 语法。

对 99% 的代码保持克制

当你在那 1% 的热路径里用尽了上述像 C 语言一样的“脏活累活”后，请立刻停手。

让程序剩下的 99% 保持最地道（Idiomatic）、最简单、最具可读性的 Go 代码。让 GC 去接管它们。

你会神奇地发现：你的程序不仅拥有了媲美 C++/Rust 的极致性能，同时你的团队依然保持着原本极高的业务迭代速度。

小结——顶级工程师与普通码农的终极分水岭

回顾这几位大佬的讨论，其实核心只指向了一个词：克制（Restraint）。

普通工程师总是试图寻找一种“银弹”——希望换一种时髦的语言，就能一劳永逸地解决架构、性能和内存安全的所有问题。他们沉迷于构建极其复杂的抽象体系，试图用技术上的炫技来掩盖业务上的平庸。

而真正顶级的架构师，深知商业的本质和团队运作的规律。他们懂得：

1. 好的设计，就是当你不能再拿走任何东西的时候。 （正如评论区一位开发者所说：Good design is when you keep taking away things until you cannot take away any more.）
2. 永远不要在全局引入复杂性。 遇到性能问题，先用监控定位，然后把性能敏感的那 1% 的代码隔离出来，在这个小黑盒子里用最极客的方式优化，最后把它严丝合缝地封装好。
3. 拥抱不完美但高效的工具。 不要嫌弃 GC，懂得如何与 GC 和谐共处，才是真正的大师。

如果下次你的团队里，再有人因为某个接口慢了 10 毫秒，就嚷嚷着要用 Rust 把整个几十万行的后端服务重写时，请把这篇文章甩到他的脸上。

告诉他：“去把 pprof 打开，把那 1% 循环里的临时变量给我复用了，然后早点下班回家。”

资料链接：

• https://x.com/valyala/status/2055725885035045234
• https://x.com/stewartlynch8/status/2055322205563617516
• https://x.com/davidcrawshaw/status/2055288855792955511

今日互动探讨：

在你的职业生涯中，是否经历过为了追求所谓的“极致性能”或“极客审美”，而导致整个项目陷入“过度复杂化（Over-engineering）”灾难的时刻？或者，你在使用 Go 语言时，有什么私藏的“热路径”压榨技巧？

欢迎在评论区留言和我探讨，我们一起对抗现代软件的“过度复杂病”。 （如果你觉得这篇文章打破了你的认知，别忘了点赞转发，让更多挣扎在重构边缘的兄弟们看到！）

还在为写 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/05/10/scaling-uber-with-thuan-pham

大家好，我是Tony Bai。

在硅谷的黄金时代，曾有一家公司以一种近乎“暴力”的美学，重新定义了增长的速度。它的名字叫 Uber。

在最癫狂的岁月里，它以“周”为单位攻占新的城市，用海量的资本和补贴点燃市场，其业务增长曲线陡峭得如同悬崖峭壁。

但在这场增长的狂欢之下，是一套摇摇欲坠、濒临崩溃的技术系统。

2013 年，当 Tuan Pham（后来被称为 Uber 的“救火队长”）加入时，这家拥有 40 名工程师的公司，系统每周都会崩溃数次。而他面临的第一个挑战，就是公司的核心派单系统，只剩下 5 个月的寿命。

近日，这位传奇 CTO 接受了一次深度访谈。他不仅首次揭秘了当年与创始人 Travis Kalanick (以下称TK) 长达 30 小时的“魔鬼面试”，更详细复盘了 Uber 是如何在失控的边缘，被迫走上那条被全网群嘲、却又别无选择的 “5000 微服务” 之路。

今天，就让我们跟随 Tuan 的视角，重返那个硝烟弥漫的战场。

从船民到 MIT：一段关于生存的开端

Tuan Pham 的人生开局，堪称地狱模式。

他出生于越南，是战争的亲历者。1975 年后，由于家庭背景，他和家人被迫成为“越南船民”，挤在破旧的渔船上，冒着不足 50% 的生还率，在深夜逃离故土。

在海上漂泊了四天三夜，躲过风暴和海盗，他们最终在马来西亚登陆，却又被拖回大海，最终被印尼的一个荒岛收留。

一年后，他们以难民身份来到美国。身无分文，不懂英语，第一套衣服来自教堂的捐赠衣橱。

“生存”，是刻在他骨子里的第一性原理。

和很多技术天才一样，Tuan 在数学上展现了过人的天赋。高中时，他靠着一台有两个软盘的 IBM PC 自学了编程，甚至用脚本语言帮政府机构把需要 3 周才能完成的财务对账工作，压缩到了 3 小时。

凭借着优异的成绩和推荐信，他被 MIT 录取，正式开启了他的计算机科学之旅。

血泪的教训：两场失败，塑造了 Uber 的基因

在加入 Uber 之前，Tuan 的职业生涯并非一帆风顺。但正是这些宝贵的“失败”，让他积累了足以驾驭 Uber 这头巨兽的认知。

第一场失败，在 SGI（硅谷图形公司）。

上世纪 90 年代，他参与了一个极其超前的项目——交互式电视。在那个连手机和互联网都还没普及的年代，他们已经实现了“视频点播、在线购物”。斯皮尔伯格、迈克尔·杰克逊都来参观过。但这个项目最终惨败，因为机顶盒的成本高达 4.5 万美元。这让他得到一条教训：光有伟大的技术没用，你必须在正确的时间、以正确的价格，出现在正确的市场。

第二场失败，在 NetGravity（一家互联网广告公司）。

他们发明了动态广告系统，并成功上市。但另一家比他们晚成立的公司，靠着更轻量的“广告服务（Ad Service）”模式，野蛮生长，最终被 Google 收购。而他们，因为董事会要求“优先盈利”，错失了市场。这让他得到了另外一条教训：当市场窗口期出现时，增长速度压倒一切，哪怕是以亏损为代价。

这两条从真金白银和血泪中总结出的铁律，仿佛就是为日后的 Uber 量身定制的。

30小时的“魔鬼面试”：与 TK 的灵魂拷问

离开 VMware 后，Tuan 并未主动寻找工作。是 Benchmark 的传奇投资人 Bill Gurley（也是 Uber 的早期投资人）找到了他。Bill Gurley 认识 Tuan，源于十几年前那家失败的广告公司。

Tuan 在访谈中反复强调一个观点：

“我从不刻意经营人脉。你只需要把你手头的每一份工作做到极致，真诚地对待你身边的每一个人。随着时间推移，你的声誉会为你打开所有的大门。”

当他见到 Uber 的创始人 Travis Kalanick (TK) 时，一场长达 30 小时、横跨两周的马拉松式面试开始了。

TK 在白板上写下了密密麻麻的清单：从招聘开除、到代码质量、再到团队文化……他们每天 Skype 两小时，一个一个地辩论。

Tuan 回忆道，那根本不像面试，更像是两个合伙人在激烈地碰撞思想。有一次，聊到一半 TK 要赶飞机，他直接拿起电话让助理改签，然后继续辩论。

T.K. 对技术细节的痴迷，和近乎偏执的激情，让 Tuan 意识到，这是一个将技术视为公司命脉的创始人。

面试的最后，Tuan 发现，这 30 小时其实是一场“模拟工作”。TK 在用最高成本的方式，去观察当他们意见相左时，是否还能有效地沟通、并最终达成共识。

微服务之殇：我们根本不想搞 5000 个微服务！

Tuan 加入 Uber 时，公司只有 40 个工程师，但系统每周都会宕机数次。整个后端是一个巨大的单体应用，派单系统是用单线程的 Node.js 写的。为了扩容，工程师们只能不断地把程序挪到 CPU 更快的机器上（垂直扩容）。

Tuan 问团队：“如果最快的 CPU 也扛不住了怎么办？”

工程师说：“那就换一个有多颗 CPU 的机器。”

Tuan 再问：“那这些进程之间怎么共享状态？”

团队沉默了。

Tuan 迅速算出，当时最大的城市纽约，将在 5 个月后彻底冲垮派单系统的物理上限。

重写，是唯一的活路。

他只提了两个要求：1. 一个城市必须能被多台机器支撑；2. 一台机器必须能支撑多个城市。 没有新功能，只要活下去。

最终，团队在 8 月份惊险上线了新系统，暂时续上了命。

但真正的噩梦，来自那个名为 API 的巨型单体应用。随着业务的爆炸式增长（UberX 上线、新城市扩张），这个单体应用成了所有团队的瓶颈。任何一个新功能，都可能要排队等好几个团队的开发资源。

为了活下去，Tuan 和 TK 做出了那个后来被全行业“群嘲”的决定：

“任何新功能，一律不许再往单体里加！必须作为独立的服务（Microservice）去开发。”

同时，成立一个专门的团队，去把旧的单体应用一块块“拆骨”。

这个拆骨项目，代号“达尔文（Darwin）”。Tuan 苦笑道，如果时间静止，这个项目 3-6 个月就能搞定。但他们花了整整两年。

因为在他们拆解的同时，业务的增长速度比他们拆解的速度还要快！新功能被疯狂地加回到那个正在被拆的单体里。

“当你把一块代码剥离出去后，剩下的部分因为业务增长，变得比你剥离出去的还要大。我们就像在追着自己的尾巴跑。”

5000 个微服务，不是一个被精心设计出来的架构蓝图。它是在极端增长压力下，为了让几百个工程师能够并行开发、不互相阻塞，而被迫做出的“最不坏”的选择。

这是 Uber 用每年几亿美元的服务器成本，换来的开发速度。

中国速度：两个月，拿下中国市场

在 Uber 的历史上，最能体现这种“速度压倒一切”文化的，莫过于 2014 年底的“中国闪击战”。

圣诞节前，TK 宣布：新年过后，Uber 要全面进军中国。他给了 Tuan 两个月的时间，在中国本土，从零开始搭建一套完整的、物理隔离的数据中心。

Tuan 的工程团队评估后，给出的最快时间是 6 个月。他在湾区的朋友们听说后，都嘲笑他疯了：“没有 18 个月根本不可能。”

TK 不接受，最终两人“折中”到了 4 个月。

4 个月后，项目延期了。TK 很不爽。

5 个月后，项目再次延期。TK 暴怒。

Tuan 对 TK 承诺，再给一个月，但必须允许他们“分阶段上线”，而不是一次性点亮所有城市。

TK 同意了，但提了一个极其苛刻的条件：第一个上线的，必须是当时业务量最大的城市——成都。

Tuan 在访谈中回忆道，这在当时看来简直是自杀，但事后回想，这是 TK 做出的最天才的决定。

“当你把最硬的骨头啃下来之后，剩下的就全是下坡路了。整个团队的士气和信心都被拉满了。”

最终，他们真的做到了。IT 团队在两周内完成了服务器的跨国部署，软件团队在无数个通宵后，让代码在中美两地同时跑了起来。

没有人认为这能成功，但它就是成功了。 这就是 Uber 当时的魔力。

小结：AI 时代的生存法则

在访谈的最后，Tuan 聊到了如今最火热的 AI 编程。

他所在的新公司 FAIR，已经开始使用 Agent Swarm（智能体集群） 来辅助开发。他发现，顶级的工程师在使用 AI 后，产出能翻倍。

当被问及“AI 时代，如何区分优秀与平庸的工程师”时，Tuan 的回答，与他在 Uber 血战时总结出的经验如出一辙：

“好奇心、无畏、愿意尝试新事物、敢于打破常规。这些特质，在过去能让你脱颖而出，在今天，同样能让你成为驾驭 AI 的顶级玩家。平庸的人把 AI 当拐杖，而优秀的人把 AI 当作火箭推进器。”

从越南船民到硅谷之巅，Tuan Pham 的一生，就是一部关于“在混乱中寻找秩序，在极限压力下野蛮生长”的史诗。

Uber 的故事或许不可复制，但它留给我们的思考，远未结束。

在技术的世界里，从来没有完美的架构，只有与业务增长阶段相匹配的、充满妥协与权衡的草台班子。

而我们作为工程师的终极使命，就是在这个草台班子上，用最快的速度，把它搭成别人眼中坚不可摧的罗马。

今日互动探讨：

看完 Uber 的故事，你觉得在你的公司里，是应该优先选择“技术正确”的完美架构，还是“能快速上线”的野路子？你对微服务和单体架构有什么切身体会？

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

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

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

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

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

• 想写出更地道、更健壮的Go代码，却总在细节上踩坑？
• 渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
• 想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！ 现在就加入，让你的Go技能再上一个新台阶！

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

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/01/open-source-civil-war-bun-founder-predicts-ban-on-human-contributions

大家好，我是Tony Bai。

过去的一年，AI 编程的浪潮席卷了整个技术圈。但在这片繁荣之下，一场关于“开源精神与 AI 伦理”的深刻裂痕，正在悄然扩大。

就在前几天，这场裂痕，以一种极其戏剧性的方式，被彻底引爆了。

事件的导火索，来自当红 JavaScript 运行时 Bun 的一则看似平平无奇的技术更新：Bun 团队 fork 了 Zig 语言的编译器，通过引入并行分析等优化，将自己的调试构建速度提升了 4 倍。

但真正引爆全网的，是 Bun 官方账号在 X 平台发布的一条补充说明：

“我们目前不打算将这些改进提交回上游（Zig 社区），因为 Zig 有一条严格的禁令：禁止任何由 LLM（大模型）创作的贡献。”

这条推文，像一根火柴，瞬间点燃了整个开源社区的火药桶。

Bun 的创始人 Jarred Sumner 更是亲自下场，抛出了一个极其激进、甚至有些“疯狂”的预言：

“我预感开源社区会走向另一个极端：未来将不再允许人类贡献代码。人类写的垃圾代码（Slop），将成为 2025 和 2026 年的怀旧遗物。”

一边是 Zig 社区对 AI 的严防死守，另一边是 Bun 创始人对“纯 AI 开发”的狂热鼓吹。这场突如其来的“内战”，引来了包括网景创始人 Marc Andreessen、开源运动领袖 Eric S. Raymond 等一众硅谷大佬的围观和站队。

今天，我们就来复盘这场神仙打架，看看在这场关于“Pro-AI”与“Anti-AI”的论战背后，到底隐藏着怎样的技术哲学、利益博弈与生存法则。

分裂的开端：当“贡献”的定义被改写

Zig 社区为什么要禁止 AI 贡献？

这背后，是传统开源精神对“贡献”二字的捍卫。在他们看来，一个 Pull Request 不仅仅是一段代码，它更代表了贡献者投入的心血、思考、以及对社区文化的认同。

而由 AI 生成的、未经深入理解的“垃圾代码（Slop）”，正在无情地摧毁这种信任契约，将 Code Review 的沉重负担，转嫁给那些用爱发电的维护者。

但 Bun 的创始人 Jarred Sumner 显然不这么认为。他坚信，AI 将彻底重塑生产关系。

在他的设想中，未来的开源协作将是这样的：

“和人类不同，AI 会严格遵守你的代码风格指南，并在几分钟内完成你提出的每一个修改。它们会编写详尽的测试和文档。它们会研究竞争对手的实现方案。它们会不知疲倦地进行迭代，直到通过所有第三方的一致性测试。”

在这场辩论中，著名浏览器 Ladybird 的作者 Andreas Kling，给出了一个更宏大、也更令人不安的预言：

“我的猜测是，开源社区将分裂成两个阵营：Pro-AI（亲 AI）和 Anti-AI（反 AI）。
1. Pro-AI 阵营的项目，将以惊人的速度超越 Anti-AI 阵营。
2. 那些被 Anti-AI 项目拖慢了脚步的 Pro-AI 开发者，最终会选择 fork 或者重写这些项目。”

Bun 对 Zig 的这次 fork，似乎正是这个预言的第一次应验。

神仙打架：硅谷大佬的站队与嘲讽

这场论战迅速升级，引来了各路神仙的围观。

传奇投资人、a16z 联合创始人 Marc Andreessen，用一个简单的“+1”表情，旗帜鲜明地站在了 Jarred Sumner 的“未来无人类”阵营。

开源运动的“教父级”人物、《大教堂与集市》的作者 Eric S. Raymond，也对“Anti-AI”派发起了无情的嘲讽：

“我发现了一个规律。在开源社区里，那些反对 AI 的人，和之前被‘Woke Mind Virus’（觉醒文化病毒）完全俘获的，是同一批人。他们是白痴。 这是我作为创始人的肺腑之言。”

当然，也有大量的资深开发者对 Jarred 的观点嗤之以鼻。

一名游戏引擎开发者直接发问：

“在保持高质量标准的前提下，‘超越’的证据在哪里？还是说你认为质量对于客户来说已经不重要了？”

Gary Marcus（著名 AI 评论家）更是引用了一句名言来讽刺 AI 的不可靠：

“当你不了解一个主题时，AI 看起来最令人印象深刻。一旦你对某个领域了如指掌，你就会发现它说的全是废话。”

AI 时代的“阶级固化”：谁在定义“高质量”？

这场争论的背后，其实隐藏着一个更深层次的权力问题：当 AI 能够生成 90% 的代码时，谁来定义剩下的 10% 的“质量”？

Bun 创始人 Jarred Sumner 的答案是：Agent。

他认为，未来的代码质量将由自动化的测试、严格的类型系统和不知疲倦的 Agent 来保证，人类的角色将被无限削弱。

但反对者认为，这是一种极其天真的“技术幻想”。

Darren Shepherd（Rancher 联合创始人）在评论中指出：

“所有迹象都表明，未来由 AI 辅助生成的代码，其质量将远高于纯人类编写和维护的代码。”

这场辩论最终走向了一个无法调和的哲学分歧：

• Pro-AI 派相信，通过强大的 Harness（驾驭系统）和自动化评估（Evals），AI 生成代码的质量和速度，将很快超越人类的上限。
• Anti-AI 派则坚信，软件工程中那些最宝贵的特质——品味、洞察力、对复杂系统的直觉——是 AI 永远无法模拟的。而放任 AI 生产“看似合理”的代码，最终只会导致整个行业的“审美降级”和“智力衰退”。

生存法则：在“内战”中，我们该如何站队？

作为身处一线的工程师，我们不必陷入这种非黑即白的“信仰之争”。

无论是 Pro-AI 还是 Anti-AI，在这场混乱的辩论中，我们依然能找到几条极其清晰的生存法则。

第一，警惕“立场先行”，回归“工程现实”。

无论是 Bun 还是 Zig，他们的选择，都是基于自身项目所处的特定工程阶段和社区文化。

• Zig：作为一门底层语言，它追求的是极致的稳定性和可预测性。任何由黑盒 AI 生成的、可能引入未知风险的代码，都是不可接受的。
• Bun：作为一门上层应用的运行时，它追求的是极致的迭代速度和生态兼容性。为此，他们愿意拥抱 AI，甚至不惜与上游社区决裂。

你的项目，更像 Zig，还是更像 Bun？这个问题，比单纯地喊“AI 万岁”或“AI 垃圾”要有意义得多。

第二，不要成为“AI 的传声筒”，要做“AI 的驾驭者”。

即使在 Pro-AI 阵营内部，大佬们也普遍承认一个事实：无脑地让 AI “Vibe-Coding”，结果就是灾难。

你需要为 AI 构建强大的“护栏（Guardrails）”，你需要设计精密的“评测体系（Evals）”，你需要像一个真正的架构师一样，去定义系统的边界和验收标准。

AI 正在把开发者的能力，从“写代码”，向上推到“设计系统”和“定义规则”。

第三，拥抱“阵营分裂”的未来。

Andreas Kling 的预言，大概率会成为现实。

未来的开源世界，将不再是一个“其乐融融”的大家庭。它会分裂成：
* Anti-AI 社区：坚守人类智慧的最后防线，可能会变得更加封闭、审核更严，成为“小而美”的精英俱乐部。
* Pro-AI 社区：以惊人的速度进行迭代和演进，可能会涌现出大量创新，但同时也伴随着巨大的混乱和泡沫。

作为开发者，你需要提前思考：你的价值观和职业规划，更适合哪一个“宇宙”？

小结：一场没有回头路的豪赌

Bun 与 Zig 的这次“决裂”，可能只是未来十年开源社区大分裂的第一次预演。

当 Jarred Sumner 喊出“未来将禁止人类贡献”时，他开启了一场极其危险的“社会实验”。这背后，是资本对“效率”的无限渴求，是对“开源社区协作成本”的极度不耐烦。

而 Zig 社区的坚守，则是对“人类智慧不可替代性”的最后捍卫。

这场战争，没有对错，只有选择。

但无论你选择哪条路，请记住：工具终将过时，但工程的智慧与审美的品味，永不褪色。

资料链接：https://x.com/i/trending/2048470411793563936

今日互动探讨：

你更认同 Bun 的“Pro-AI”哲学，还是 Zig 的“Anti-AI”哲学？在你的日常工作中，是否也曾因为“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. 版权所有.