本文永久链接 – https://tonybai.com/2026/05/14/uncle-bob-esr-on-why-we-are-turning-to-go-and-rust-in-the-ai-era

大家好，我是Tony Bai。

在软件工程的浩瀚星河中，有两位堪称“活化石”级别的宗师：

一位是 Eric S. Raymond (ESR)，开源运动的先驱，那本被誉为开源圣经的《大教堂与集市》以及《Unix编程艺术(The Art of UNIX Programming)》一书均是出自他手。他是一个写了 40 年 C 语言的硬核黑客。

另一位是 Uncle Bob Martin (Bob 大叔)，敏捷宣言的签署人之一，《敏捷软件开发》、《代码整洁之道 (Clean Code)》等程序员经典书籍的作者，无数 Java 和 C# 程序员的精神导师。

这两位加起来写了快一百年代码的传奇人物，最近却在 X (Twitter) 平台上，不约而同地抛出了一个足以引发技术圈大地震的论断：

在如今这个被 AI 席卷的时代，他们双双放弃了自己曾经最擅长的语言（C 和 Java），转而全面拥抱 Go 语言，并在特定底层场景下使用 Rust。

更令人震撼的是，ESR 直接宣告了手工古法编程模式的死刑：

“手写代码的时代基本结束了（The age of hand-coding is mostly over）。现在选择编程语言的标准，已经彻底变了。”

今天，我们就来深度扒开这场顶级黑客的“赛博夜话”，看看在 AI 智能体（Agent）狂飙突进的 2026 年，我们究竟该如何重新审视和选择我们手中的“兵器”。

认知颠覆：当 AI 成为主程序员，语言的选择标准变了

我们过去是如何选择编程语言的？

语法是否优雅？生态是否繁荣？框架是否齐全？这些都是基于“人类如何高效手写代码”而设定的标准。

但 ESR 尖锐地指出，在如今我们拥有“机器朋友（Robot friends / AI）”来完成绝大部分代码生成和翻译工作的时代，这些旧标准已经失效了。

现在的核心标准只有两个：

1. 你的 AI 朋友，能不能高质量地生成这种语言的代码？
2. 生成之后，作为人类的你，能不能一眼看懂（Review）这些代码？

“如今，我使用什么计算机语言是否顺手，已经不再那么重要了，真正重要的是我正在使用的‘机器朋友’能否高质量地生成它。
同时也重要的是我能否读懂这门语言，因为我需要亲自去审查（Review）这些代码。”

在这个新标准下，那些充满了黑魔法（如各种奇葩的宏、复杂的继承体系、极度隐晦的元编程）的语言，瞬间成了灾难。因为当 AI 吐出几百行充满魔法的代码时，人类审查的“认知负荷”将是灾难性的。

宗师的抉择：为什么是 Go 和 Rust？

在这个全新的游戏规则下，两位宗师给出了他们惊人一致的答案。

Bob 大叔的 Go 语言初体验：快、无聊、但完美契合 AI

Bob 大叔在评论区透露，他正在设计一门关于“使用 Agent 进行软件工程”的在线课程。

“在过去，我会选择像 Java、C# 或 JavaScript 这样流行的语言来做课程。但这次我选择了 Go。不是因为它流行，而是因为它很快（Fast）。我的学生们不会花太多精力去钻研 Go 的语法细节，但他们会看到 Go 的表现。”

Go 语言那常被诟病的“啰嗦”和“无聊”，在 AI 时代反而成了最强大的护城河。

因为 Go 的语法极度收敛，没有隐式类型转换，没有复杂的泛型继承。当 AI 生成一段 Go 代码时，那满屏极其直白的 if err != nil，让人类工程师一眼就能看穿它的逻辑底裤。在审查 AI 代码时，没有魔法，就是最高的生产力。

ESR 的决断：别了，我写了 40 年的 C 语言

ESR 的话更具传奇色彩和悲壮感：

“我可能再也不会用 C 语言开新项目了。那除了自虐还有什么意义？我花了 40 年写 C，我非常精通。但我会毫不留恋地把它，连同它的缓冲区溢出、堆破坏、未定义行为和可移植性问题，全部抛在脑后。”

他现在的探索性编程，全部交给了 Python 或 Go。

