本文永久链接 – 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/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/03/28/ai-engineer-gpu-introduction-course

大家好，我是Tony Bai。

就在最近，科技界发生了一件极其戏剧性的事情。本周三美股开盘，全球存储产业巨头——美光、西部数据、希捷的股价遭遇了“黑色时刻”，普遍明显下跌（3%~6%）。

引发这场资本市场大地震的，不是什么贸易战，也不是财报暴雷，而仅仅是谷歌（Google Research）发布的一篇技术论文：《TurboQuant: Redefining AI efficiency with extreme compression》。

这篇论文宣称，他们发明了一种极端的压缩算法，能在几乎零损耗的情况下，将大模型推理时的 KV 缓存（KV Cache）暴降 6 倍，并让注意力机制的计算速度狂飙 8 倍！

很多传统的后端程序员看到这条新闻，可能一头雾水：

• 什么是 KV Cache？
• 为什么压缩了一个叫 KV Cache 的东西，就能让卖物理内存芯片的巨头们吓得半死？

在这些雾水和疑惑背后，隐藏着 AI 大模型时代最核心、也最残酷的技术真相：内存墙（Memory Wall）。

AI 时代的底色：算力过剩，访存为王

在传统的软件开发中，我们习惯了用 CPU 的思维去思考性能。我们认为程序跑得慢，是因为“计算太复杂”，我们需要更强的算力（更快的 CPU 频率）。

但在大语言模型（LLM）的世界里，逻辑变了。

大模型在生成文本时，是逐字生成（自回归）的。为了不每次都把前面说过的话重新计算一遍，模型会把之前所有上下文的内部特征（Key 和 Value 矩阵）全部保存在显存里。这份庞大的“运行记忆”，就是 KV Cache。

随着上下文越来越长（比如从 4K 飙升到 128K 甚至百万级），这份 KV Cache 会像滚雪球一样膨胀。

这就是为什么业界说：KV Cache 是大模型推理名副其实的“吞金兽”。

更要命的是，每次生成一个新的字，GPU 都必须把这份庞大的 KV Cache 从显存（HBM）完整地搬运到计算核心（SRAM）里过一遍。

这就好比你有一个世界上切菜最快的厨师（GPU 算力），但他每次切一片肉，都要跑到 10 公里外的仓库（显存）去取。厨师的手速再快也没有用，整体速度完全被运货卡车的速度（显存带宽）锁死了。

这就是困扰所有 AI 工程师的 “内存墙”。也是为什么各大公司疯狂抢购高显存、高带宽的 H100 显卡的原因。

而谷歌的 TurboQuant 之所以引发地震，正是因为它通过极致的数学算法（极坐标变换 + 1-bit 残差误差校验），直接在软件层面把搬运的数据量压缩了 6 倍！这意味着，同样的硬件，现在能跑更长的上下文、支持更高的并发。存储巨头们能不慌吗？

为什么后端工程师必须懂 GPU？

你可以说：“我只是个调 OpenAI 兼容API 的后端工程师，硬件底层关我什么事？”

在过去的一年里，这是行得通的。但随着开源模型（如 GLM、Qwen、MiniMax、DeepSeek、KIMI等）的全面爆发，以及企业对数据隐私、成本控制的极致追求，“本地化/私有化部署大模型” 也正在成为一些中大型企业的刚需。

当你作为架构师或后端主力，被老板要求把一个 70B 的大模型部署到公司的服务器上时，真正的挑战才刚刚开始：

• 面对 OOM（显存溢出），你该如何调整参数？
• 并发量稍微一高，首字延迟（TTFT）就卡到几十秒，你该怎么排查？
• 采购硬件时，你是买 8 张便宜的 RTX 4090，还是花高价租用带 NVLink 的 A100/H100？
• 你该如何向团队解释引入 vLLM、FlashAttention 和 INT8/FP8 量化的必要性？

如果你把 GPU 当成一个“跑得更快的 CPU”来用，你将会在上述每一个问题上栽大跟头。

你需要建立一套全新的“硬件心智模型”，这也是我编写这门《AI 工程师的 GPU 入门课：从硬件视角看大模型推理》微专栏的主要目标。

这门微专栏将教你什么？

市面上关于 GPU 和 CUDA 的教程很多，但大多是教你如何写出复杂的 C++ 图形渲染代码，或者如何在学术上推导矩阵乘法。

这门微专栏与众不同。它是专为后端/软件工程师打造的“白盒化” GPU 入门课程。

我们不教图形渲染，不深究复杂的 C++ 语法。我们将直接切入大模型推理的痛点，带你一步步从物理架构走到前沿的 AI 工程技术。

• 如果你想吃透热门技术： 我们将为你讲透 FlashAttention、PagedAttention (vLLM)、模型量化背后的物理原理。你会发现，这些看似高深的技术，本质上都是在和“内存墙”做斗争。
• 如果你追求实战落地： 我们不仅教你看懂硬件，还会教你用 Profiling 工具（性能分析器）像侦探一样排查慢查询；作为加餐，我们甚至会教你如何用纯 Go 语言（Zero CGO）直接点火发射 CUDA 内核！

课程目录全景图

为了让你对这趟旅程有一个清晰的预期，以下是本专栏的完整地图：

第一阶段：硬件心智模型
* 第 01 讲 | 硬件解剖：为什么 CPU 是“法拉利”，GPU 是“大巴车”？（含 5090 vs H100 对比）
* 第 02 讲 | 内存金字塔：HBM、SRAM 与不可逾越的“内存墙”

第二阶段：编程模型与工具链
* 第 03 讲 | CUDA 编程模型：指挥“千军万马”的线程艺术
* 第 04 讲 | 性能侦探：性能侦探：拆解 Hello World Kernel 与 Profiling 实战

第三阶段：AI 工程进阶
* 第 05 讲 | 显存管理革命：从 KV Cache 到 PagedAttention (vLLM)
* 第 06 讲 | 算子融合魔法：FlashAttention 的底层原理
* 第 07 讲 | 精度与量化：精度与量化：INT8/FP8 为什么既快又省？
* 第 08 讲 | 分布式推理：Tensor Parallelism (TP) 与通信墙
* 第 09 讲 | 终极指南：如何科学计算 AI 算力需求与硬件选型？

特别加餐：Gopher 的专属浪漫
* 第 10 讲 | 加餐：Go 语言的 GPU 编程——Gopher 的逆袭

小结

在算力的装备竞赛里，最锋利的武器未必是更昂贵的芯片，而是深刻理解软硬件边界的人。

正如谷歌 TurboQuant 证明的那样：懂底层的工程师，只需改写一行底层逻辑，就可能撬动万亿级别的市场价值。

算力时代，不要只做“调包”的局外人。

准备好跨越 CPU 的舒适区，跟我一起深入算力的硅基心脏了吗？

点击这里或扫描下方二维码，开启你的GPU与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/01/11/21-lessons-from-google-engineer

大家好，我是Tony Bai。

“当我 14 年前加入 Google 时，我以为这份工作就是写出优秀的代码……我只说对了一部分。我待得越久，就越意识到，那些真正茁壮成长的工程师，不一定是最好的程序员——他们是那些懂得如何驾驭代码周围一切的人：人、政治、协同和模糊性。”

这段话，出自 Google 资深工程师 Addy Osmani 的一篇深刻反思——《在 Google 14 年的 21 条经验》。这篇文章，如同淬炼了 14 年的智慧结晶，几乎没有谈论任何具体的技术栈，却精准地描绘出了一位卓越工程师的成长画像。

这 21 条“法则”，并非关于某种转瞬即逝的技术，而是关于那些在项目、团队、公司之间反复出现的永恒模式。它们不是一场与外部世界的战争，而是一场关于自我提升的漫长“修炼”。这是一份珍贵的“心法”，能帮助我们在这场修炼之路上，走得更远、更稳。本文将为你逐一解读。

1. 最好的工程师痴迷于解决“用户问题”，而非“技术问题”

这是工程师“修炼”之路的第一心法：放下执念。

放下对特定技术的迷恋，将自我从“工具的使用者”升华为“问题的解决者”。

“用户痴迷”意味着走出 IDE，去阅读支持工单，去和真实用户交谈，去观察他们如何在你的产品中挣扎。

当你真正理解了用户的“痛”，你往往会发现，那个最优雅的解决方案，远比你最初设想的任何复杂技术都要简单。

2. 做到正确很廉价，而“一起”做到正确才是真正的修行

你可以在每一次技术辩论中都“赢”，但最终输掉整个项目。

真正的“修为”，不在于证明自己正确，而在于创造一个安全的空间，让团队能够共同对问题达成一致，并对自己的确定性保持怀疑。

记住：“观点强硬，但立场松动 (Strong opinions, weakly held)。”

3. 偏爱行动。交付。你可以修改一个糟糕的页面，但无法修改一个空白的页面

对完美的追求是麻痹剂，是“心魔”。

完美的架构不会在纯粹的冥想中诞生，它诞生于与现实的接触。

先做出来，再做对，再做得更好。

交付那个让你感到“有点尴尬”的 MVP。

一个粗糙的原型所能带来的真实反馈，远超一个月闭门造车的理论辩论。

4. 清晰即资深，聪明是开销

编写“聪明”的代码，是工程师证明能力的本能。

但真正的软件工程，是在时间和团队协作的维度上展开的。

清晰性不是一种风格偏好，而是一种运营风险的降低。

你的代码，是一份写给未来某个凌晨三点需要维护它的陌生人的“战略备忘录”。

资深的工程师，早已学会在他们的“修炼”中，用清晰性去交换那份无关紧要的“聪明”。

5. 新奇是一笔贷款，你将在故障、招聘和认知开销中偿还

像一个预算有限的组织一样，谨慎地对待你的“创新代币”。

只在你拥有独特优势的地方进行创新，其他所有事情，都应该默认选择“无聊”的技术，因为“无聊”意味着失败模式是已知的。

记住，“最好的工具”，常常是那个“在最多场景下最不坏的工具”。

6. 你的代码不会为你代言，人会

以为“好的工作会自己说话”，是工程师“修炼”生涯早期最大的错觉。

代码静静地躺在仓库里，它不会在晋升会议上为你辩护。

你需要将你的工作和价值，以一种可被他人理解和传播的方式呈现出来：写清晰的文档、做有影响力的分享、主动沟通你的成果。

7. 最好的代码，是那些你从未写下的代码

工程文化崇尚创造，但删除代码往往比增加代码更能改善一个系统。

你没有写下的每一行代码，都是你永远不必去调试、维护或解释的一行代码。

在动手构建之前，请先用“无为”的智慧拷问自己：“如果我们就是……不这么做，会发生什么？”

8. 在规模化面前，即使你的 Bug 也有用户

当用户足够多时，你的系统的每一个可观测行为，无论你是否承诺过，都会成为一种事实上的依赖。

有人正在爬取你的 API，有人正在自动化你的“怪癖”，有人正在缓存你的 Bug。

这意味着，兼容性本身就是一种产品。你不能再将修复 Bug 视为“维护”，将开发新功能视为“真正的工作”。

9. 大多数“慢”团队，其实是“失调”的团队

当项目拖延时，我们的本能是归咎于执行力：人手不够、技术不行、工作不努力。

但真正的瓶颈，往往在于协同失败 (Alignment Failure)——团队在做错误的事情，或者以不兼容的方式在做正确的事情。

资深工程师会花费更多时间去澄清方向、接口和优先级，而不是单纯地“更快地写代码”。

10. 关注你能控制的，忽略你不能的

在大型组织中，组织架构调整、管理层决策、市场变化……无数变量都在你的控制范围之外。

为这些事情焦虑，是在浪费你宝贵的精力。

卓越的工程师，会战略性地专注于他们的“影响圈”：你能控制你代码的质量，你能控制你如何响应变化，你能控制你学到了什么。

这是一种专注的“禅定”。

11. 抽象并未消除复杂性，只是将其转移到了你 on-call 的那一天

每一个抽象，都是一次“我未来不需要理解其底层”的赌博。

有时你会赌赢，但抽象总会泄露。

资深工程师之所以坚持学习底层知识，并非出于怀旧，而是出于对“凌晨三点，当你独自面对一个失效的抽象时”的敬畏。

12. 写作倒逼清晰。想学得更快，就去教别人

当你试图向他人解释一个概念时——无论是在文档中、演讲中，还是 Code Review 的评论里——你会立刻发现自己理解上的盲点。

把一个东西教给别人，本质上是在调试你自己的心智模型。

这是最高效的“利己”的学习法门。

13. 那些让其他工作成为可能的工作，无价且无形

“胶水工作”——文档、新人引导、跨团队协调、流程改进——至关重要。

但如果你无意识地、仅仅出于“乐于助人”去做这些事，它们会吞噬你的时间，让你偏离技术主航道。