“我的机器朋友在生成这两种语言的代码时都非常出色。我认为它们在生成 Go 代码时的表现甚至略胜一筹，这可能是因为 Go 语言拥有更小的表面积（smaller surface）。”

(注：Smaller surface 意味着语法简单，AI 预测下一个 Token 时的歧义和错误率极低)

至于 Rust，ESR 将其定位为“终极的降落场”。

当他需要极其坚固的内存安全保证，且代码的探索期已经结束，进入严肃的生产部署阶段时，他会让 AI 把代码翻译成 Rust。

“Rust 满足了我的要求——我发现它写起来很麻烦，但读起来基本没问题。”

时代的阵痛：被 AI 降维打击的传统生态

这场讨论，不仅是对 Go 和 Rust 的赞歌，更是对一些传统“大厂语言”的残酷揭底。

ESR 毫不客气地吐槽了 Python 曾经的混乱（尽管它现在有了类型提示和 uv 等现代工具，情况有所好转）：

“Python 曾是我的最爱，但在 Python 2 到 Python 3 的灾难性过渡、GIL 导致的并发地狱、以及包管理的混乱之后，我曾对它感到厌倦……如果我现在要写一个比 Python 粘合脚本大得多的东西，我只会耸耸肩，然后直接去用 Go。”

在推特的评论区，另一位开发者的一句话，道出了更多人的心声：

“Go 代码的质量，很大程度上是因为 Go 语言本身往往倾向于极高的质量（因为缺乏炫技的空间）。所以 AI 生成的代码，也顺理成章地继承了这种高质量。”

当一门语言为了迎合人类的“偷懒”和“炫技”而变得越来越复杂时（比如不断叠加新特性的 C++ 和 Java），它在 AI 时代反而会成为一种累赘。

因为 AI 不需要语法糖，AI 需要的是绝对的清晰和确定性。

反思：从“写手”到“审查员”的身份跃迁

两位古灰级黑客的这番言论，给所有还在为了“哪种语言的特性更酷炫”而争得面红耳赤的年轻程序员，狠狠地上了一课。

时代的列车已经呼啸而过。

当代码生成不再是瓶颈，软件工程师的核心价值，正在不可逆转地从“Writer（编写者）”向“Reader & Reviewer（阅读者与审查者）”迁移。

在这个新时代，我们评估一项技术的眼光必须升级：

1. 可审计性（Auditability）大于一切：如果一段代码极其简洁但难以调试，它就是垃圾。Go 语言的“直白”，在 AI 时代成为了最顶级的安全感。
2. 安全性的底座转移：像 Rust 这样通过极其严苛的编译器来保证内存安全的语言，将成为 AI 时代最可靠的“数字基础设施钢筋”。你可能不需要手写它，但你的 Agent 会为你生成它，并由编译器确保它不会在半夜崩溃。
3. 拥抱“机器思维”：放下程序员的“文人相轻”，接受那些对机器友好、对审查友好的“无聊技术”。

小结：向宗师致敬，向未来前行

如果连写了 40 年 C 语言的 Eric S. Raymond，和开创了现代软件工程思维的 Uncle Bob，都能毫不犹豫地放下过去的骄傲，全身心地拥抱 AI、Go 和 Rust。

我们这些普通开发者，还有什么理由紧抱着那些陈旧的“鄙视链”不放呢？

手写代码的时代正在落幕，但软件工程的黄金时代，才刚刚开始。

用 Go 来快速验证和构建业务，用 Rust 来打造坚不可摧的底层，让 AI 成为那个不知疲倦的打字员。这，就是顶级黑客们为我们指明的 2026 年生存法则。

资料链接：https://x.com/esrtweet/status/2054288478750597593

今日互动探讨：

连 Bob 大叔和 ESR 都倒戈了！你同意他们“手写代码时代已结束”、“更看重代码审查的可读性”的观点吗？在日常的 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 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

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

本文永久链接 – https://tonybai.com/2026/05/13/go-mod-hidden-features-7-secret-switches-in-go-version

大家好，我是Tony Bai。

在这个“CV 工程师(复制粘贴工程师)”盛行的时代，很多 Go 开发者在新建项目时，不会使用go mod init来初始化一个模块，而是会熟练地从别的 go.mod 文件里，复制粘贴那行 go 1.xx，或者直接复制一个starter 脚手架Go 工程。我们似乎都默认了go.mod中go 1.xx 的作用——“嗯，就是声明一下我用的 Go 版本嘛，不重要。”