诀窍在于，有意识地去做，为它设定时间盒，将它转化为文档、模板、自动化等可见的成果，让它成为你明确的影响力，而非模糊的“性格特质”。

14. 如果你赢得了每一次辩论，你可能正在积累无声的抵制

当你“赢”得太轻松时，通常意味着事情不对劲了。

人们不再与你争论，不是因为你彻底说服了他们，而是因为他们已经放弃了尝试。

而这份未解的分歧，将会在未来的执行层面，以“神秘的阻力”的形式爆发出来。

真正的协同，需要你真正去理解他人，并有时公开地改变自己的想法。

15. 当一个指标成为目标时，它便不再是一个好的指标

古德哈特定律的经典再现。

人类会为了被测量的东西而优化。

资深的做法是，用一组成对的指标来响应管理需求（例如，速度 vs. 质量），并坚持解读趋势，而非崇拜某个具体的阈值。

16. 承认“我不知道”，比假装知道能创造更多安全感

当一个领导者或资深工程师坦诚自己的不确定性时，他实际上是在给予整个团队“提问”和“犯错”的许可。

这会创造一种心理安全的环境，让问题在爆炸前被暴露出来。

反之，一个“永远正确”的领导者，只会培养出一群沉默的下属和一堆隐藏的地雷。

17. 你的人脉，比你做过的任何一份工作都更长久

职业生涯早期，我们容易专注于工作本身而忽略人际交往。

这是一个巨大的错误。

那些在公司内外投资于人际关系的同事，在数十年后，会收获巨大的回报。

你的工作不是永恒的，但你建立的信任是。

18. 大多数性能的胜利，源于“移除工作”，而非“增加聪明”

当系统变慢时，我们的本能是增加缓存、并行处理、或者换用更聪明的算法。

但更具影响力的胜利，往往来自于问一个更根本的问题：“我们正在计算的这些东西，真的有必要吗？”

删除不必要的工作，远比把必要的工作做得更快要有效得多。

最快的代码，是那段从未运行过的代码。

19. 流程的存在是为了减少不确定性，而不是为了制造文书工作

最好的流程，能让协作更容易，让失败的代价更便宜。

而最坏的流程，是“官僚主义戏剧”——它的存在不是为了帮助，而是在出问题时用来甩锅。

如果你无法解释一个流程如何降低风险或增加清晰度，那它很可能就是纯粹的开销。

20. 最终，时间会比金钱更宝贵。请据此行事

职业生涯早期，你用时间换金钱。

但在某个临界点之后，这个公式会反转。

时间是唯一不可再生的资源。

答案不是“不要努力工作”，而是“清楚你在交易什么，并深思熟虑地做出交易。”

21. 没有捷径，但有复利

专业知识，来自于经年累月的刻意练习。

但这里有希望的部分：学习是具有复利效应的。

你建立的每一个心智模型，你总结的每一条经验教训，都会成为你未来解决更复杂问题的“可复用原语”。

将你的职业生涯视为复利投资，而非一张张彩票。

小结：修炼的核心永远是人

Addy Osmani 的 21 条经验，最终可以归结为几个核心思想：保持好奇，保持谦逊，并永远记住，修炼的核心是人——你为之构建的用户，以及与你一同构建的队友。

对于我们工程师而言，这意味着，职业生涯的成长，是一场双螺旋式的攀升。

技术能力的“硬实力”是我们的根基，但决定我们最终能达到何种“境界”的，往往是沟通、协作、权衡、同理心这些看似“软”的、关于人的智慧。

这场“代码之外的修炼”，道阻且长，但行则将至。

资料链接：https://addyo.substack.com/p/21-lessons-from-14-years-at-google

你的“第22条”法则

读完这21条法则，相信你一定心有戚戚焉。在你自己的职业生涯中，是否有哪一条“生存法则”是你用惨痛教训换来的？或者，你觉得还有什么重要的经验是这21条没有覆盖到的？

欢迎在评论区分享你的独家心法！ 让我们一起汇聚更多智慧。

如果这篇文章给了你新的启发，别忘了点个【赞】和【在看】，并转发给身边正在迷茫的工程师朋友，也许这就是他破局的关键！

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

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

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

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

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

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

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

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

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

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/01/10/go-dropped-from-7th-to-16th-in-one-year

大家好，我是Tony Bai。

新年伊始，TIOBE 发布了最新的编程语言排行榜。当我满怀期待地去寻找 Go 的身影时，差点以为自己眼花了：

Go 居然从去年的第 7 名，断崖式下跌到了第 16 名！ 占比跌幅高达 1.37%，在这个榜单上几乎是“崩盘”级别的表现。

这是什么概念？这意味着在 TIOBE 的统计里，Go 现在的流行度还不如 Delphi/Object Pascal（第 9 名）和 Visual Basic（第 7 名）。

这就很离谱了。任何一个在 2025 年还在写代码的人，都不会觉得 Go 的生态已经萎缩到这种地步。

是 Go真的凉了吗？还是 TIOBE 的算法“疯”了？

平行宇宙：稳如泰山的 Go

为了验证我的认知是否出现了偏差，我特意查阅了 2025 年其他的权威榜单：

• GitHub Octoverse：Go 依然稳居前 10，云原生领域的统治地位不可撼动。
• Stack Overflow 开发者调查：Go 在“最想学习的语言”和“薪资最高语言”中依然名列前茅。
• JetBrains 生态报告：Go 开发者的数量在持续稳步增长，并登顶“最受期待”榜首，没有任何衰退迹象。

全世界都觉得 Go 挺好，唯独 TIOBE 觉得 Go 要完。这种巨大的反差，逼得我不得不去扒一扒 TIOBE 的底裤——它的排名算法到底是怎么算的？

扒皮 TIOBE：一个过时的算法游戏

根据 TIOBE 官方公布的定义文档，它的算法极其简单粗暴，甚至可以说——在 2026 年显得有些可笑。

它的核心逻辑只有一个公式：

在 25 个主流搜索引擎中，搜索 +” programming”，统计返回的页面数量。

就是这么简单。没有什么复杂的加权，没有什么开发者活跃度分析，就是数一数搜索引擎告诉你“有多少个网页提到了这个语言”。

这种算法在 20 年前或许有效，但在今天，它成为了导致 Go 排名暴跌的元凶。

元凶一：AI 杀死了“搜索结果页”

2025 年最大的变化是什么？是 AI Search。

当我们遇到编程问题时，越来越多的人不再去 Google 翻阅那几百万个搜索结果页面，而是直接问 ChatGPT、Claude 或者 DeepSeek。
TIOBE 明确表示：ChatGPT 等 AI 工具不被纳入统计，因为它们没有“返回结果数量”的计数器。

这就导致了一个悖论：越是热门、现代的语言（如 Go、Python(得益于AI模型训练与应用开发)），其用户群体越年轻、越拥抱新技术，也就越倾向于用 AI 解决问题。 这直接导致了这些语言在传统搜索引擎中的“查询热度”和“新内容生成量”出现显著下降。

相比之下，那些老旧的语言（如 VB、Delphi），其用户群体相对固化，且维护遗留系统时更多依赖传统的文档和论坛搜索，因此受到的冲击较小，甚至在对比中显得“逆势上扬”。

注：Python的占比相对于2025.01也下降了0.68%。

元凶二：Go 的名字太“吃亏”了

TIOBE 的核心搜索查询是 +” programming”。

这对于 Python、Java 这种专有名词来说问题不大。但对于 Go 来说，这就是个灾难。

• 通用词的悲剧：Go 是一个极其通用的英语单词。为了过滤掉“去（go）”的含义，TIOBE 必须强制加上 “programming” 后缀。
• 搜索习惯的改变：但在 2025 年，开发者还会搜 “Go programming” 吗？不会了。大家搜的是 “Go generics”、”Golang k8s”、”Goroutine leak”。
• 不成比例的过滤：随着搜索引擎算法日益智能，它开始更精准地理解用户意图，不再机械地匹配 “Go programming” 这个短语。这导致大量讨论 Go 技术的高质量页面（但没有显式包含该短语）被 TIOBE 的简单算法无情过滤。而像 “Python programming” 这种组合，因为 Python 本身的高辨识度，受到的影响要小得多。

元凶三：搜索引擎的“去水化”

Google 等搜索引擎在 2025 年大幅调整了算法，致力于打击 SEO 内容农场和低质量生成的页面。

Go 作为一个在云原生时代极速窜红的语言，过去几年充斥着大量的入门教程、培训班广告和搬运文章。搜索引擎的这一波“清洗”，可能不成比例地删除了大量包含 “Go programming” 关键词的低质、重复页面。

虽然页面总量少了，但生态的“干货密度”其实更高了。 然而，在 TIOBE 这种只看“数量”不看“质量”的算法眼里，这就被简单粗暴地解读为“热度暴跌”。而那些生态早已固化、鲜有新内容产生的老语言，反而躲过了这一劫。

注：以上也是笔者的主观分析，不一定与事实相符！

小结：看个乐呵就行

把 Go 排在 Visual Basic 后面，这本身就是一个笑话。

TIOBE 的这次排名暴跌，反映的不是 Go 语言的衰落，而是 TIOBE 这种基于“网页搜索量”的统计方法，在 AI 和现代互联网面前的全面崩塌。

它就像一个依然在用“收音机收听率”来衡量流行音乐热度的老人，已经无法捕捉流媒体时代的脉搏。

所以，各位 Gopher，该写代码写代码，该摸鱼摸鱼。Go 好着呢，别被这个离谱的排名吓到了。

你的“体感”排名

TIOBE 的数据确实让人啼笑皆非。在你心目中，Go 语言现在的真实热度应该排第几？你觉得还有哪个榜单能更客观地反映编程语言的现状？

欢迎在评论区晒出你的“心选榜单”，或者尽情吐槽这个离谱的排名！

如果这篇文章解开了你心中的疑惑，别忘了点个【赞】和【在看】，并转发给那些正在唱衰 Go 的朋友，打脸要快！

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

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

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

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

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

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

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

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

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

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/01/05/how-ken-thompson-developed-go-language-at-google.

大家好，我是Tony Bai。

为什么 Go 语言极其痛恨复杂的特性？为什么 Go 如此执着于编译速度？我们常说 Go 是一门“工程实用主义”的语言，它的设计哲学是“少即是多”。但你是否想过，这种近乎偏执的简洁，究竟是为了对抗什么？

这一切的答案，都藏在 2007 年 Google 内部的一场 C++ 标准委员会汇报演讲中。当图灵奖得主 Ken Thompson 发现自己竟然“看不懂”新的 C++ 特性时，一颗变革的种子就此埋下。

最近，我重温了这段 Ken Thompson（Unix 之父、Go 语言联合创始人）的珍贵访谈。在访谈中，老爷子毫无保留地讲述了 Go 语言诞生的前因后果。 故事的起点，并非某次高瞻远瞩的战略规划，而是一次“听不懂”的 C++ 技术分享，以及 Google 内部那令人绝望的 45 分钟编译时间。

本文基于 Ken Thompson 的访谈实录，带你回到那个决定性的瞬间，还原 Go 语言诞生背后的真实故事。

压死骆驼的最后一根稻草：C++ 的“新特性”

故事发生在 2007 年左右。当时，Google 内部有一位 C++ 标准委员会（ANSI C++）的代表。

有一天，这位代表刚开完标准会议回来，在 Google 内部做了一场技术分享，向大家介绍 C++ 即将引入的“新特性”（注：推测是指当时的 C++0x，即后来的 C++11 草案）。

Ken Thompson 就在台下。作为发明了 B 语言（C 语言的前身）并重写了 Unix 内核的宗师级人物，他在听完这场一小时的密集分享后，感受到的不是兴奋，而是困惑。

“这所谓的‘新东西’，在我看来比语言本身还要大。”
“那些关于指针的形式，除了指针之外还意味着其他东西……我告诉你，我没听懂。”

想象一下，连 Ken Thompson 都直言自己“没听懂” C++ 的新特性，这说明了什么？

在他看来，这些所谓的“改进”，只是在不断地堆砌复杂度。这场演讲成为了催化剂。Ken 回到办公室，找到了同样对现状不满的 Robert Griesemer 和 Rob Pike。

Ken 的不满在于语言的过度复杂，而 Rob Pike 的痛点则在于 Google 庞大的工程规模。

Google 的工程噩梦：10 行代码与 500 万行编译

当时的 Google 面临着一个前所未有的工程挑战：Monorepo（单一代码仓库）的膨胀。

Ken 在访谈中描述了一个令人窒息的场景：

“在 Google，你可以从任何源文件中引用库。你可能只写了一个 10 行的程序，但最终却需要处理 500 万行的编译量。”

这不是夸张。由于缺乏严格的依赖管理和可见性控制，一个微小的依赖引入，可能会像滚雪球一样，将底层的庞大库（如 Protocol Buffers、基础库等）全部卷入编译过程。

更糟糕的是，头文件（Header files）的包含机制导致了严重的重复劳动。