我们可能会花几天时间去争论 GOMAXPROCS 该设成多少，或者为了一个微小的性能优化而重构代码，但很少有人会去深究这行看似“平平无奇”的指令，到底在 Go 的世界里扮演着怎样的角色。

但如果我今天告诉你，这行被我们忽视了近 8 年的“魔法咒语”，在 Go 工具链的底层，其实悄悄地控制着多达 7 个维度的编译和运行时行为呢？

从你能不能用泛型，到 go mod tidy 的工作模式，再到你的程序在生产环境中的默认行为……这一切，都由这行代码说了算。

最近，我扎进了 Go 语言的源码，试图去解开这个“最熟悉的陌生人”的秘密。而我发现的真相，足以颠覆多数 Gopher 的认知。

今天，就让我们来一场硬核的“源码考古”，逐一拆解这行 go 指令背后的七大用途。

go directive 是什么

go.mod 中的 go directive 格式如下：

go 1.21.0

它由 golang.org/x/mod/modfile 包解析，并存储在 modfile.File.Go.Version 字段中。

// $GOROOT/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
type Go struct {
    Version string // "1.23"
    Syntax  *Line
}

有趣的是，如果你的 go.mod 文件里没有这一行（比如一些远古项目），Go 工具链并不会报错，而是会默默地为你应用一个默认值：go 1.16。

// $GOROOT/src/cmd/go/internal/gover/version.go
const DefaultGoModVersion = "1.16"

为什么是 1.16 这个看起来有点奇怪的数字？Go 源码的注释给了我们答案：

因为 Go 1.17 对模块图的语义进行了重大修改。为了保证对那些没有 go 指令的、极其古老的项目的兼容性，我们必须保守地假设它遵循 Go 1.16 的规则。这个默认值，永远不会再被提高了。

这背后，体现了 Go 团队对“向后兼容性”近乎偏执的坚守。

用途一：语言版本的“守门人”（最核心）

这是 go 指令最广为人知、也是最直接的作用：它决定了编译器允许你使用哪些语言特性。

在 Go 的源码深处，go 命令在编译每个包时，都会将 go.mod 中定义的版本号，通过 -lang 标志，像一道“圣旨”一样传递给编译器。

// $GOROOT/src/cmd/compile/internal/noder/irgen.go
conf := types2.Config{
    GoVersion: base.Flag.Lang,  // 来自 -lang 标志，由 go.mod 的 go directive 决定
    ...
}

编译器内部的类型检查器，会用一个名为 allowVersion 的函数，来判断你写的某段代码，是否“越界”使用了当前版本还不支持的“未来语法”。

// $GOROOT/src/cmd/compile/internal/types2/version.go
func (check *Checker) allowVersion(want goVersion) bool {
    return !check.version.isValid() || check.version.cmp(want) >= 0
}

经典案例：Go 1.22 的 for 循环变量“拨乱反正”

Go 1.22 修复了 for 循环变量在闭包中常年为人诟病的“共享变量”问题：

// go.mod: go 1.21  → 旧语义，所有迭代共享同一变量
// go.mod: go 1.22  → 新语义，每次迭代独立变量

而这个行为的开关，正是由 go 指令严格控制的。

// 示例：
// 当 go.mod 中是 go 1.21 时，以下代码会打印 3 个 "3"
// 当 go.mod 中是 go 1.22 时，以下代码会打印 0, 1, 2
funcs := make([]func(), 3)
for i := 0; i < 3; i++ {
    funcs[i] = func() { fmt.Println(i) }
}

for _, f := range funcs {
    f()
}

这意味着，仅仅是修改 go.mod 里的一行数字，就可能让你的程序的输出结果发生根本性的变化！

其他受Go 版本控制的语言特性一览

如果你试图在 go 1.21 的模块里写 for i := range 10，编译器会毫不留情地报错，并清晰地告诉你：“检查你的 go.mod 文件！”

用途二：模块图裁剪(Module Graph Pruning)的“总开关”

这是 Go 1.17 引入的一项重要优化，它彻底改变了 Go 命令解析依赖图的方式，但很多开发者对此却知之甚少。