“像最简单的库，可能会被加载和检查成百上千次。”

虽然 Google 拥有当时世界上最强大的分布式编译集群（成百上千个 CPU 并行工作），虽然工程师们发明了各种缓存机制和 ifdef 技巧来避免重复包含，但物理定律是不可违背的。

编译一个简单的程序，需要等待 15 分钟，甚至 45 分钟。

Rob Pike 对此深恶痛绝。这种低效的开发循环，正在扼杀 Google 工程师的创造力。

三个火枪手与“一票否决权”

于是，在 Google 的一间办公室里，Ken Thompson、Rob Pike 和 Robert Griesemer 聚在了一起。

Ken 说出了那句改变历史的话：

“What are we going to do about it? Let’s write a language.”（我们该怎么办？让我们写个语言吧。）

这是一个完美的互补组合：

• Rob Pike：深刻理解 Google 的工程痛点（依赖地狱、构建速度、大规模协作）。
• Ken Thompson：拥有深厚的语言和编译器构建历史。
• Robert Griesemer：被称为“瑞士军刀般的语言专家”，熟悉理论上存在的所有语言特性，是团队的理论百科全书。

在设计 Go 语言时，他们制定了一个残酷但有效的规则：全员同意原则。

“我们必须都同意某个特性，它才能被加入。仅仅因为‘我想要这个特性’是不够的。”

这个规则过滤掉了绝大多数“花哨但非必要”的特性。Go 语言之所以能保持如此干净、紧凑，正是因为这三位创始人在最初就把住了关口。

遗产与未来

Ken Thompson 在 Go 语言开源并走上正轨后，逐渐淡出了核心开发。但他对 Go 的后续发展给予了极高的评价，特别是对标准库。

“在我离开后，后来的人写了一套极其出色（magnificent）的标准库。”

那之后，这位图灵奖得主在 Google 的工作中，几乎只使用 Go 语言，并且几乎只使用标准库。

他对 Go 的评价朴实无华：

“它很简单。任何人都可以在一小时内学会它。当你写代码时，它运行得足够快，给你即时的反馈。”

小结

重读这段访谈，我们就能理解：

• 为什么 Go 甚至不愿意引入三元运算符？
• 为什么 Go 的依赖管理（Go Modules）对版本控制如此严格？
• 为什么 Go 编译器宁愿牺牲一些优化也要保证极快的编译速度？

因为 Go 从诞生的那一刻起，就是为了反抗 C++ 的过度复杂，和解决 Google 级别的工程规模问题。

它不是为了在编程语言理论上创新，而是为了让像 Ken Thompson 和 Rob Pike 这样的工程师，不再需要在编译期等待 45 分钟，不再需要去猜测一段代码到底在通过指针玩什么花样。

Go 的诞生，是工程实用主义对无节制复杂性的一次伟大胜利。

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

你的“编译等待”时刻

45分钟的编译时间催生了Go语言。在你的开发生涯中，是否也经历过类似的“编译噩梦”？或者，你是否也曾被某些语言的“过度复杂”劝退过？

欢迎在评论区分享你的故事！ 让我们一起致敬那些为了“简单”而努力的先驱。

如果这篇文章让你对Go语言的设计哲学有了更深的理解，别忘了点个【赞】和【在看】，并转发给身边还在忍受漫长编译的朋友！

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

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

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

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

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

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

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

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

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

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/12/26/google-2025-research-breakthroughs

大家好，我是Tony Bai。

“2025 年，我们见证了人工智能从一种‘工具’向一种‘实用效能 (Utility)’的根本性转变。如果说 2024 年是奠定多模态基础的一年，那么 2025 年则是 AI 开始真正思考、行动并与我们一同探索世界的一年。”

近日，Google 发布了由 大神Jeff Dean, 诺贝尔奖得主Demis Hassabis 和 James Manyika 三位顶级技术领袖联合署名的《2025 年度研发回顾》。这份报告是对 Google 过去一年技术成就的总结，更是一份关于 AI 未来发展方向的战略宣言。

从 Gemini 3 的推理能力突破，到 AlphaFold 在生命科学领域的持续深耕，再到量子计算的工程化落地，Google 用八大领域的进展，向世界展示了一个 AI 全面赋能科学与创造的新时代。

模型进化：Gemini 3 与“思考”的艺术

2025 年是 Google 模型能力突飞猛进的一年。Google 明确指出，AI 的进化方向已从单纯的“生成”转向了深度的“推理” (Reasoning)。

• Gemini 3 Pro：被誉为 Google 迄今为止最强大的模型。它不仅霸榜 LMArena，更在数学、编程和多模态推理上树立了新标杆。
• Gemini 3 Flash：延续了“Flash > 上一代 Pro”的传统，以更低的延迟和成本提供了顶级的推理能力，成为性价比之王。
• Deep Think：这是 Gemini 3 的核心能力之一。它让模型能够处理需要深度抽象推理的问题，甚至在国际数学奥林匹克 (IMO) 和国际大学生程序设计竞赛 (ICPC) 中达到了金牌水平。

AI 已不再只是概率性的文字接龙，它开始具备逻辑推导和解决复杂问题的能力。这标志着 AI 从“知其然”向“知其所以然”迈出了关键一步。

开发者工具：AI Agent 的崛起

在软件开发领域，Google 正式吹响了 AI Agent (智能体) 的号角。

• Google Antigravity：这是一个划时代的 AI 辅助软件开发平台。它不再是简单的代码补全工具，而是一个能够理解项目上下文、执行复杂任务、甚至与开发者协作的Agentic System。
• MCP (Model Context Protocol) 支持：Google 宣布在其服务中全面支持 MCP 协议，这是一个开放标准，旨在让 AI 模型能够标准化地连接和控制外部数据与工具。这标志着 Google 在构建开放、互操作的 AI Agent 生态方面迈出了坚实的一步。

开发者与 AI 的关系正在重塑。AI 将从“副驾驶”升级为能够独立执行任务的“队友”，而 MCP 协议的引入，将极大地加速这一进程。

科学发现：AI 成为科学家的“超级大脑”

Google DeepMind 继续在“AI for Science”领域领跑，将 AI 的力量注入到基础科学的探索中。

• AlphaFold 的五年：作为诺贝尔奖级的成果，AlphaFold 在发布五年后，依然是生命科学领域的灯塔，服务于全球 190 个国家的 300 万研究人员。
• AlphaChip 与 Ironwood：Google利用 AI (AlphaChip) 设计出了新一代 TPU —— Ironwood。这是一款专为推理时代设计的芯片，展示了 AI 自我进化的潜力：用 AI 设计更强的 AI 芯片。
• 量子计算的新篇章：随着量子纠错算法 Quantum Echoes 的发布，以及 Google 科学家 Michel Devoret 荣获诺贝尔物理学奖，Google 在通往实用量子计算机的道路上又迈进了一大步。

创造力与物理世界：AI 的“具身”时刻

AI 的影响力正在溢出屏幕，进入物理世界和创意产业。

• Robotics：Gemini Robotics 1.5 和 Genie 3 的发布，标志着通用世界模型 (World Models) 的成熟。AI Agent 开始具备理解物理规律、并在真实世界中执行任务的能力。
• 生成式媒体：从 Veo 3.1 (视频生成) 到 Imagen 4 (图像生成)，再到 Nano Banana 系列模型，Google 为创作者提供了前所未有的表达工具。

责任与安全：AI 发展的“刹车系统”

在追求速度的同时，Google 依然强调“负责任的 AI”。

• Frontier Safety Framework：Google 加强了其前沿模型的安全框架，Gemini 3 被称为“迄今为止最安全的模型”。
• AI 内容水印：在 Gemini 应用中引入了对 AI 生成视频和图像的验证功能，致力于解决 AI 内容的深度伪造问题。

小结：向 AGI 迈进的坚实一步

Jeff Dean 等人的这份报告，描绘了一个令人激动的未来：AI 正在从一个被动的查询对象，进化为一个主动的、有推理能力的、能与物理世界交互的智能体。

2025 年，不仅是技术的突破之年，更是 AI 范式转移的关键一年。无论是对于开发者、科学家还是普通用户，学会与这些“会思考”的 AI Agent 协作，将成为新时代最重要的生存技能。

资料链接：https://blog.google/technology/ai/2025-research-breakthroughs/

从“看客”到“领航者”：构建你的 AI 原生开发工作流

Google 的 2025 年度报告为我们描绘了 AI Agent 的宏大未来：AI 将不仅是代码补全的工具，更是具备推理能力、能独立解决问题的“队友”。

但对于此时此刻的开发者来说，最大的挑战在于：如何将这些“飞在天上”的未来技术，落地到我们每天的写代码、修 Bug 和架构设计中？

当 Google Antigravity 和 Gemini 3 正在重塑开发范式时，你是否还停留在只会用 Chatbot 问答的阶段？

是时候升级你的开发“操作系统”了。

在我的极客时间专栏《AI 原生开发工作流》中，我将带你跳出简单的 Prompt 技巧，深入探索：

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

不要只做 AI 时代的见证者，要做驾驭 AI 的“原生开发者”。

扫描下方二维码，订阅《AI 原生开发工作流》，开启你的AI原生开发之旅！

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

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

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

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/12/10/russ-cox-interview-go-birth-evolution-future

大家好，我是Tony Bai。

他是 Go 语言的第二代掌门人，在长达十余年的时间里，引领着 Go 从一个内部实验项目，成长为云原生时代的霸主。他也是 Plan 9 的资深黑客，贝尔实验室精神的传承者。如今，他已将 Go 的帅印交给了下一代，转身投入到 AI 模型编码能力的研究中。

他就是 Russ Cox。

在 ACM ByteCast 的一场罕见的深度访谈中，Russ Cox 系统性地回顾了他从贝尔实验室的青葱岁月，到创立 Go 语言的初心，再到对 AI 时代编程语言未来的深刻思考。这既是一段个人回忆录，也是一部关于“如何构建持久的技术”的生动史诗，充满了值得每一位 Gopher 细细品味的智慧。

Go 的“前传”——源自贝尔实验室的“简单”基因

Go 语言对“简单”的极致追求，并非凭空而来，它的种子早已在贝尔实验室和 Plan 9 操作系统的沃土中埋下。

Russ Cox 的编程之旅，始于上世纪 90 年代末的贝尔实验室。作为一个高中生，他有幸在那个创造了 Unix 的传奇之地“厮混”，与 Brian Kernighan, Rob Pike, Ken Thompson, Dennis Ritchie 这些“上古巨神”一同午餐、交流。

“贝尔实验室和 Plan 9 给我最深刻的印记，就是对构建真正简单的事物的执着。那里的人们，那是一个小团队，他们在做着雄心勃勃的事情，而完成它们的最好方式，就是从简单的事情开始，构建那些真正坚固可靠的简单事物。”

这段经历，为他注入了“简单”的 DNA。然而，当他进入 MIT 读研时，他第一次遭遇了“现代 C++”的“恐怖与复杂”。他被当时的业界现状所震惊：多线程不可靠、异步回调横行…… 这让他深信：“一定有更好的方式。”

Go 的“创世纪”——“让我们做点让自己开心的事”

2008 年春天，当 Russ Cox 结束学业，准备进入工业界时，已经先行加入 Google 的 Rob Pike, Robert Griesemer 和 Ken Thompson 向他发出了邀请，他们正准备全职启动一个新语言项目。

这个项目的初心，极其纯粹和个人化。

“我们都曾在 Google 写过大量的 C++ 程序……我们只是再也不想写那种代码了。我们受够了。我们知道有更好的方式，并且我们确信能把它带给 Google 的工程师们。”

“我们想解决的问题是，我们想构建一个能让我们在 Google 开心地编写程序的系统。”

Go 语言的诞生，并非一次自上而下的战略规划，而是一场由几位顶尖工程师发起的、旨在解决自身痛苦的“自救运动”。他们见识过更好的开发环境（Plan 9, Modula-3, Smalltalk），他们无法忍受现代 C++ 的复杂性。Russ Cox 甚至坦言：“说实话，我当时愿意付钱换取和他们一起工作的机会，而 Google 反而付钱给我。这对我来说是双赢。”

Go 的“演进哲学”——稳定压倒一切

从 Plan 9 的“无人问津”，到 Go 的巨大成功，Russ Cox 对开源社区的建设和语言的演进，有着极其深刻的理解。他认为，Go 的成功，很大程度上源于其对“稳定”的执着。

“进步可以有多种形式，一种是不稳定的进步，一种是稳定的进步。我们竭尽全力去寻找稳定的形式，而这通常意味着做得比人们要求的更少，但同时又能让他们解决自己的问题。”

他举了 go test 与 JUnit XML 格式集成的例子。社区曾强烈要求 go test 直接输出 JUnit 格式的 XML。但 Go 团队拒绝了，因为他们不想成为一个复杂 XML 格式的“专家”和“维护者”。