在 Go 的源码中，1.17 被定义为一个分水岭：

// src/cmd/go/internal/gover/version.go
ExplicitIndirectVersion = "1.17"  // 启用图裁剪的版本

go.mod 中的版本号，将决定你的项目采用哪种依赖图模式：

// $GOROOT/src/cmd/go/internal/modload/modfile.go
func pruningForGoVersion(goVersion string) modPruning {
    if gover.Compare(goVersion, gover.ExplicitIndirectVersion) < 0 {
        return unpruned  // < 1.17：加载完整传递依赖图
    }
    return pruned        // >= 1.17：启用图裁剪
}

go < 1.17（完整模式 Unpruned）：

• go.mod 文件里只需要列出你的直接依赖。
• 但代价是，每次构建时，Go 命令都需要递归地、完整地加载所有传递依赖（A 依赖 B，B 依赖 C，C 依赖 D……）的 go.mod 文件，构建一个庞大的、完整的依赖图。这在大型项目中，极其缓慢。

go >= 1.17（裁剪模式 Pruned）：

• go.mod 文件里必须显式地列出所有传递依赖，哪怕它们是间接的。这就是你经常看到的 // indirect 标记的由来。
• 好处是，Go 命令在构建时，可以“偷懒”，只读取直接依赖的 go.mod 文件，而对那些未真正使用的间接依赖进行“裁剪”，从而极大地加快了构建速度，并增强了构建的可重现性。

# go 1.17+ 的 go.mod 示例：间接依赖被显式列出
require (
    github.com/some/direct v1.2.3  

    github.com/indirect/dep v0.1.0 // indirect  ← 1.17+ 才会出现
)

用途三：all 模式的“结界”

go test all 这样的命令，在不同的 Go 版本下，其“all”所覆盖的范围，竟然是不同的！而这个“结界”的开关，同样是 go 指令。

在源码中，1.16 是另一个分水岭：

这个改动非常微妙，但影响深远。它意味着在 Go 1.16 之后，go test all 不再会因为某个你八竿子打不着的、间接依赖的测试代码写错了而失败，让 all 模式变得更加聚焦和实用。

用途四：GODEBUG 运行时行为的“默认存档”

这是 Go 1.21 引入的最具“魔力”，也最危险的一个特性：go 指令，决定了你的程序在生产环境中的 GODEBUG 默认值！

Go 团队为了在不破坏向后兼容性的前提下，修复一些语言的历史包袱（比如 panic(nil)），引入了 GODEBUG 环境变量。

当编译器在构建你的 main 包时，它会检查 go.mod 里的版本号，然后将一套与该版本行为相匹配的 GODEBUG 默认值，直接编译进你的二进制文件里。

// $GOROOT/src/cmd/go/internal/load/godebug.go
func godebugForGoVersion(v string) map[string]string {
    // ...
    def := make(map[string]string)
    for _, info := range godebugs.All {
        if n < info.Changed {
            def[info.Name] = info.Old  // 使用旧版本的默认值
        }
    }
    return def
}

经典案例：

• 如果你的 go.mod 写的是 go 1.20，那么你的程序在运行时，会默认 panicnil=1（允许 panic(nil) 这种旧的、不规范的行为）。
• 但如果你把它改成 go 1.21，那么程序的默认行为就会变成 panicnil=0（panic(nil) 会在运行时直接报错）。

官方文档说得很清楚：

Go 工具链会修正自己的默认行为，以尽可能地匹配你声明的旧版本。

这意味着，升级 go 指令，是一项具有潜在风险的操作。 它可能在你不经意间，改变程序的运行时行为。

用途五：Toolchain 自动切换的“指挥官”

从 Go 1.21 开始，你的电脑上可以同时安装多个 Go 版本。而决定在编译某个特定项目时，到底该用哪个版本的“指挥官”，就是 go 指令。

当你的 GOTOOLCHAIN 环境变量设为 auto 时，go directive 会触发自动工具链切换。

// $GOROOT/src/cmd/go/internal/toolchain/select.go
if gover.Compare(goVers, minVers) > 0 {
    gotoolchain = "go" + goVers
    // ...
    gover.Startup.AutoGoVersion = goVers
    // 打印：go: upgrading toolchain to goX.Y.Z (required by go line in go.mod)
}

下面是一个示例：

# go.mod
module example.com/myapp
go 1.23.0

# 你的电脑当前默认安装的是 go1.21.0
# 当你在这个项目下运行 go build 时……
# → Go 命令会发现版本不匹配，自动去下载并切换到 go1.23.0 工具链！
# 并打印：go: upgrading toolchain to go1.23.0 ...

同时，Go 1.21 还引入了“严格版本约束”：一个 go 1.21+ 的模块，其 go 指令版本，必须 大于或等于 它所有依赖模块的 go 版本。

// $GOROOT/src/cmd/go/internal/gover/version.go
// GoStrictVersion is the Go version at which the Go versions became "strict"
// in the sense that every module must have a go version line ≥ all its dependencies.
GoStrictVersion = "1.21"

用途六 & 七：Vendor 模式与 go mod tidy 的“幕后推手”

除了上述几大核心用途，go 指令还在一些细节上，扮演着“幕后推手”的角色。

Vendor 模式

从 Go 1.17 开始，go mod vendor 会在 vendor/modules.txt 文件里，为每一个依赖项记录其 go 版本：

## explicit; go 1.17

这确保了即使在离线 vendor 模式下，编译器也能为每个包应用正确的语言特性。

# go.mod: go 1.16 → vendor/modules.txt 不含版本信息，统一猜测为 1.16
# go.mod: go 1.17 → vendor/modules.txt 含版本信息，每个包用自己的版本

go mod tidy的行为

go 指令的版本，还会影响 tidy 命令在依赖保留范围、go.sum 校验范围、以及间接依赖分组显示等方面的细微行为。

1. 保留的依赖范围

// $GOROOT/src/cmd/go/internal/modcmd/tidy.go
// Go versions 1.17 and higher retain more requirements in order to
// support lazy module loading.

2. go.sum 的校验范围

// $GOROOT/src/cmd/go/internal/gover/version.go
// TidyGoModSumVersion is the Go version at which 'go mod tidy' preserves
// go.mod checksums needed to build test dependencies of packages in "all"
TidyGoModSumVersion = "1.21"

3. 间接依赖的分组显示

SeparateIndirectVersion = "1.17"
// go >= 1.17：// indirect 依赖单独成块

小结：一行代码背后的“架构演进史”

看到这里，你还会觉得 go 1.xx 只是一行简单的版本声明吗？

这短短的一行代码，像一根时间线，串联起了 Go 语言从诞生到成熟的整个演进历史。

go directive
    │
    ├─ 编译器 -lang 标志
    │       └─ 控制语言特性（泛型/loopvar/range整数...）
    │
    ├─ 模块图裁剪模式
    │       ├─ < 1.17：unpruned（完整传递依赖图）
    │       └─ >= 1.17：pruned（显式间接依赖 + 图裁剪）
    │
    ├─ "all" 模式范围
    │       ├─ < 1.16：包含外部包的测试依赖
    │       └─ >= 1.16：仅主模块的传递导入
    │
    ├─ GODEBUG 运行时默认值
    │       └─ 编译进二进制，影响运行时行为
    │
    ├─ Toolchain 自动选择（>= 1.21）
    │       └─ GOTOOLCHAIN=auto 时触发工具链下载/切换
    │
    ├─ vendor/modules.txt 版本记录（>= 1.17）
    │       └─ 影响 vendor 模式下的语言版本应用
    │
    └─ go mod tidy 行为
            ├─ 依赖保留范围
            ├─ go.sum 校验范围
            └─ 间接依赖分组

它既是语言特性的“守门人”，又是模块系统的“总开关”，还是运行时行为的“默认存档”。

它身上，凝聚了 Go 团队对向后兼容性、工程效率、可重现性这三大核心哲学最深刻的思考与权衡。

下一次，当你新建一个项目，或者准备升级 go.mod 里的那个版本号时，请务必三思。

因为你修改的，不仅仅是一个数字，而是你与 Go 工具链之间，一份极其重要、且牵一发而动全身的“契约”。

今日互动探讨：

在你的日常Go编程中，你有没有遇到过写错Go version带来的“坑”？你觉得 Go 语言go.mod中的go version用起来怎样？是否还有改进的地方。

欢迎在评论区分享你的血泪史与感悟！

还在为写 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 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

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