Go 团队的解决方案是：

1. 定义一个极其简单的、稳定的、机器可读的 JSON 输出格式。Go 团队只承诺维护这个简单格式的稳定性。
2. 告诉社区：“然后，你们可以自己写一个从这个 JSON 到你们所需 XML 的转换器。现在，你们可以自己解决自己的问题，而无需等待我们来解决。”

这种“授人以渔”而非“授人以鱼”的哲学，通过提供稳定、正交的底层构建块(build block)，赋能社区在其上构建自己的“进步”，这正是 Go 生态能够健康、蓬勃发展的核心秘诀。

AI 时代的“灵魂拷问”——我们还需要 Go 吗？

如今，Russ Cox 的工作重心已转向“理解和提升 AI 模型的编码能力”。对于 AI 是否会取代程序员这个终极问题，他给出了一个充满历史纵深感的、冷静的回答。

AI 只是进化的又一级台阶

他认为，AI 与编程语言的关系，是计算机发展史上“抽象层次不断提升”这一宏大叙事的延续。

• 40年代：我们通过手动连接电线来编程。后来，我们发明了解释器，用“数据”代替了“电线”。
• 50年代：我们有了 FORTRAN，用 ax² + bx + c 这样的公式，代替了手写机器指令。
• 今天：AI 正在将一些我们曾认为“只有人能做”的工作自动化，比如编写样板代码、调试简单问题。

“我认为 AI 将融入同样的模式……我们会将一些关注点交接出去，然后我们会找到更新、更大的事情来专注。每当我们的能力增长，或者我们将一些工作卸载给机器时，我们的雄心也会随之增长。”

AI 不会让我们失业，它只会让我们站到更高的起点，去挑战更宏大的问题。

编程语言不会消亡，清晰性永恒

Russ Cox 坚信，无论 AI 如何发展，人类可读、行为确定的编程语言都不会消亡。

“英语不会成为编程语言，因为它的歧义性太高了……最终，我们描述的依然是一门编程语言。”

“拥有一门人类可以阅读、理解的编程语言，这一点仍然至关重要。这样，当计算机行为不端时，你可以看着代码说：‘哦，我明白了为什么在这些指令下，它没有做正确的事。’”

AI 可能会帮助我们编写代码，但代码本身，作为人与机器之间那个最基础、最可靠的契约，其地位无可替代。

Go 在 AI 时代的定位

Go 诞生的初衷，是为了解决 20 年前兴起的“多核网络系统”这一巨大挑战。Russ Cox 认为，AI 很有可能在未来提出另一个同等级别的挑战，催生一门全新的语言。

“也许会有一门专为训练模型而生的新语言。Python 目前表现出色，但很容易相信你可以用一门定制语言做得更好。但整个世界并不会都在训练模型。”

他认为，世界上有大约 300 万 Go 开发者，但需要编写模型训练代码的人远少于此。这意味着，Go 作为一门为构建大规模、高并发网络服务而生的语言，其核心价值主张在 AI 时代不仅没有过时，反而愈发重要——因为所有的 AI 模型，最终都需要通过稳定、高效的服务来提供价值。

给后辈的忠告——如何构建持久的事业？

在访谈中，Russ Cox 还给所有有志于创造持久价值的年轻工程师，分享了两条极其宝贵的建议：

1. 花时间去真正理解问题：“很多时候，人们很容易满足于第一个能工作的方案。而我做过的大部分有价值的事，都来自于回头审视一个问题，然后感觉：‘实际上，我还没有完全理解它，我应该再试一次。’” 深入挖掘，直到你发现一个更简单、更根本的解决方案。

2. 找到让你兴奋的环境：“如果你对一件事感到兴奋，你早上醒来就想继续做它，那么你最终能完成的工作，将远超那些只为完成 8 小时任务的人……去找到那些能真正激励你的事情。”

领导力的传承 —— “最重要的期末考试，是退到一旁”

在访谈的最后，Russ Cox 分享了他对领导力，特别是开源项目领导力传承的深刻见解。这或许是整场对话中最具智慧和温度的部分。

他认为，开源社区的领导力，本质上是一种“社会性事业” (social endeavor)，沟通、协作、建立共识的能力，远比纯粹的编程能力更重要。而一个领导者最终极的考验，并非是他能做出多少贡献，而在于他能否以及何时选择“退到一旁”。

“最终，对领导者来说最重要的期末考试，就是退到一旁，然后说：‘好吧，我甚至不需要再在这里了。现在你可以领导这个了。’ 而这很难。”

Russ Cox 坦言，做自己擅长的事情是舒适和安全的，但他清醒地认识到，“项目需要新的想法和新的视角”。他回顾了 Go 领导权的两次交接：

1. 从 Rob Pike 到 Russ Cox：一次非正式的、渐进的交接。Rob Pike 邀请他加入，并在某个时刻悄然地“把项目交给了我，我突然就负责了”。
2. 从 Russ Cox 到 Austin Clements：一次更正式的交接。在领导 Go 长达十年之后，Russ Cox 在 2023 年正式将帅印交给了 Austin Clements。

他强调，这种传承的意义在于：

“确保项目能超越某个特定的人而存在，并且也能获得它们所需要的新视角和新想法。”

这不仅仅是一次权力的交接，更是一位卓越领导者对项目未来的深谋远虑和无私奉献。它确保了 Go 这艘大船，能够在新船长的引领下，继续朝着更广阔的海域航行。

结语

从贝尔实验室的“简单”初心，到 Go 语言的“稳定”哲学，再到对 AI 时代的冷静远见，Russ Cox 的这场访谈，为我们描绘了一位顶尖工程师和技术领袖的心路历程。

他的故事告诉我们，构建持久的技术，其秘诀不在于追逐一时的潮流，而在于深刻地理解问题，坚守核心的原则，并始终保持对创造的热情。这或许也是 Go 语言之所以能穿越喧嚣，成为今天这个样子的根本原因。

资料链接：https://learning.acm.org/bytecast/ep78-russ-cox

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

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

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

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

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

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

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/11/24/google-adk-go-in-action

大家好，我是Tony Bai。

上周，我花了一个下午，仅仅是为了让一个Python写的Agent能稳定地调用我Go服务里的一个简单函数。在那一刻，看着屏幕上纠缠的gRPC、Python虚拟环境和混乱的日志，我脑海里只有一个念头：这不对劲，这绝对不是软件工程该有的样子！

显然，不仅仅是我一个人在为此焦虑。

就在最近，一个名为 google/adk-go 的项目悄然开源，并迅速霸榜 GitHub Go 语言趋势榜长达一周之久！ 全球的 Gopher 似乎都在用脚投票，表达着同一个渴望：我们受够了“炼丹”，我们要回归工程！

过去的一年，AI 的浪潮席卷了整个技术圈。我们 Gopher，作为构建云原生世界的中坚力量，看着 Python 社区在 AI 领域“杀”得热火朝天，心中或许都有一个共同的疑问：

“这场 AI 的盛宴，我们 Gopher 的主菜在哪儿？”

我们习惯了用 goroutine 优雅地处理并发，用 channel 安全地传递消息，用静态编译的单个二进制文件征服任何服务器。我们是天生的“工程师”，我们信奉的是可测试、可维护、可部署的软件工程哲学。

然而，当我们尝试踏入 AI Agent 的世界时，却常常感觉自己像一个闯入了“炼丹房”的“机械师”。面对那些需要反复“吟唱咒语”（调 Prompt）、结果飘忽不定的“丹炉”（模型），我们不禁会问：

• 我的 Agent 行为不稳定，怎么写单元测试？
• Prompt 稍微一改，整个“丹方”都可能失效，版本管理怎么做？
• 我如何将这个“充满魔法”的 Python 脚本，与我现有的 Go 微服务体系优雅地集成，而不是变成一坨无法维护的“耦合怪”？

这些问题，不是因为我们不懂 AI，而是因为我们太懂工程。我们厌倦了“炼丹”式的不确定性，我们渴望一种能将 AI 的强大能力，用严谨的工程纪律约束起来的解决方案。

现在，Google 亲自下场，为我们递来了“工程图纸”。

Google ADK for Go：写给工程师的 AI Agent 开发框架

这个霸榜的项目，全称是 Agent Development Kit (ADK) for Go。

这不是又一个“玩具”或“研究性”框架。从它的设计理念中，我看到了一个清晰而坚定的信号——AI Agent 开发，正在从“炼丹”式的“艺术创作”，全面进入“工程化”的“工业生产”时代。

而 ADK for Go 的核心哲学，与我们 Gopher 的信仰不谋而合，那就是——代码优先 (Code-First)。

• 你的 Agent，就是你的 Go 代码： 不再有晦涩的 YAML，不再有天书般的“链”，Agent 的所有逻辑、决策、工作流，都由你亲手编写的、地地道道的 Go 代码来定义。
• 天生的可测试性： 你的 Agent 就是一个实现了 agent.Agent 接口的 struct。这意味着什么？你可以像测试任何 Go 代码一样，go test 走起！Mock 依赖、断言行为，所有你熟悉的工程实践，全部回归。
• Git 即版本管理： Agent 的每一次进化，都是一次清晰的 git commit。Code Review、版本回滚，一切都尽在掌握。
• 云原生无缝集成： 它就是一个标准的 Go 模块，可以被无缝地集成到你的 Gin/gRPC 服务中，打包成一个极小的 Docker 镜像，部署到任何 K8s 集群。

这就是为什么它能霸榜 GitHub 的原因——它不是在教你如何更好地“调优 Prompt”，而是在教你如何用坚实的工程代码，去彻底终结那个不可控的“炼丹”时代。

Google的adk-go，就是那座连接 Gopher 工程世界与 AI Agent 智能世界的桥梁。

和我一起，从零开始“造”一个真正的 AI Agent

坦白说，ADK for Go 刚刚推出，市面上的教程几乎一片空白。文档虽有，但如何将其与真实的工程场景结合，如何理解其设计背后的权衡，如何避开那些必将遇到的“坑”——这些都需要有人去探索，去趟路。

所以，我决定做这件事。

我将以一个“学伴”和“探索者”的身份，推出我的全新付费微专栏：

《Google ADK 实战：用 Go 构建可靠的AI Agent》

在这个专栏里，我不会扮演一个无所不知的专家。相反，我会将我从零开始学习、实践、踩坑、顿悟的全过程，毫无保留地分享给你。

我们将一起，手把手地、从一个空 main.go 文件开始，完成一次令人兴奋的创造之旅：

• 第 1-2 讲：思维转变与灵魂注入
  我们将彻底理解“代码优先”的哲学，拆解adk-go，了解其中的概念、架构和核心组件，并亲手定义出第一个实现了 agent.Agent 核心接口的智能体。

• 第 3 讲：为 Agent 插上“手臂”： 让你的Agent能调用任何Go函数，像操作自己的手脚一样自如
  我们将学会 ADK 的“魔法”函数 functiontool.New，将一个普通的 Go 函数，零成本地转化为 Agent 可用的工具。

• 第 4 讲：赋予 Agent “双核记忆”
  我们将深入 session（短期记忆）和 memory（长期记忆），让我们的 Agent 能够理解上下文，并记起与你的历史交互。

• 第 5 讲：从“单兵”到“军团”： 构建一个懂分工、会协作的Agent团队，自动化完成复杂任务
  我们将学习 workflowagents，通过编排多个专家 Agent，构建一个强大的“代码生成-审查-重构”自动化流水线。

• 第 6 讲：从“原型”到“产品”
  我们将为 Agent 建立科学的评估体系，并最终将其打包成 Docker 镜像，部署到通用的 Kubernetes 环境中。

学完这个专栏，你将收获的，不仅是一个能跑起来的酷炫 AI 项目，更是一套可复用的、工程化的 AI Agent 构建方法论，以及在 AI 新浪潮中，属于我们 Gopher 的那份自信和底气。

加入这场 Gopher 的 AI 工程化之旅

这个微专栏，是我为你，也为我自己准备的一份“AI 时代 Gopher 生存指南”。它凝聚了我对 Go 工程哲学的理解，和我对 AI Agent 未来的全部热情。

微专栏共 6 篇深度长文，每一篇都是我亲手实践、细节满满的 step-by-step “航海日志”。

我没有设定一个高昂的价格，而是希望与更多志同道合的 Gopher 一起探索。所以，订阅这份专栏，仅需你一杯咖啡的诚意。

花一杯咖啡的时间，你或许能得到片刻的清醒；而用同样的价格投入到这里，我希望能为你带来一次思维的升级和技能的跃迁。

点击这里，或扫描二维码，立即加入。

让我们一起，用代码，构建智能。

P.S. 如果你对 AI Agent、Go 语言或者这个微专栏有任何问题，欢迎在评论区留言，我们一起交流探讨！

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

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

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

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

© 2025, bigwhite. 版权所有.