本文永久链接 – https://tonybai.com/2026/02/13/grady-booch-uml-software-engineering-third-golden-age-begins

大家好，我是Tony Bai。

在 2026 年初的今天，如果你问一个软件工程师“最近感觉如何？”，得到的回答大概率是焦虑。

Anthropic 的 CEO Dario Amodei 曾预言：“软件工程将在 12 个月内被自动化。”

GitHub Copilot、Claude Code、Gemini Cli等Coding Agent的代码生成能力确实让人惊叹，但也让人背脊发凉：如果 AI 能瞬间写出完美的 C++ 代码，我们这些还在啃算法、背八股文的人，存在的意义是什么？

在这个充斥着“软件工程已死”论调的时刻，一位真正的“上古大神”站了出来。

他是 Grady Booch。

如果你是计算机科班出身，你一定听过他的名字。他是 UML（统一建模语言）的创始人之一，面向对象设计（OOD）的先驱，IBM Fellow。他入行时，程序员还在用打孔卡；他经历过汇编到高级语言的剧变，也经历过互联网泡沫的崩塌。

在最近的一次深度访谈中，面对“AI 取代程序员”的言论，Grady Booch 微微一笑，给出了一个截然不同的判断：

“别担心。软件工程没有死，我们正站在‘第三次黄金时代’的门口。”

直面争议：“那是纯属胡扯”

访谈中，主持人问 Grady 如何看待“软件工程即将被自动化”的观点。

Grady 的回答非常直接且不留情面：“纯属胡扯”。

为什么这位泰斗如此笃定？因为那些鼓吹替代论的 CEO 们，混淆了两个根本性的概念：Coding（编码）与 Engineering（工程）。

• Coding 是什么？是将设计好的逻辑翻译成机器能懂的语言。这是 AI 最擅长的，也是最容易被自动化的“翻译层”。
• Engineering 是什么？是在资源受限、需求模糊、环境动态变化的前提下，寻找最优解的过程。

Grady 指出，软件工程师的本质工作，是平衡多维度的力量（Balancing Forces）。你需要平衡物理定律（光速限制延迟、芯片散热）、经济成本（算力预算、开发周期）、法律合规（数据隐私）、人类伦理（算法偏见）。

Grady补充，“AI 目前只是一个极其高效的‘实现者’。它连理解这些约束的门槛都没摸到。”

只要这个世界还存在资源稀缺和复杂的人性，就需要工程师去权衡利弊、做出决策。这才是工程的灵魂，而代码只是结果。

历史的望远镜：软件工程的三次跃迁

为了让我们看清未来，Grady 举起了历史的望远镜。他认为，软件工程的历史，就是一部抽象层级不断提升的历史。

第一次黄金时代 (1950s – 1970s)：算法抽象

那时，软件刚从硬件中解耦。Fortran 和 Algol 的出现，让程序员不再需要手写汇编。

• 当时的焦虑：“高级语言效率太低，真正的程序员只写汇编。”
• 结果：汇编程序员确实变少了，但软件行业爆发了。我们开始关注算法。

第二次黄金时代 (1980s – 2000s)：对象抽象

随着 PC 的普及，系统复杂度指数级上升。面向对象（OOP）和设计模式应运而生。

• 当时的焦虑：“有了图形界面和开发工具，还需要专业程序员吗？”
• 结果：软件渗入了人类生活的方方面面。我们开始关注对象和交互。

第三次黄金时代 (2000s – Now)：系统抽象

现在，我们进入了第三阶段。云原生、微服务、以及现在的 AI。

• 现在的焦虑：“AI 写代码了，我们要失业了。”
• Grady 的预判：AI 是最新的编译器，是这一代最高的抽象层。它屏蔽了语法的细节，屏蔽了库的调用。

Grady继续指出：“每一次抽象层级的提升，都会消灭低端的重复劳动，但同时会释放出巨大的生产力，让我们去构建更宏大、更复杂的系统。”

未来的核心竞争力：系统思维

如果 AI 帮我们干了脏活累活（写 CRUD、写测试、修 Bug），那我们该干什么？

Grady 给年轻工程师的建议是：去拥抱“系统思维（Systems Thinking）”。

未来的软件工程师，将从 Coder（代码工匠）进化为 Architect（系统架构师）。

你的核心竞争力将不再是“精通 Go 语法”或“手写红黑树”，而是：

1. 复杂性管理：当 AI 一天能生成 10 万行代码时，如何保证系统不崩塌？如何设计高可用的架构？
2. 跨学科融合：Grady 提到了他在 NASA 火星任务中的经历。要构建那个系统，他必须懂生物学、神经学和物理学。AI 时代，软件将进入更多深水区，你需要懂业务、懂人性。
3. 定义问题的能力：AI 是执行者，你是定义者。Problem Shaping（问题重塑）的价值将远远超过 Problem Solving（问题解决）。

“Fear not（不要恐惧）。” Grady 说，“你的工具变了，但你要解决的问题——如何用技术改善人类生活——从未改变。”

小结：站在深渊边缘，学会飞翔

在访谈的最后，Grady Booch 说了一段极具哲学意味的话。

面对 AI 带来的巨大变革，我们就像站在悬崖边缘。

你可以选择盯着深渊，恐惧地喊：“完蛋了，我要掉下去了。”

你也可以选择抬起头，说：“不，我要跳跃，我要飞翔。”

这就是起飞的时刻。

AI 帮你消除了实现的摩擦，降低了构建的成本。以前你受限于手速和团队规模，做不出伟大的产品；现在，限制你的只有你的想象力。

软件工程没有死，它只是进化了。

而我们，有幸成为这第三次黄金时代的开启者。

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

你准备好“飞翔”了吗？

Grady Booch 的判断让我们看到了一个更宏大的未来。作为一名开发者，你是否也曾感觉到“编码”与“工程”之间的那道分界线？你认为在即将到来的“第三次黄金时代”，除了系统思维，还有哪些能力是不可或缺的？

欢迎在评论区留下你的思考或困惑！ 让我们一起在悬崖边缘，寻找飞翔的力量。

如果这篇文章给了你走出焦虑的勇气，别忘了点个【赞】和【在看】，并转发给你那些还在被“AI 替代论”困扰的朋友！

如何成为 AI 时代的“系统工程师”？

Grady Booch 告诉我们要具备系统思维，要学会编排 AI，而不是被 AI 取代。但这具体怎么落地？

• 如何从“写代码”转型为“设计 Spec”？
• 如何利用 Agentic Workflow 组建你的“数字研发团队”，去构建复杂的系统？
• 如何建立 AI 时代的代码审查和质量控制体系？

欢迎关注我的极客时间专栏**《AI 原生开发工作流实战》**。

我们不教你如何在这个时代“卷”代码，我们教你如何站在巨人的肩膀上，成为驾驭算力的 System Engineer。

扫描下方二维码，开启你的第三次黄金时代。

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

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

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

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

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

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

本文永久链接 – https://tonybai.com/2026/02/10/ai-agent-realizes-ultimate-dream-software-factory

大家好，我是Tony Bai。

在计算机科学与软件工程的历史长河中，始终存在着一个令人魂牵梦绕、却又屡屡受挫的终极梦想——“软件工厂（Software Factory）”。

早在 20 世纪 60 年代，日本的大型科技企业（如日立、东芝）就开始尝试引入制造业的流水线理念来生产软件。80 年代，CASE（计算机辅助软件工程）工具试图实现全流程自动化；21 世纪初，MDA（模型驱动架构）试图通过 UML 图直接生成代码。

然而，这些尝试无一例外都未能成为主流。

为什么？因为软件开发与硬件制造有着本质的不同。硬件是标准化的，而软件需求充满了不确定性（Ambiguity）、非标准化（Non-standard）和创造性（Creativity）。传统的刚性流水线无法处理这种“软”的复杂性。

但这一次，不一样。

随着以 GPT-5.2、Claude 4.5、Gemini Pro 3.0 等为代表的大语言模型（LLM）能力的爆发，以Claude Code、Gemini Cli等编码智能体的快速演进，以及Agentic Workflow（智能体工作流）的成熟，我们第一次拥有了能够理解“非标需求”并将其转化为“标准代码”的通用推理引擎。

特斯拉前 AI 总监 Andrej Karpathy 将这一刻定义为 Software 3.0 的黎明。在这个新时代，那个尘封已久的“软件工厂”蓝图，正在从幻想变成触手可及的现实。

今天，我们就来深度剖析这座正在崛起的 AI 软件工厂，看看它将如何重塑我们的行业、生态与职业。

Software 3.0：从“写代码”到“定义目标”

要理解软件工厂的本质，我们需要先理解 Karpathy 提出的软件演进三阶段论。这是一次技术的迭代，更是编程范式的根本性迁移。

Software 1.0：显式编程 (Code)

这是我们最熟悉的时代。程序员使用 Go、Python、C++、Java、TypeScript 等语言，编写显式的逻辑规则。

• 特征： 人类必须清楚地知道每一步该怎么做（How），然后翻译给机器。
• 局限： 复杂度随着代码行数线性（甚至指数）增长，维护成本极高。这是典型的“手工作坊”模式。

Software 2.0：数据驱动 (Weights)

深度学习的兴起带来了 2.0 时代。程序员不再编写规则，而是编写目标（损失函数）和准备数据，由优化器（Optimizer）在神经网络的权重空间中搜索出最优解。这是一个黑盒。虽然它能解决图像识别等 1.0 很难解决的问题，但它缺乏逻辑的可解释性。

Software 3.0：自然语言编程 (Prompts)

现在，我们进入了 3.0 时代。LLM 成为了一个新的、通用的可编程实体。

• 特征： 编程语言变成了英语（或任何自然语言）。我们不再需要告诉机器“怎么做（How）”，只需要告诉它“做什么（What）”和“想要什么结果（Goal）”。
• 质变： Prompt 成了新的源代码。而能够理解 Prompt 并执行任务的 AI Agent，成了新时代的工人。

正是 Software 3.0 的出现，让“输入模糊需求，输出精确系统”成为了可能。

全景图：解构一座柔性的“AI 软件工厂”

想象一下，未来的软件交付不再是一个团队几周的冲刺，而是一个工厂几分钟的运转。这座工厂不再由传送带和机械臂组成，而是由运行在云端的 Agent Swarm（智能体集群）构成。

这是一座柔性制造的超级工厂，其运作流程如下：

输入端：非结构化的意图

你不需要编写代码，甚至不需要编写格式严格的 PRD 文档。

工厂的原材料可以是极其粗糙的：

• 一段 30 分钟的产品会议录音。
• 一张在白板上画的草图照片。
• 或者仅仅是一句模糊的想法：“帮我做一个给宠物猫记账的小程序，要能识别猫粮的发票，还要有月度支出的数据看板。”

生产车间：智能体协作网络

需求进入工厂后，会被一个Orchestrator（编排器）接管，并分发给不同的“职能车间”。这些车间由专精不同领域的 Agent 组成：

• 设计车间 (Architect Agent)：

它首先分析需求，进行系统拆解。它会输出：

*   API Spec: 定义前后端交互的接口（如 OpenAPI/Swagger）。
*   Database Schema: 设计数据库表结构（如 SQL DDL）。
*   Tech Stack: 根据需求量级选择技术栈（是选 Next.js 还是纯 HTML？）。

• 制造车间 (Coder Agent)：

这是工厂的主力军。它会裂变出多个子 Agent 并行工作：

*   Frontend Agent: 根据设计稿生成 React 组件。
*   Backend Agent: 编写 API 逻辑和数据库访问层。
*   SQL Agent: 编写复杂的查询语句。

它们通过 GitHub 或共享文件系统进行协作，像真实团队一样提交 Pull Request。

• 质检车间 (QA Agent)：

这是保证“良品率”的关键。QA Agent 不会等到代码写完才介入，而是采用 TDD（测试驱动开发）模式。

*   它会先根据 Spec 生成测试用例（Test Cases）。
*   然后对 Coder Agent 提交的代码进行“红绿循环 (Red-Green Loop)”测试。
*   如果发现 Bug，它不会只是报错，而是将错误日志作为“反馈信号”退回给制造车间，要求重做。

• 装配车间 (DevOps Agent)：

代码通过测试后，DevOps Agent 上场。它编写 Terraform 或 Dockerfile，调用 AWS/Aliyun/Cloudflare的 API，自动配置云端环境，进行部署。

输出端：即时可用的服务

工厂的传送带末端，输出的不是一堆冷冰冰的代码文件，而是一个可访问的 URL，一个已经配置好的 Admin 后台，以及一套完善的系统监控仪表盘。

这就是 Software 3.0 的终极形态：Prompt in, System out.

核心变革：柔性制造与动态编排

为什么我们要强调这是“柔性”工厂？因为它解决的是传统 CI/CD 流水线最大的痛点——刚性。

传统的流水线是线性的（Build -> Test -> Deploy）。一旦 Test 挂了，流水线就停了，红灯亮起，必须等待人类工程师介入修 Bug。

但 AI 软件工厂是有生命、会呼吸的。

它是基于 Agentic Workflow 的动态有向无环图（DAG），甚至是包含循环的图。

• 自愈 (Self-Healing)：当 QA Agent 发现 Bug 时，系统不会停机。它会触发一个**“修复循环”**。Coder Agent 会分析 QA 给出的错误日志，结合源代码进行推理，修改代码，再次提交。这个过程可能在几秒钟内迭代数十次，直到测试通过。
• 动态扩容 (Dynamic Scaling)：如果 Architect Agent 发现需求特别复杂（比如涉及 50 个页面），它会自动指挥工厂“招人”——即启动更多的 Coder Agent 实例并行开发，最后再进行合并。

这是一条会思考的流水线。它不仅生产代码，还生产基础设施（IaC）。它与云厂商深度集成，实现了真正的 Serverless——作为用户，你连 Server 都不用感知，你只感知 Service。

行业震荡：生态与角色的重构

当这种“输入需求，输出系统”的工厂模式普及后，软件行业的格局将发生天翻地覆的变化。

软件工程：从“人际协作”到“机机协议”

传统的软件工程理论（Agile, Scrum, 看板）很大程度上是为了解决“人与人协作”中的摩擦——信息不对称、理解偏差、情绪波动。

但在 AI 工厂里，协作变成了 A2A (Agent-to-Agent) 的协议交互。

• Agent 不会开小差。
• Agent 不会误解符合 Spec 的接口定义。
• Agent 不需要每日站会同步进度。

未来的软件工程，将从管理“人”，转向管理“协议”和“标准”。协作的重心将聚焦于“人与工厂”的交互——即如何更精准、更高效地向工厂下达指令（Prompt Engineering / Spec Writing）。

软件生态：开源项目的“模具化”

在 Software 1.0 时代，开源项目（如 React, Spring, Django）是给人用的库（Library）。我们需要学习它的文档，理解它的 API。

在 Software 3.0 时代，开源项目将变成工厂的“模具”。

我们可能不再直接引用库，而是告诉工厂：“用 React 的模具生产前端”。源代码（Source Code）本身可能会变成像汇编语言一样的中间产物/表示——只有 AI 读写它们，而人类只会面向Spec。

Software is ephemeral. Spec is eternal.（软件是瞬态的，规格是永恒的。）

从业者：从“码农”到“厂长”

这是最残酷但也最充满机遇的转变。软件公司的人才结构将呈现极端的两极分化：

• 订货人 (Product Owner / PM)：

负责定义“我要什么”。在工厂时代，生产成本趋近于零，“决策”的成本变得极高。你需要极强的业务洞察力、审美能力和用户同理心。因为工厂生产得太快了，如果你不知道什么是好的，你生产出来的就是一堆垃圾。

• 厂长 (Platform Engineer / Architect)：

负责维护工厂本身。你需要设计 Agent 之间的协作 SOP，优化工厂的“良品率”，集成最新的模型能力，确保工厂不会生产出有安全漏洞的产品。

• 消失的角色：

纯粹的、重复性的“代码搬运工”和初级 CRUD 工程师。他们的工作将完全被 Coder Agent 取代。

小结：工业革命的前夜

我们正处于软件行业“手工作坊”向“机器大工业”过渡的前夜，就像 1760 年代瓦特改良蒸汽机的前夜。

AI 软件工厂 不是科幻小说，它正在此时此刻发生。

Claude Code的Agent Team、针对编码智能体编排的Gas Town等，很可能都是这座工厂雏形的组件。

Karpathy 说的 “The hottest new programming language is English” 并不是一句玩笑。它意味着编程的门槛被无限降低，但构建系统的门槛被无限拔高。

无论你是想做“订货人”还是“厂长”，现在开始学习驾驭 AI Agent，学习如何构建和管理这些“数字员工”，是你拿到新时代船票的唯一方式。

你的“厂长”初体验

“软件工厂”的时代正在加速到来，我们每个人都将面临从“码农”到“订货人”或“厂长”的转型。想象一下，如果你现在拥有一座 24 小时不停工的“AI 软件工厂”，你最想让它为你生产一个什么样的系统？你认为在“机机协作”的未来，人类程序员最后的护城河在哪里？

欢迎在评论区分享你的脑洞与思考！让我们一起在这场软件工业革命的前夜寻找坐标。

如果这篇文章为你揭示了软件工程的未来，别忘了点个【赞】和【在看】，并转发给你的架构师朋友，大家一起未雨绸缪！

亲手搭建你的“微型工厂”

虽然完全自动化的“软件工厂”还在建设中，但其中的核心技术——Agent 编排、Spec 驱动开发——已经触手可及。

在我的极客时间专栏《AI 原生开发工作流实战》中，我将带你从零开始，利用 Claude Code，构建一个微型的 AI 软件流水线。

• 如何让 Coder Agent 和 QA Agent 左右互搏，实现代码自愈？
• 如何用 Spec 文档指挥整个生产流程？
• 如何构建一个能自我修复 Bug 的智能体闭环？

扫描下方二维码，开启你的 AI 架构师之旅。

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

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

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

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

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

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

本文永久链接 – https://tonybai.com/2026/02/05/ai-code-quality-surpasses-80-percent-of-human-programmers

大家好，我是Tony Bai。

随着 Claude Code、Gemini Cli、OpenCode 等 AI 智能体编程工具的爆火，技术圈里出现了一种流行的论调：

• “AI 写的代码质量不高，全是 Bug。”
• “简单的还行，复杂的还得靠人。”
• “AI 也就是个实习生水平。”

这些批评有道理吗？当然有。AI 确实会产生幻觉，逻辑偶尔会断裂。

但这种批评忽略了一个最基本的事实：我们拿来对比的基准（Baseline），往往是我们心目中“理想的资深工程师”。

请现在、立刻、马上打开你公司的 Github私有库或GitLab，随便点开一个两年前的遗留项目，看看里面的代码：

• 那些随意的变量命名 tmp, data1；
• 那些长达 800 行、没有任何注释的上帝函数；
• 那些为了赶上线而写死的 Magic Number；
• 那些复制粘贴了 5 遍却忘了改参数的逻辑……
• … …

这才是人类编码的常态。

如果我们摘下“幸存者偏差”的滤镜，从全局视角的大数定律来看，一个残酷的真相正在浮出水面：

AI 写的代码，虽然缺乏神韵，但其平均质量，可能已经超越了80%的人类程序员。

人类的“熵增” vs. AI 的“基准线”

人类写代码，本质上是一个对抗熵增的过程。而人类在这个过程中充满了弱点：

• 情绪与疲劳：下午 5 点写的代码，质量通常低于上午 10 点。为了赶着回家，我们会下意识地省略错误处理（catch (e) { // TODO }）。
• 知识盲区：即使是高级工程师，也记不住所有正则表达式的语法，或者某个冷门 API 的最佳实践。
• 懒惰：没人喜欢写文档，没人喜欢写单元测试。

相比之下，AI 简直就是代码规范的狂热信徒。

• 标准化：只要你 Prompt 给对了，它生成的代码默认符合 PEP8、Google Style、Effective Go 或任何你指定的规范。
• 全面性：它不厌其烦地写 Docstring，写类型注解，写样板代码。这些人类最讨厌干的脏活，是 AI 的舒适区。
• 无情绪：它不会因为被产品经理气到了，就故意写一段晦涩难懂的代码报复社会。

AI 也许写不出 Linux 内核那样的神作（上限），但它绝对不会写出连缩进都乱七八糟的垃圾。它极大地拉高了代码质量的底线。对于商业软件而言，底线的提升，往往比上限的突破更有价值。

自动驾驶的启示：一场“平庸”的胜利

我们可以用自动驾驶来做一个绝佳的类比。

每当特斯拉撞上路桩，媒体都会大肆报道。人们会说：“你看，机器还是不靠谱。”

但我们忽略了，此时此刻，全世界有成千上万的人类司机正在因为酒驾、看手机、打瞌睡、路怒症而制造车祸。

统计数据最终会证明：只要 AI 的故障率低于人类的平均故障率，它就是巨大的进步。

编程也是一样。

AI 编程的终局，不是写出完美无瑕的代码，而是写出比“人类平均水平”更可靠的代码。

当 AI 写的代码自带测试、自带文档、没有低级语法错误时，它就已经赢了。它消灭了“垃圾代码”。这将是一场“平庸的胜利”——软件工程将不再依赖个别天才的灵光一闪，而是依赖工业化、标准化的稳定产出。

范式转移：从“写代码”到“审代码”

如果承认 AI 已经是中级工程师水平，那么人类的角色必须发生根本性的转变。

以前，我们是 Coder（代码作者）。现在，我们被迫成为了 Reviewer（审查者）和 Architect（架构师）。

这其实对人类提出了更高的要求。

• 阅读理解能力：AI 一秒钟生成 100 行代码，你是否有能力在 10 秒内看出其中的逻辑漏洞？
• 系统设计能力：既然“搬砖”的工作 AI 做得比你好，你必须去思考“砖头该怎么垒”——系统架构、数据模型、业务边界。

更关键的是“自动化验证”。

既然人类读代码的速度跟不上 AI 写代码的速度，我们就必须建立一套**“机器审查机器”**的机制。

• AI 写代码，AI 写测试。
• AI 写实现，Compiler/Linter 做检查。

未来的软件质量，将不取决于你手写了多少行代码，而取决于你设计了多严密的护栏（Guardrails）和验收标准（Spec）。

小结：拥抱“无人编程”时代

我们可能正在经历软件工程领域的“无人驾驶时刻”。

初期，我们需要“安全员”（人类程序员）手扶方向盘，随时准备接管。

但随着模型能力的迭代（如 GPT-5.2、Gemini 3.0 Pro、Claude 4.5 Opus等），接管的频率会越来越低。

最终，“人类手写代码”可能会被视为一种不安全的行为——就像现在“酒后驾车”一样。

因为人类是不稳定的、不可控的。而经过严格 Prompt 工程和测试约束的 AI，是稳定、可控、可追溯的。

承认 AI 比我们写得好，并不丢人。

这意味着我们可以从繁琐的语法细节中解放出来，去追求那 1% 的“神来之笔”——创造力、同理心和对未来的想象。

你怎么看这个“80%”？

你认同这个残酷的结论吗？在你看来，AI 生成的代码最让你放心的地方在哪里？最让你担心的地方又在哪里？欢迎在评论区开启你的辩论模式！

如果这篇文章戳中了你的“痛点”，别忘了点个【赞】和【在看】，并转发给你的开发伙伴，看看他们敢不敢“承认”！

如何做 AI 的“安全员”？

AI 的代码质量已经超越了大多数初级工程师。作为一个**“AI 时代的 Tech Lead”**，你该如何建立一套机制，来驾驭这股庞大的算力？

在我的极客时间专栏**《AI 原生开发工作流实战》中，我们不谈如何写代码，而是谈如何审代码**，如何构建 Test-Driven 的自动化护栏。

• 如何利用 Claude Code 自动生成高覆盖率的测试用例？
• 如何构建 AI Code Reviewer 来预审代码？
• 如何用 Spec 约束 AI，防止幻觉？

让我们一起，从“写代码的人”，进化为“定义代码标准的人”。

扫描下方二维码，开启你的进阶之旅。

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

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

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

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

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

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

本文永久链接 – https://tonybai.com/2026/01/31/rust-vs-typescript-ai-agent-battleground-winner

大家好，我是Tony Bai。

如果把 2025 年定义为 Coding Agent（编程智能体） 的元年，那么刚刚开启的 2026 年，毫无疑问是 Personal AI Agent（个人助理智能体） 的元年。

以 openclaw（曾用名Clawdbot/Moltbot）为代表的开源项目，一夜之间席卷了 GitHub，让无数开发者为之疯狂。但在这一片繁荣的景象背后，作为一名敏锐的技术观察者，我发现了一个极其有趣的现象。

请环顾四周，看看那些最顶尖、最流行、体验最好的 AI Agent 项目：

• Claude Code (Anthropic 官方)：TypeScript。
• Gemini CLI (Google 官方)：TypeScript。
• openclaw(100k+ Star)：TypeScript。
• opencode以及配套的oh-my-opencode：TypeScript。

再看看Go语言，虽然没有占据头把交椅，但也稳稳地守住了一席之地。Gastown、crush 这些专注于并发和后端服务的 Agent 或Agent编排框架，依然拥有自己的一批拥趸。

但是，那个在过去几年呼声最高、号称“内存安全、性能无敌、将重写一切”的 Rust 去哪了？

在 AI Agent 的应用层战场上，尤其是像上述这些火出圈的AI Agent项目中，Rust 几乎“失声”了。除了 OpenAI 的 Codex 这个孤勇者之外，我们很难在主流的开源 Agent 列表中看到 Rust 的身影。

难道在 AI 时代的Agentic AI(智能体AI应用)阶段，Rust 输了吗？为什么被视作“玩具语言”的 TypeScript，反而成了 AI Agent的“母语”？

今天，我们不谈信仰，只谈架构。让我们深入剖析这场语言战争背后的第一性原理。

数据说话：统治 Agent 界的“TS 军团”

在下结论之前，我们先来看一组数据。

我统计了目前 GitHub Trending 上排名前 20 的 AI Agent 相关项目（排除单纯的模型推理框架，仅统计应用层 Agent），结果令人震惊：

• TypeScript / JavaScript：占比约 75%。

这是绝对的统治地位。无论是官方的 SDK，还是社区的野生项目，TS 都是默认选项。openclaw的作者 Peter Steinberger 本人就是 iOS 和 C++ 出身，但他依然选择了 TS 来构建他的个人AI助理。

• Python：占比约 15%。

依靠着 LangChain 和 AutoGen 的早期积累，Python 依然有存量优势，但在构建交互式 CLI 和 全栈应用 时，Python 的体验明显不如 TS 丝滑。

• Go：占比约 8%。

Go 凭借其单文件分发（Single Binary）和强大的并发模型，在Agent编排框架、Coding Agent，尤其是 DevOps 类的 Agent（如 K8s 运维助手）中表现亮眼。

• Rust：占比 < 2%。

除了 OpenAI 这种拥有无限工程资源的巨头敢用 Rust 重写 Codex，绝大多数独立开发者和创业公司似乎都对其敬而远之。

这个数据说明了什么？

说明在 Agent 这个特定的垂直领域，开发效率（Velocity） 已经彻底压倒了 运行效率（Performance）。

对于一个每秒钟只能输出 50 个 Token 的 LLM 来说，你的程序是 1ms 响应还是 10ms 响应，用户根本感觉不到区别。但你能否在 1 天内上线一个新功能，用户感知极强。

第一性原理：为什么是 TypeScript？

TypeScript 之所以能赢，绝不是因为运气，而是因为它在基因层面契合了 AI Agent 的特性。

AI 的“母语”是 JSON，而 TS 是 JSON 的亲兄弟

这是最核心的原因之一。

大模型（LLM）与外部世界交互的通用协议是什么？是 JSON。

无论是 Tool Calling（函数调用），还是 Structured Output（结构化输出），LLM 吐出来的都是 JSON。

• TypeScript: 处理 JSON 是原生的。JSON.parse() 之后，直接当作对象操作。配合 TypeScript 的 Interface 定义，你可以获得极佳的类型提示，但又保留了运行时的灵活性。

// TS: 轻松处理
interface ToolCall { name: string; args: any }
const call = JSON.parse(llmOutput) as ToolCall;

• Rust/Go: 你需要定义严格的 Struct。如果 LLM 发疯，多返回了一个字段，或者把 int 写成了 string，你的 serde_json 或 json.Unmarshal 就会直接报错 panic。在 AI 开发中，你需要的是“宽容”，而 Rust/Go 给你的却是“严厉”。

“Vibe Coding” 需要松弛感

openclaw 作者提到的 Vibe Coding，本质上是一种**“心流状态”**。我想到了一个功能，告诉 AI，AI 生成代码，我运行，成功。整个过程行云流水。

• TS 的体验： AI 生成了一段 TS 代码，可能类型有点小问题，用了 any，但能跑。我先跑起来看看效果，以后再修类型。It works > It is correct.
• Rust 的体验： AI 生成了一段 Rust 代码。10分钟后编译器报错：“生命周期不匹配”、“借用检查失败”、“unwrap 可能会 panic”。你被迫停下来，花 30 分钟和编译器搏斗。你的 Vibe（氛围）瞬间没了。

在探索性开发（Exploratory Development）阶段，Rust 的严格性变成了阻碍。

生态位的降维打击：全栈与浏览器

Agent 不仅仅是在终端跑。它需要操作浏览器（比如使用Playwright），需要写 Chrome 插件，需要构建 Web UI。

在这些领域，TS 是唯一的王。

如果你的 Agent 需要抓取网页数据，TS 有最成熟的库；如果你的 Agent 需要提供一个可视化的 Dashboard，TS 前后端通吃。

Rust 的尴尬与反击：退守“基础设施”

那么，Rust 真的输了吗？

从应用层来看，是的。但从基础设施层来看，Rust 依然是基石。

我们必须看清一个分层结构：

• L0 (Infrastructure): 向量数据库 (LanceDB, Qdrant)、推理引擎 (像Candle)、高性能网关。这是 Rust 的领地。
• L1 (Application): Agent 业务逻辑、流程编排、工具调用。这是 TypeScript 的领地。

Rust 并没有输，它只是退到了幕后。 Rust 成了 AI 的“地基”之一，而 TS 成了 AI 的“胶水”。

Agent 本质上就是把 LLM、数据库(记忆)、API 粘合在一起的胶水层。在这个层面上，灵活的胶水（TS）永远比坚硬的水泥（Rust）好用。

Go 的中间路线：CLI 界的“钉子户”

在这场战争中，Go 语言处于一个非常有趣的位置。它不像 TS 那么动态，也不像 Rust 那么死板。

Go 在 Agent 领域依然有一席之地，主要得益于两点：

1. Single Binary (单文件分发)：

如果你写一个 CLI Agent 分发给用户，Go 编译出来就是一个二进制文件，扔过去就能跑。TS 还需要用户装 Node.js，装依赖（npm install 地狱）。对于 openclaw 这种本地工具，其实 Go 也是一个极佳的选择（虽然作者选了 TS）。 2. 并发模型 (Goroutine)：

当我们需要构建 Agent Swarm (蜂群)，比如同时启动 100 个 Agent 去爬取数据、分析情报时，Go 的 Goroutine 模型比 TS 的 Promise.all 更轻量、更可控，性能也更佳。

像 Beads 和 Gastown 这样的项目选择 Go，正是看中了它在工程化和并发上的平衡。

小结：语言没有优劣，只有“生态位”

Openclaw 的爆火和 Claude Code 的选择，向我们揭示了 AI 时代的一个新真理：

在 Agent 应用层，灵活性（Flexibility）和容错性（Forgiveness）是第一生产力。

• 如果你想快速构建一个能够“听懂人话、调用工具”的 Agent，请毫不犹豫地选择 TypeScript。
• 如果你想构建一个高性能的 llm 路由网关、MCP Server 或 并发Agent编排工具，又或是Cli Agent，Go 是你不错的好帮手。
• 如果你想造一个新的 向量数据库 或 推理引擎，请拥抱 Rust。

不要带着旧时代的“语言鄙视链”进入新时代。

在 AI 眼里，代码只是它实现目标的工具。它写 TS 最顺手，那 TS 就是最好的语言。

Rust 没有输，它只是太“硬”了，不适合在这个充满幻觉和不确定性的 Agent 世界里跳舞。

你的“Agent 母语”

TypeScript 的统治力看似不可动摇，但技术圈永远不缺变数。在你心目中，开发 AI Agent 的最佳语言是哪一门？你愿意为了开发效率而忍受 TypeScript 的类型体操，还是为了极致性能去啃 Rust 的硬骨头？

欢迎在评论区捍卫你的“本命语言”！让我们看看谁才是真正的 Agent 之王。

如果这篇文章颠覆了你的技术选型观，别忘了点个【赞】和【在看】，并转发给还在纠结学什么的兄弟！

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

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

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

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

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

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

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

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

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

本文永久链接 – https://tonybai.com/2026/01/29/write-a-good-claude-md

大家好，我是Tony Bai。

在使用 Claude Code、Cursor 或 Gemini Cli 等 AI 编程工具时，你是否遇到过这样的情况：

明明在项目根目录写了 CLAUDE.md（或 AGENTS.md），洋洋洒洒列了几十条项目规范：“使用 TypeScript”、“不要用 any”、“单元测试覆盖率要达标”……

但 AI 就像个叛逆的实习生，经常对这些指令视而不见，反复犯同样的低级错误。

是你写的 Prompt 不够严厉吗？还是模型不够聪明？

最近，HumanLayer 团队发布的一篇深度分析文章揭示了真相：

问题恰恰在于你写得太多了。

Claude Code 的内部机制会给模型注入一条系统级提醒：

“IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant.”

（重要：此上下文可能与您的任务无关。除非高度相关，否则请忽略。）

这意味着，你的 CLAUDE.md 越臃肿，包含的无关信息越多，它被系统判定为“噪音”并整体忽略的概率就越大。

今天，我们来聊聊如何用工程化的思维，重构你的 AI 上下文管理。

第一性原理：AI 是无状态的“新员工”

要写好 CLAUDE.md，首先要理解 LLM 的本质：它是无状态的（Stateless）。

每次你开启一个新的 Session，对于 AI 来说，都是入职第一天。它对你的代码库一无所知。CLAUDE.md 是它唯一的“入职手册”和“长期记忆”。

但这并不意味着你要把公司历史全塞给它。一个优秀的入职手册应该包含什么？

HumanLayer 的文章中 总结了 “The Trinity”（三要素）：

1. WHAT（地图）： 技术栈是什么？项目结构是怎样的？（特别是 Monorepo，告诉它哪里是 App，哪里是 Lib）。
2. WHY（目标）： 这个项目的核心价值是什么？核心模块的职责边界在哪里？
3. HOW（工具）： 怎么构建？怎么跑测试？用 npm 还是 bun？

除此之外的任何废话，都是在消耗 AI 宝贵的注意力。

最佳实践一：少即是多 (Less is More)

研究表明，即便是最前沿的推理模型（Thinking Models），能稳定遵循的指令上限也就在 150-200 条左右。而小模型（如 Haiku 或 GPT-4o-mini）的遵循能力随着指令数量增加呈指数级下降。

更糟糕的是 “位置偏见（Position Bias）”。LLM 高度关注开头（System Prompt）和结尾（最新对话），夹在中间的 CLAUDE.md 如果过长，极易沦为“被遗忘的中间层”。

因此，请遵循以下黄金法则：

• 不要试图涵盖所有边缘情况。
• 将根目录的 CLAUDE.md 控制在 300 行以内，HumanLayer 的生产环境甚至控制在 60 行以内。
• 每一行都要问自己：“如果没有这句话，AI 真的干不了活吗？”

最佳实践二：渐进式披露 (Progressive Disclosure)

如果你确实有很多规范要交代，怎么办？

答案是：不要把所有鸡蛋放在一个篮子里。

想象一下，HR 会在入职第一天把 500 页的《数据库运维手册》扔给一个前端开发吗？不会。

你需要构建一套**“渐进式”**的文档体系：

1. 建立文档库：

在项目中创建一个 .ai/docs/ 目录，存放特定领域的指南：

• testing.md：详细的测试编写与运行指南。
• database.md：Schema 定义与迁移规范。
• architecture.md：核心架构图与数据流。

2. 建立索引：

在主 CLAUDE.md 中，只保留“触发器”：

• “编写或运行测试前，请务必阅读 .ai/docs/testing.md。”
• “涉及数据库变更时，请参考 .ai/docs/database.md。”

这样，当 AI 只是在写一个前端组件时，它的上下文窗口就不会被无关的后端 Schema 污染。保持注意力的纯净，是提升 AI 智商的关键。

最佳实践三：别把 AI 当 Linter 用

这是最常见的资源浪费：在 CLAUDE.md 里写了 50 行关于代码风格的规定——“缩进用 2 个空格”、“花括号不换行”、“变量名用驼峰”……

请记住：LLM 是昂贵的推理引擎，不是廉价的格式化工具。

让 AI 去关注缩进，就像让法拉利去送外卖，既贵又慢。而且，AI 即使知道规则，也经常因为概率性生成而“手滑”。

正确的解法是：Tooling > Prompting。

1. 配置工具： 使用 Prettier, Biome, ESLint, govet 等确定性工具来处理格式。
2. 设置 Hook： 配置 Claude Code 的 Stop Hook。如果 AI 生成的代码格式不对，让 Linter 报错，把错误信息喂回给 AI。 * AI: (生成代码) * System: “Lint Error: Missing semicolon.” * AI: “Ah, fixing it.”

AI 极其擅长修复报错，但并不擅长凭空遵守**“隐形的规则”**。

小结：杠杆的层级

在 AI 原生开发中，CLAUDE.md 处于**“杠杆层级”**的顶端。

• 写错一行代码 = 1 个 Bug。
• 写错一行 CLAUDE.md = 成百上千次错误的规划、错误的检索、错误的代码。

不要盲目依赖 /init 自动生成的文件，那只是个起点。你需要像维护核心代码一样，精心雕琢你的 CLAUDE.md。

现在，打开你的项目，检查一下那个文件。

删掉那些废话，把长文档拆分，把格式化交给工具。

给你的数字员工减负，它才能跑得更快。

资料链接：https://www.humanlayer.dev/blog/writing-a-good-claude-md

你的 CLAUDE.md 有几行？

读完这篇文章，不妨现在就去检查一下你项目里的 CLAUDE.md。它是清爽的“入职手册”，还是臃肿的“裹脚布”？你目前的行数是多少？

欢迎在评论区晒出你的“瘦身”成果！让我们一起给 AI 减负。

如果这篇文章帮你解决了 AI “不听话”的难题，别忘了点个【赞】和【在看】，并转发给你的团队，规范大家的 Prompt 工程！

构建工程化的 AI 工作流

CLAUDE.md 只是构建 AI 原生工作流的起点。

• 如何配置 Hooks 来实现自动化代码审查？
• 如何编写 Sub-Agents 来处理隔离的脏活累活？
• 如何设计 Slash Commands 来固化团队的 SOP？

如果你想深入掌握 Claude Code 的高阶玩法，不仅仅是写 Prompt，而是构建一套**“自动纠错、按需加载”**的工程化体系。

欢迎关注我的极客时间专栏**《AI 原生开发工作流实战》**。

我们不聊虚的，只讲能在生产环境中落地的 AI 工程实践。

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

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

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

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

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

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

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

Tony Bai 一个程序员的心路历程

• Google Go语言编码风格规范

  • Google Go语言编码风格规范：指南篇
  • Google Go语言编码风格规范：决定篇
  • Google Go语言编码风格规范：最佳实践篇

• Go语言第一课FAQ

• Go语言进阶课FAQ

• 关于我

• 我的技术专栏

• 文章列表

算了一笔账后，这个双十一我决定做个“亏本”买卖

• 十一月 11, 2025
• 0 条评论

本文永久链接 – https://tonybai.com/2025/11/11/zsxq-11-11-2025

大家好，我是Tony Bai。

又到了一年一度的双十一了，这个曾经的光棍节，如今已内化为一场全民的消费节。

作为一个埋头搞技术的程序员，我很少参与这类活动。但最近，我对自己运营的知识星球 “Go & AI 精进营” 做了一次“成本核算”，算完之后，我愣住了，然后决定：

今年双十一，我也“疯”一次，做个“亏本”买卖。

一个不严谨的科学计算：我的星球到底值多少钱？

我一直在思考，如何量化一个知识社群的价值。于是，我用“程序员的思维”，对“Go & AI 精进营”做了一次不严谨的价值评估。

1. 先算核心产出：“主菜”——体系化的微专栏

我的星球，最核心的价值是体系化的深度内容输出。今年，我开启了全新的**“微专栏”**模式，用 3-5 篇的篇幅(长的也有8-10篇的)，把一个垂直领域挖深讲透。

• 产出频率： 我计划的更新节奏，大概是平均 2 天一篇。一年 365 天，就算 180 篇。
• 打个折： 考虑到假期、偶尔的“状态不佳”，以及一些不可抗力（比如沉迷于某个新剧，或某本爱不释手的新书），我们打个骨折，算 150 篇深度内容。
• 单篇估值： 我看了一下市面上单篇付费文章的价格，咱们的深度和体系化程度，谦虚点，一篇算 5 块钱不过分吧？

初步计算：150 篇 x 5 元/篇 = 750 元

2. 再算“吸收率”：知识的“损耗”

当然，没人能 100% 吸收所有知识。就像网络传输有丢包，知识传递也有“损耗”。

假设大家都是追求精进的开发者，学习能力极强，知识吸收率能达到 80%。

价值折现：750 元 x 80% = 600 元

仅仅是核心专栏内容，折算后的价值就已经达到了 600 元。

这还没算上那些真正的“无价之宝”：

• 那些能帮你省下数小时、甚至数天调试时间的**“避坑指南”**…
• 一个可能让你在面试中脱颖而出的关键问题解答…
• 第一时间获取Go & AI 前沿动态的“情报费”…
• 链接一群高质量 Gopher 的“社交网络费”…
• 以及，我个人**“随叫随到”**的有问必答服务…

这些“附加值”，其价值更是难以估量。

一个“亏本”的决定：双十一，仅此一天

算完这笔账，再看看星球目前的定价，我发现自己一直在做“慈善”。（手动狗头）

既然如此，不如“慈善”到底。

我决定，在今年的双十一（11 月 11 日）当天，为所有希望加入“Go & AI 精进营”的新朋友，提供一次全年仅此一天的特别优惠。

双十一当天（00:00 – 23:59）

加入我的知识星球“Go & AI 精进营”

享受全年唯一一次 8 折优惠！

仅此一天，错过再等一年！

我很少做活动，因为我相信，真正的价值不需要频繁的折扣来证明。但我也希望，在双十一这个特殊的日子里，能为那些一直在关注、但稍有犹豫的朋友，提供一个“临门一脚”的绝佳机会。

扫描下方二维码，或点击“这里”，立即领取 8 折优惠券，双十一当天使用

你将加入一个怎样的社群？

“Go & AI 精进营”不是一个靠打卡来制造热闹的地方，而是一个**“高手过招的茶馆”和“深度研讨的实验室”**。

在这里，我们共同探讨：

• Go 语言的底层原理与高级工程实践
• AI Agent 与大模型应用的落地
• 云原生与分布式系统的前沿

2025 年，我们已经推出了：

• 《Go测试之道：从测试金字塔到高级实践》
• 《Go模块构建与依赖管理》
• 《Go网络编程全解》
• 《Go context解惑》
• 《Go开发者的数据库设计之道》
• 《Go 系统编程》
• 《用Go 解锁位运算之美》
• 《Go TUI开发入门》
• 《Go密码学101》
• 《Gemini CLI：重新定义命令行AI开发》
• 《Go并发调度艺术》
• 《征服Go并发测试》
• 《Gopher 的 AI 原生应用开发第一课》
• 《Go语言进阶课》

更多已推出的微专栏信息，请参见《我的技术专栏》页面。

未来几个月，我们即将启程：

• 《AI原生开发工作流实战课》（与极客时间同源）
• 《Go工具创造者指南：从代码分析、构建Linter到代码生成》
• 《写给 Go 工程师的 DDD 设计实录》
• 《代码中的数学》
• 《Go 数据压缩通识课》
• …以及更多硬核的微专栏

而这，仅仅是开始。

展望 2026 年，我的规划将更加聚焦于体系化和实战。 我计划将今年的“微专栏”系列进行迭代和整合，打磨成一系列完整的、覆盖从入门到精通的“Go 工程师的 AI 实战微课程”。同时，我们也会继续深入 Go 的底层，探索更多硬核的系统可观测和性能优化主题。

加入我们，你投资的不仅是 2025 年的内容，更是通往 2026 年及以后，一张更具竞争力的自己的“早鸟票”。

如果你渴望在一个高质量的圈子里，与一群志同道合的 Gopher 共同成长，探索 Go & AI 的前沿，那么，这可能是你今年最值得的一笔“自我投资”。

最后提醒一次：8 折优惠，仅限双十一当天。

期待在星球里，看到你的身影。

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

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

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

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

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

想系统学习Go，构建扎实的知识体系？

我的新书《Go语言第一课》是你的首选。源自2.4万人好评的极客时间专栏，内容全面升级，同步至Go 1.24。首发期有专属五折优惠，不到40元即可入手，扫码即可拥有这本300页的Go语言入门宝典，即刻开启你的Go语言高效学习之旅！

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

本文永久链接 – https://tonybai.com/2025/08/24/junior-engineer-survival-guide-in-ai-age

大家好，我是Tony Bai。

这是一个对初级工程师而言，最好也最坏的时代。

说它“最好”，是因为我们从未拥有过如此强大的工具。一名刚走出校门的毕业生，在入职的第一天，就能手握Claude Code、ChatGPT、Gemini Cli、Cursor、Copilot 等强大的 AI 编程助手。面对一个从未接触过的复杂任务——比如，为一个 Go 项目编写一个复杂的 gRPC 中间件——他可能只需要组织几次提示词，一段看起来完美、功能齐全、甚至带着单元测试的代码就诞生了。

那种“我什么都行”的强大感和即时满足感，是十年前的我完全无法想象的。

但说它“最坏”，也恰恰源于此。在这种令人沉醉的“魔幻”体验背后，一个直击灵魂的问题正在浮现：

这种惊人的“效率”，是在加速你的成长，还是在为你铺设一条通往“能力空心化”的捷径？

今天，我想和大家一起聊聊这个话题。这不仅是一份给初级工程师的生存指南，更是我们每一个身处 AI 浪潮中的技术人，都应该进行的深刻反思。

“浅层技能” vs “内功心法”：AI 正在拉开的差距

要理解 AI 带来的潜在风险，我们首先需要区分两种截然不同的技能：“浅层技能”与“内功心法”。

“浅层技能”，关注的是**“是什么”（”What”）**。在 AI 时代的初期，这主要体现为：

• 擅长编写精妙的 Prompt。
• 能快速地从 AI 处获得“能用”的代码片段。
• 熟练地进行“复制-粘贴-修改”的“胶水”工作。

而如今，随着 Gemini CLI、Claude Code 这类编码智能体（Coding Agent）以及深度集成在 IDE 中的 AI 工具的兴起，这种“浅层技能”又演化出了一个更集成、也更具迷惑性的新形态。

“复制-粘贴”的动作消失了。取而代之的，是 Agent 直接读取你的整个代码库，然后给你一个可以直接应用的变更集（diff）。在这里，“浅层技能”表现为：

• 将高阶的、模糊的任务指令（‘重构这个文件’、‘修复这个bug’）下发给 Agent。
• 对 Agent 提出的变更集进行表面化的审查——检查代码风格是否一致、命名是否规范，但缺乏对底层逻辑、性能陷阱和安全隐患的深度洞察。
• 最终，熟练地点击‘应用’（Apply）或‘接受’（Accept）按钮，成为一个高效的“变更批准员”。

你看，无论是“复制代码”还是“批准变更”，其本质是相通的：你依然只停留在知道“是什么”，而没有深入到“为什么”。 你知道这段由 Agent 修改的代码能工作，但你很可能依然不清楚它背后的原理。这种新模式甚至更危险，因为它让你感觉更“专业”，更容易在不知不觉中放弃思考。

而**“内功心法”，关注的则是“为什么”（The “Why”）和“怎么做”（The “How”）**。这包括：

• 设计模式：为什么在这里 AI 选择用工厂模式，而不是单例模式？这两种模式的权衡是什么？
• 数据结构与算法：AI 生成的这个函数，其核心数据结构是什么？它的时间复杂度和空间复杂度在各种情况（最好、最坏、平均）下分别是多少？
• 架构权衡：这段看似独立的代码，被集成到系统中后，是会提升整个系统的内聚性，还是会引入一个危险的耦合点？
• 调试能力：当这段“完美”的 AI 代码，在生产环境中因为一个罕见的并发条件而出现诡异的 Bug 时，你有能力深入其中，定位并解决问题吗？

“浅层技能”决定了你使用工具的熟练度，而“内功心法”则决定了你作为一名工程师的能力天花板。

“舒适”的代价：正在累积的“认知负债”

问题在于，AI 工具太“舒适”了。它让我们能轻易地绕过那些艰难的、需要深度思考的“内功”修炼，直接获得“浅层”的结果。这种舒适感，正在让我们不知不觉地背上沉重的**“认知负债”（Cognitive Debt）**。

这个概念精辟地描述了一种权衡：我们用即时的便利，换取了长期的批判性思维、记忆力、以及创造性自主权的丧失。 你正在向机器借用脑力，但这笔债，未来需要连本带利地偿还。

最近的一项科学研究，用数据血淋淋地揭示了这一点。研究者将参与者分为三组写论文：纯脑力组、搜索引擎组和 LLM 组。结果令人震惊：

在 LLM 组中，83% 的参与者在写完论文后，几乎无法复述出自己文章中的任何观点(见下图)。而在另外两组，几乎每个人都能做到。

这证明了，当我们把思考过程完全外包给 AI 时，知识并没有真正“流经”我们的大脑，我们只是成为了一个信息的“搬运工”。

这背后，是纳西姆·塔勒布在其著作《反脆弱》中提到的深刻哲理：小的压力和不适，会让我们变得更强大。

• 肌肉，需要通过举起沉重的杠铃，在撕裂和修复中才能生长。
• 我们的大脑，同样需要通过“精神举重”——也就是主动思考、艰难探索、反复试错的“摩擦力”——才能成长。

而初级工程师的职业生涯前三年，正是进行这种“精神举重”、构建个人能力护城河最宝贵的黄金时期。如果在这个阶段，你沉迷于 AI 带来的舒适感，持续累积“认知负债”，无异于在一个本应最大化“肌肉增长”的年纪，选择了全程坐轮椅。

其长期危害是显而易见的：

1. 成长停滞：解决问题的“认知肌肉”因缺乏锻炼而萎缩。
2. 危险的“信心差”：你产生了一种“我能搞定任何代码”的虚假自信，但这与“我能维护和解释任何我写的代码”的真实能力之间，存在着巨大的鸿沟。这在团队协作和处理线上故障时，是极其危险的。
3. 沦为“API 粘合工”：长期以往，你可能会彻底丧失从零开始构建系统的能力，沦为只会将 AI 生成的黑箱代码块“粘合”在一起的低阶操作员，失去了真正的工程创造力和不可替代性。

“破局”指南：如何成为 AI 的主人，而非奴隶？

那么，我们该如何打破这个困局？关键在于心态的转变和方法的调整。你需要将 AI 从一个无所不知的**“神谕”（Oracle），转变为一个需要你引导和挑战的“陪练”**。

这里有四条具体的实战法则：

法则一：“先思后问”法则

在向 AI 提问前，强迫自己先进行独立思考。用纸笔、伪代码或注释，勾勒出你自己的解决方案轮廓。哪怕这个方案很粗糙，甚至可能是错的，这个思考的过程本身就是一次宝贵的“精神举重”。

然后，你可以这样做：

“不要让 AI 直接为你解题；相反，提供你自己的解法，让它解释你可能错在哪里，或者有哪些可以改进的地方。”

通过这种方式，你把 AI 从一个“答案机”变为一个能启发你、挑战你的“批判性思维伙伴”。你始终是思考的主导者。

法则二：“刨根问底”法则

永远不要满足于 AI 给出的第一份“能用”的代码。对它生成的每一段关键代码，都要像对待一位资深同事的 Code Review 意见一样，进行苏格拉底式的反复追问：

• “你为什么选择这种数据结构？它和另一种方案相比，优劣势分别是什么？”
• “这段代码的时间复杂度和空间复杂度是多少？在什么情况下会达到最坏情况？”
• “请为这段代码生成五个可能会导致它出错的边缘案例（corner cases）。”
• “这段代码遵循了哪些设计模式？请为我解释这个模式的核心思想。”

通过这种刨根问底，你把 AI 从一个“代码生成器”，变成了一个免费的、24小时在线的、极具耐心的私人导师。

法则三：“刻意练习”法则

定期进行**“无 AI 编程”**的刻意练习。这就像健身房里的“力量训练日”。给自己设定一些小项目、算法题，或者工作中的某个非紧急模块，规定自己在不使用任何 AI 代码生成辅助的情况下，从零开始完整地实现它。

这个过程可能会让你感到“不适”，速度会很慢，甚至会碰壁。但请记住塔勒布的教诲：不适感不是麻烦，而是训练场。 这正是你构建底层能力、“流血流汗”的真实成长过程。

法则四：“源码为师”法则

当 AI 生成了一段使用了你从未见过的库函数或框架特性的代码时，不要只满足于知道“怎么用”。花15分钟时间，去看看那个函数或特性的源码实现。

这是理解其背后原理、设计哲学和实现细节的最直接方式。AI 可以为你指出一条通往宝藏的道路，但路边的风景和地下的矿藏，需要你自己去探索和挖掘。

你的不可替代性，藏在 AI 的“盲区”里

遵循以上法则，你会发现，AI 不仅不会成为你成长的障碍，反而会成为你成长的强大加速器。更重要的是，它会帮助你将精力聚焦在那些 AI 永远无法取代的、真正体现工程师价值的领域——也就是 AI 的“盲区”。

• 深度理解业务：AI 不懂你的用户，不懂你的商业模式。将技术与业务场景深度结合，提供有洞察力的解决方案，这是你的核心价值。
• 系统性思考：AI 能生成一个函数，但它尚无法设计一个健壮、可扩展、可维护的大规模生产级系统。培养自己的架构思维和全局视野，是你拉开差距的关键。
• 人际协作与沟通：理解团队成员的需求，清晰地阐述技术方案的利弊，组织有效的讨论，推动项目落地。这些“软技能”，在 AI 时代变得比以往任何时候都更加重要。

小结：别在黄金时代，选择一条最容易的路

职业生涯的初期，是一个人构建个人“能力护城河”最关键的时期。在这个阶段，最宝贵的不是表面的“效率”，而是**“成长深度”**。

AI 时代，给了我们前所未有的强大工具，但工具的价值，永远取决于使用者的智慧。

所以，请警惕那些让你过于舒适的捷径。不要在最需要“扎马步”的年纪，沉迷于“轻功”带来的快感。 真正的成长，永远伴随着求索的痛苦和突破的喜悦。让我们去拥抱那些有益的“摩擦力”，掌握那些 AI 无法生成的“内功心法”。

选择那条更难、但更有价值的路，你才能在未来的技术浪潮中，真正地立于不败之地。

参考资料

-《Your Brain on ChatGPT: Accumulation of Cognitive Debt when Using an AI Assistant for Essay Writing Task》- https://arxiv.org/pdf/2506.08872v1

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

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

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

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

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

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

Tony Bai 一个程序员的心路历程

• Google Go语言编码风格规范

  • Google Go语言编码风格规范：指南篇
  • Google Go语言编码风格规范：决定篇
  • Google Go语言编码风格规范：最佳实践篇

• Go语言第一课FAQ

• Go语言进阶课FAQ

• 关于我

• 我的技术专栏

• 文章列表

想用Go复刻“Claude Code”？那你得先补上TUI这一课

• 八月 8, 2025
• 0 条评论

本文永久链接 – https://tonybai.com/2025/08/08/go-tui-primer

大家好，我是Tony Bai。

最近，AI 圈最火的莫过于Anthropic推出的“Claude Code”– 一款基于终端的编码智能体工具：

当你在终端窗口里，看着 AI 实时地帮你生成、修改、编译、测试和运行一个 Web 应用，并且能立刻看到输出和反馈时，那种感觉只能用“震撼”来形容。

作为一名 Go 开发者，我当时脑子里冒出的第一个念头就是：

“如果我能用 Go，在自己的终端里，也实现一套这样的工作流，那该多酷？”

想象一下：你写一个 CLI 工具，它可以连接到任何一个大模型 API。你给它一个需求，比如“帮我写一个处理用户注册的 Go HTTP Handler”，然后：

1. 你的终端左侧窗口，开始像打字机一样，流式输出 AI 生成的 Go 代码。
2. 右侧窗口，实时显示出代码的编译状态、单元测试的进度条和结果。
3. 当代码完成时，它自动运行起来，并告诉你：“服务已在 localhost:8080 启动，请测试。”

这个场景，就是我们开发者梦想中的“编码伙伴”，也是一个宏大但并非遥不可及的目标。

要实现这个目标，除了调用 AI 的 API，最关键、也是我们最容易忽视的一环是——如何构建这样一个复杂的、多窗口的、可实时交互的终端界面？

答案，就是 TUI (Terminal User Interface) 开发。

你的下一个 Go 程序，值得拥有一张“脸”

我们很多 Go 开发者，都把技能点加在了后端性能、并发模型上，这当然没错。但我们常常忽略了程序的“脸面”——它的交互体验。

传统的 CLI 工具，就像一个只会用专业术语说话的机器人，强大但冷漠。而一个现代的 TUI 应用，则像一个能与你沟通的智能助手。

它能在终端这个我们最熟悉、最高效的环境里，提供类似图形界面的直观体验：

• 多窗口布局： 像 VS Code 一样，清晰地划分代码区、状态区、输出区。
• 实时反馈： 进度条、加载动画、状态指示器，让一切尽在掌握。
• 交互式组件： 可滚动的列表、可输入的文本框、可选择的菜单，告别死记硬背。

而 Go 语言，凭借其无与伦比的性能和静态编译能力，正是构建这类高性能 TUI 应用的最佳选择。

但这条路，自学起来并不容易

当你兴致勃勃地去 GitHub 搜索 Go TUI 库时，你可能会发现一些挑战：

• 陡峭的思维转变： 最流行的库 bubbletea，用的是一种函数式的 Elm 架构。它的 Model-View-Update 模式，对于习惯了传统命令式编程的 Gopher 来说，像是在学习一门“外语”。
• 知识点零散： 如何处理异步任务？如何设计可复用的组件？如何美化 UI？这些问题的答案散落在各种英文文档和 GitHub Issue 里，很难形成体系。
• 缺乏实战引导： 看完基础教程，能写个计数器，但一到真实项目就无从下手，不知道如何将简单的 Demo 组合成一个复杂的应用。

为了帮你扫清这些障碍，让你能把精力聚焦在创造性的工作上，而不是在入门的坑里反复挣扎，我倾力打造了一门付费微专栏——《重塑终端：Go TUI 开发入门课》。

这门课，就是你通往“用 Go 复刻 Claude Code”梦想的第一块，也是最重要的一块基石。

在这门课里，你将得到什么？

本专栏专为有一定 Go 基础，但对 TUI 开发感到陌生或困惑的你而设计。无论你是想打造惊艳的开源工具，还是想给内部平台配一个更酷的客户端，你都能在这里找到清晰的路径。

通过 5 讲精心设计的内容，你将：

• 第 1 讲 | 新利器： 我们将重新认识 TUI，理解它为何在 AI 时代成为 Go 开发者的“新利器”，并为你建立一套坚实的理论认知框架。
• 第 2 讲 | 核心架构： 彻底解密 bubbletea 背后的 Elm 架构。我将用最直观的方式，带你掌握 Model-View-Update 这一核心思想，这是编写可维护 TUI 应用的基石。
• 第 3 讲 | 交互之魂： 深入 bubbletea 的消息（Msg）与命令（Cmd）系统。你将学会如何处理键盘、鼠标等各种输入，以及如何优雅地执行网络请求等异步任务而不阻塞界面。
• 第 4 讲 | 终端美学： 学习使用 Charm 生态中的 Lip Gloss 和 Bubbles 库。我将教你如何为你的 TUI 应用添加漂亮的色彩、布局和边框，并快速集成输入框、列表、进度条等现成组件。
• 第 5 讲 | 实战串讲： 我们将所有知识融会贯通，从零开始，手把手带你构建一个功能完备的“终端版 GitHub Issue 查看器(如下图)”。这个项目将成为你的代码库，为你未来的 TUI 开发提供一个绝佳的脚手架。

完成这门课后，你将不仅仅是“会用”bubbletea，而是真正“理解”了现代 TUI 应用的构建哲学。你将有足够的能力和信心，去挑战那个“用 Go 复刻 Claude Code”的终极目标。

梦想再宏大，也要从第一行代码开始。而一个好的课程，能让你的第一行代码，走在最正确的路上。

今天，微专栏正式上线！扫描下方二维码，立即订阅。让我们一起，用 Go 重塑终端，开启属于你的 AI + TUI 开发之旅！

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

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

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

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

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

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

本文永久链接 – https://tonybai.com/2025/07/25/how-anthropic-teams-use-claude-code

当 AI 编程助手从简单的代码补全工具，演变为深度集成于开发者工作流核心的“终端原生 AI”（Terminal-native AI）时，一个根本性的问题浮现出来：顶尖团队究竟是如何在日常工作中驾驭这股新力量的？ 理论和演示层出不穷，但真实、大规模、跨职能的实践案例却凤毛麟角。

现在，我们得到了来自源头的答案。

Anthropic 公司今天发布了一份极为详尽的内部案例研究，为我们提供了一次罕见的“幕后观察”机会，让我们得以一窥其内部团队——从最核心的产品开发、安全工程，到数据科学、乃至法务和营销团队——是如何将 Claude Code 作为其日常工作的核心伙伴。

这份案例研究的意义非凡，因为它不再是关于“AI 能做什么”的畅想，而是关于“AI 正在如何做”的实录。从数据工程师借助截图在几分钟内解决复杂的 Kubernetes 故障，到毫无编程经验的财务团队用自然语言构建起全自动的数据处理流；从新员工入职第一天就能高效导航庞大的单一代码库，到产品设计师直接将视觉稿转化为可交互的前端原型——我们看到的是一种工作范式的彻底变革以及生产力的“爆炸”！

本文就翻译自Anthropic的这篇博客文章《How Anthropic teams use Claude Code》，希望各位读者都能从中受益。

Anthropic 的内部团队正在通过 Claude Code 改变其工作流程，使开发人员和非技术人员能够处理复杂项目、自动化任务，并弥合之前限制他们生产力的技能差距。

为了了解更多，我们与以下团队进行了交谈：

• 数据基础设施
• 产品开发
• 安全工程
• 推理
• 数据科学与可视化
• 产品工程
• 增长营销
• 产品设计
• 强化学习 (RL) 工程
• 法务

通过这些访谈，我们深入了解了不同部门如何使用 Claude Code、它对其工作的影响，以及为其他考虑采用该工具的组织提供的建议。

Claude Code 在数据基础设施领域的应用

数据基础设施团队为全公司的团队组织所有业务数据。他们使用 Claude Code 来自动化常规的数据工程任务、解决复杂的基础设施问题，并为非技术团队成员创建文档化的工作流程，以便他们能够独立地访问和操作数据。

主要 Claude Code 用例

使用截图进行 Kubernetes 调试

当 Kubernetes 集群出现故障且无法调度新的 pod 时，团队使用 Claude Code 来诊断问题。他们将仪表盘的截图输入到 Claude Code 中，后者引导他们逐个菜单地浏览 Google Cloud 的 UI，直到发现一个指示 pod IP 地址耗尽的警告。随后，Claude Code 提供了创建新 IP 池并将其添加到集群的确切命令，从而无需网络专家的介入。

为财务团队提供纯文本工作流

工程师向财务团队成员展示了如何编写描述其数据工作流的纯文本文件，然后将其加载到 Claude Code 中以实现完全自动化的执行。没有编程经验的员工可以描述诸如“查询此仪表盘，获取信息，运行这些查询，生成 Excel 输出”之类的步骤，Claude Code 将执行整个工作流，包括询问像日期这样的必需输入。

为新员工提供代码库导航

当新的数据科学家加入团队时，他们被引导使用 Claude Code 来导航庞大的代码库。Claude Code 会读取他们的 Claude.md 文件，为特定任务识别相关文件，解释数据管道的依赖关系，并帮助新员工理解哪些上游数据源为仪表盘提供数据。这取代了传统的数据目录和可发现性工具。

会话结束时的文档更新

团队会要求 Claude Code 总结已完成的工作会话，并在每个任务结束时提出改进建议。这就创建了一个持续改进的循环，其中 Claude Code 帮助优化 Claude.md 文件。

跨多个实例的并行任务管理

在处理长时间运行的数据任务时，团队会在不同的代码仓库中为不同的项目打开多个 Claude Code 实例。每个实例都保持完整的上下文，因此当他们在数小时或数天后切换回来时，Claude Code 能准确记住他们当时正在做什么以及进行到哪里，从而实现了真正的并行工作流管理而不会丢失上下文。

团队影响

无需专业知识即可解决基础设施问题

解决了通常需要系统或网络团队成员介入的 Kubernetes 集群问题，使用 Claude Code 诊断问题并提供精确的修复方案。

加速入职流程

新的数据分析师和团队成员可以迅速理解复杂的系统，并在没有大量指导的情况下做出有意义的贡献。

增强的支持工作流

Claude Code 可以处理更大量的数据并识别异常（例如监控 200 个仪表盘），这是人类手动审查无法做到的。

实现了跨团队自助服务

没有编程经验的财务团队现在可以独立执行复杂的数据工作流。

来自数据基础设施团队的顶级建议

编写详细的 Claude.md 文件

团队表示，你在 Claude.md 文件中记录工作流、工具和期望越详尽，Claude Code 的表现就越好。这使得 Claude Code 在处理诸如根据现有设计模式建立新数据管道之类的常规任务时表现出色。

对敏感数据使用 MCP 服务器而非 CLI

他们建议使用 MCP 服务器而不是 BigQuery CLI，以便更好地控制 Claude Code 的访问权限，尤其是在处理需要日志记录或有潜在隐私问题的敏感数据时。

分享使用会话

团队举办了分享会，成员们在会上演示了各自的 Claude Code 工作流程。这有助于传播最佳实践，并展示了他们可能未曾发现的各种工具使用方法。

Claude Code 在产品开发领域的应用

Claude Code 产品开发团队使用他们自己的产品来为 Claude Code 构建更新，扩展产品的企业级功能和智能体体循环（agentic loop）功能。

主要 Claude Code 用例

使用自动接受模式进行快速原型设计

工程师通过启用“自动接受模式”（shift+tab）来进行快速原型设计，并建立自主循环，让 Claude 编写代码、运行测试并持续迭代。他们给 Claude 提出他们不熟悉的抽象问题，让它自主工作，然后在最终完善前审查那 80% 完成度的解决方案。团队建议从一个干净的 git 状态开始，并定期提交检查点，以便在 Claude 偏离轨道时可以轻松地恢复任何不正确的更改。

核心功能的同步编码

对于触及应用核心业务逻辑的更关键的功能，团队与 Claude Code 同步工作，提供带有具体实现指令的详细提示。他们在实时监控整个过程，以确保代码质量、风格指南合规性和正确的架构，同时让 Claude 处理重复性的编码工作。

构建 Vim 模式

他们最成功的异步项目之一是为 Claude Code 实现 Vim 键位绑定。他们要求 Claude 构建整个功能，最终实现的约 70% 来自 Claude 的自主工作，只需几次迭代即可完成。

测试生成与错误修复

团队在实现功能后，使用 Claude Code 编写全面的测试，并处理在代码审查中发现的简单错误修复。他们还使用 GitHub Actions 让 Claude 自动处理 Pull Request 中的评论，如格式化问题或函数重命名。

代码库探索

在处理不熟悉的代码库（如单一代码库或 API 端）时，团队使用 Claude Code 快速理解系统的工作方式。他们不再等待 Slack 上的回复，而是直接向 Claude 询问解释和代码引用，从而在上下文切换中节省了大量时间。

团队影响

更快的特性实现

Claude Code 成功地实现了像 Vim 模式这样的复杂功能，其中 70% 的代码由 Claude 自主编写。

提高开发速度

该工具可以快速地为功能制作原型并迭代想法，而不会陷入实现细节的泥潭。

通过自动化测试提升代码质量

Claude 生成全面的测试并处理常规的错误修复，在减少手动工作的同时保持了高标准。

更好的代码库探索

团队成员可以迅速熟悉单一代码库中不熟悉的部分，而无需等待同事的回复。

来自 Claude Code 团队的顶级建议

创建自给自足的循环

设置 Claude，让它通过自动运行构建、测试和代码检查来验证自己的工作。这使得 Claude 能够更长时间地自主工作并发现自己的错误，在要求它在编写代码之前生成测试时尤其有效。

培养任务分类的直觉

学会区分适合异步处理的任务（外围功能、原型设计）和需要同步监督的任务（核心业务逻辑、关键修复）。产品边缘的抽象任务可以用“自动接受模式”处理，而核心功能则需要更密切的监督。

形成清晰、详细的提示

当组件具有相似的名称或功能时，在你的请求中要极其具体。你的提示越好、越详细，你就越能相信 Claude 能独立工作，而不会意外地更改代码库的错误部分。

Claude Code 在安全工程领域的应用

安全工程团队专注于保障软件开发生命周期、供应链安全和开发环境安全。他们广泛使用 Claude Code 进行代码编写和调试。

主要 Claude Code 用例

复杂的基础设施调试

在处理事故时，他们向 Claude Code 提供堆栈跟踪和文档，要求它在代码库中追踪控制流。这大大缩短了生产问题的解决时间，使他们能够在大约 5 分钟内理解通常需要 10-15 分钟手动代码扫描才能发现的问题。

Terraform 代码审查与分析

对于需要安全审批的基础设施变更，团队将 Terraform 计划复制到 Claude Code 中，并提问“这会做什么？我会后悔吗？”。这创建了更紧密的反馈循环，使安全团队能更快地审查和批准基础设施变更，减少了开发过程中的瓶颈。

文档合成与操作手册（runbooks）

Claude Code 能消化多个文档源，并创建 Markdown 格式的操作手册、故障排除指南和概述。团队使用这些浓缩的文档作为调试实际问题的上下文，创建了比搜索完整知识库更高效的工作流程。

测试驱动的开发工作流

他们不再遵循以前“设计文档 → 粗糙代码 → 重构 → 放弃测试”的模式，而是要求 Claude Code 提供伪代码，引导它完成测试驱动的开发，并在其卡住时定期介入以引导方向，从而产生更可靠和可测试的代码。

上下文切换与项目入职

在为像“dependant”（一个用于安全审批工作流的 Web 应用）这样的现有项目贡献代码时，他们使用 Claude Code 编写、审查和执行用 Markdown 编写并存储在代码库中的规范，使得在几天内（而非几周）就能做出有意义的贡献。

团队影响

缩短事故解决时间

通常需要 10-15 分钟手动代码扫描的基础设施调试，现在大约只需要 5 分钟。

改进的安全审查周期

用于安全审批的 Terraform 代码审查速度更快，消除了开发者在等待安全团队批准时的阻塞。

增强的跨职能贡献

团队成员可以在几天内为项目做出有意义的贡献，而无需数周的上下文构建。

更好的文档工作流

从多个来源合成的故障排除指南和操作手册，创建了更高效的调试流程。

来自安全工程团队的顶级建议

广泛使用自定义斜杠命令

安全工程团队使用了整个单一代码库中 50% 的自定义斜杠命令实现。这些自定义命令简化了特定的工作流程并加速了重复性任务。

让 Claude 先说

他们不再是提出针对性问题以生成代码片段，而是告诉 Claude Code “边做边提交你的工作”，让它在定期检查的情况下自主工作，从而得到更全面的解决方案。

充分利用其文档能力

除了编码，Claude Code 在合成文档和创建结构化输出方面表现出色。团队提供写作样本和格式偏好，以获得可以立即在 Slack、Google Docs 和其他工具中使用的文档，从而避免界面切换的疲劳。

Claude Code 在推理领域的应用

推理团队管理着在 Claude 读取你的提示并生成响应时存储信息的内存系统。团队成员，尤其是那些刚接触机器学习的人，可以广泛使用 Claude Code 来弥补知识差距并加速他们的工作。

主要 Claude Code 用例

代码库理解与入职

团队严重依赖 Claude Code 在加入复杂代码库时快速理解其架构。他们不再手动搜索 GitHub 仓库，而是要求 Claude 找到调用特定功能的文件，在几秒钟内得到结果，而不是询问同事或手动搜索。

带边缘案例覆盖的单元测试生成

在编写完核心功能后，他们会要求 Claude 编写全面的单元测试。Claude 会自动包含被忽略的边缘案例，在几分钟内完成通常需要大量时间和脑力的工作，就像一个他们可以审查的编码助手。

机器学习概念解释

没有机器学习背景的团队成员依赖 Claude 来解释特定模型的功能和设置。以前需要一个小时谷歌搜索和阅读文档的事情，现在只需要 10-20 分钟，研究时间减少了 80%。

跨语言代码翻译

在测试不同编程语言的功能时，团队会解释他们想要测试的内容，然后 Claude 会用所需的语言（如 Rust）编写逻辑，从而无需为了测试目的而学习新语言。

命令记忆与 Kubernetes 管理

他们不再需要记住复杂的 Kubernetes 命令，而是向 Claude 询问正确的语法，比如“如何获取所有 pod 或部署的状态”，并获得他们基础设施工作所需的确切命令。

团队影响

加速机器学习概念学习

通过 Claude Code，他们的研究时间减少了 80%，以前需要一个小时谷歌搜索的事情现在只需要 10-20 分钟。

更快的代码库导航

该工具可以帮助团队成员在几秒钟内找到相关文件并理解系统架构，而不用依赖同事分享知识，后者通常需要几天时间。

全面的测试覆盖

Claude 自动生成带有边缘案例的单元测试，在保持代码质量的同时减轻了脑力负担。

消除语言障碍

团队可以在不熟悉的情况下，在像 Rust 这样的语言中实现功能，而无需学习它。

来自推理团队的顶级建议

首先测试知识库功能

尝试问各种问题，看看 Claude 的回答是否比谷歌搜索更快。如果它更快、更准确，那么它就是你工作流程中一个宝贵的时间节省工具。

从代码生成开始

给 Claude 具体指令，要求它编写逻辑，然后验证其正确性。这有助于在将其用于更复杂的任务之前，建立对该工具能力的信任。

用它来编写测试

让 Claude 编写单元测试可以显著减轻日常开发工作的压力。利用这个功能来保持代码质量，而无需花费时间手动思考所有测试用例。

Claude Code 在数据科学与机器学习工程领域的应用

数据科学和机器学习工程团队需要复杂的可视化工具来理解模型性能，但构建这些工具通常需要不熟悉的语言和框架的专业知识。Claude Code 使这些团队能够构建生产质量的分析仪表盘，而无需成为全栈开发人员。

主要 Claude Code 用例

构建 JavaScript/TypeScript 仪表盘应用

尽管对“JavaScript 和 TypeScript 知之甚少”，该团队仍使用 Claude Code 构建了完整的 React 应用，用于可视化强化学习 (RL) 模型的性能和训练数据。他们让 Claude 控制从零开始编写完整的应用程序，比如一个 5000 行的 TypeScript 应用，而无需自己理解代码。这至关重要，因为可视化应用上下文相对较低，不需要理解整个单一代码库，从而允许快速原型设计工具来理解模型在训练和评估期间的性能。

处理重复的重构任务

当面临合并冲突或半复杂的文件重构时——这些任务对于编辑器宏来说过于复杂，但又不足以进行大规模开发——他们会像使用“老虎机”一样使用 Claude Code：提交他们的状态，让 Claude 自主工作 30 分钟，然后要么接受解决方案，要么在不成功时重新开始。

创建持久的分析工具而非一次性笔记本

团队现在让 Claude 构建可以跨未来模型评估重用的永久性 React 仪表盘，而不是构建用完即弃的一次性 Jupyter 笔记本。这很重要，因为理解 Claude 的性能是“团队最重要的事情之一”——他们需要了解模型在训练和评估期间的表现，而“这实际上非同小可，简单的工具无法从一个上升的数字中获得太多信号。”

零依赖任务委托

对于完全不熟悉的代码库或语言中的任务，他们将整个实现委托给 Claude Code，利用其从单一代码库中收集上下文并执行任务的能力，而无需他们实际参与编码过程。这使得他们能够在专业领域之外提高生产力，而不是花时间学习新技术。

团队影响

实现 2-4 倍的时间节省

过去繁琐但可手动管理的常规重构任务现在完成得更快了。

在不熟悉的语言中构建复杂的应用程序

尽管 JavaScript/TypeScript 经验最少，也创建了 5000 行的 TypeScript 应用。

从一次性工具转向持久性工具

不再使用一次性的 Jupyter 笔记本，现在构建可重用的 React 仪表盘进行模型分析。

直接的模型改进洞察

第一手的 Claude Code 经验为未来模型迭代中更好的内存系统和用户体验改进提供了信息。

实现了可视化驱动的决策

通过先进的可视化工具，更好地理解 Claude 在训练和评估期间的性能。

来自数据科学与机器学习工程团队的建议

像玩老虎机一样对待它

在让 Claude 工作之前保存你的状态，让它运行 30 分钟，然后要么接受结果，要么重新开始，而不是试图纠正错误。从头开始通常比试图修复 Claude 的错误有更高的成功率。

在需要时为了简单而中断

在监督时，不要犹豫，停下来问 Claude “你为什么这么做？试试更简单的方法。” 模型默认倾向于更复杂的解决方案，但对更简单方法的请求反应良好。

Claude Code 在产品工程领域的应用

产品工程团队致力于 PDF 支持、引用和网络搜索等功能，这些功能为 Claude 的上下文窗口带来了额外的知识。跨越大型、复杂的代码库工作意味着不断遇到不熟悉的代码部分，需要花费大量时间来理解要检查哪些文件，并在进行更改前建立上下文。Claude Code 改善了这种体验，它作为一个向导，可以帮助他们理解系统架构、识别相关文件并解释复杂的交互。

主要 Claude Code 用例

第一步工作流规划

团队将 Claude Code 作为任何任务的“第一站”，要求它确定要检查哪些文件以进行错误修复、功能开发或分析。这取代了在开始工作前手动导航代码库和收集上下文的传统耗时过程。

跨代码库的独立调试

团队现在有信心在不向他人求助的情况下，处理代码库中不熟悉部分的错误。他们可以问 Claude “你认为你能修复这个 bug 吗？这是我看到的行为”，并且通常能立即取得进展，这在以前由于所需的时间投入而不可行。

通过内部测试进行模型迭代测试

Claude Code 自动使用最新的研究模型快照，使其成为体验模型变化的主要方式。这为团队在开发周期中提供了关于模型行为变化的直接反馈，这是他们以前在发布时没有经历过的。

消除上下文切换的开销

他们不再需要将代码片段复制和拖动到 Claude.ai 中，同时还要详细解释问题，而是可以直接在 Claude Code 中提问，无需额外的上下文收集，大大减少了脑力开销。

团队影响

增强了处理不熟悉领域的信心

团队成员可以独立地在不熟悉的代码库中调试错误和调查事件。

在上下文收集中节省了大量时间

Claude Code 消除了将代码片段复制和拖动到 Claude.ai 的开销，减少了上下文切换的负担。

更快的轮岗入职

轮岗到新团队的工程师可以迅速导航不熟悉的代码库，并在没有大量同事咨询的情况下做出有意义的贡献。

提升了开发者的幸福感

团队报告说，在日常工作流程中减少了摩擦，感觉更快乐、更有效率。

来自产品工程团队的顶级建议

将其视为迭代的伙伴，而非一次性的解决方案

不要期望 Claude 能立即解决问题，而是把它当作一个你与之迭代的合作者。这比试图在第一次尝试中就获得完美的解决方案效果更好。

用它来建立在不熟悉领域的信心

不要犹豫，去处理你专业领域之外的错误或调查事件。Claude Code 使得在通常需要大量上下文构建的领域独立工作成为可能。

从最少的信息开始

从你需要的最基本信息开始，让 Claude 引导你完成整个过程，而不是预先加载大量的解释。

Claude Code 在增长营销领域的应用

增长营销团队专注于在付费搜索、付费社交、移动应用商店、电子邮件营销和 SEO 方面建立效果营销渠道。作为一个非技术背景的单人团队，他们使用 Claude Code 来自动化重复性的营销任务，并创建传统上需要大量工程资源的智能体工作流。

主要 Claude Code 用例

自动化 Google Ads 广告创意生成

团队构建了一个智能体工作流，该工作流处理包含数百个现有广告及其效果指标的 CSV 文件，识别表现不佳的广告进行迭代，并生成符合严格字符限制（标题 30 个字符，描述 90 个字符）的新变体。使用两个专门的子智能体（一个用于标题，一个用于描述），该系统可以在几分钟内生成数百个新广告，而无需跨多个活动进行手动创建。这使他们能够大规模地进行测试和迭代，这是以前需要大量时间才能实现的。

用于大规模创意制作的 Figma 插件

他们开发了一个 Figma 插件，而不是为付费社交广告手动复制和编辑静态图像。该插件能识别框架并以编程方式通过替换标题和描述生成多达 100 个广告变体，将过去需要数小时的复制粘贴工作减少到每批次半秒。这使得创意产出提高了 10 倍，让团队可以在关键社交渠道上测试更多样化的创意变体。

用于活动分析的 Meta Ads MCP 服务器

他们创建了一个与 Meta Ads API 集成的 MCP 服务器，以直接在 Claude 桌面应用内查询活动表现、支出数据和广告效果，从而无需在不同平台之间切换进行性能分析，节省了关键时间，而每一个效率的提升都转化为更高的投资回报率（ROI）。

带记忆系统的高级提示工程

他们实现了一个基本的记忆系统，记录跨广告迭代的假设和实验，使系统在生成新变体时能够提取以前的测试结果作为上下文，从而创建了一个自我改进的测试框架。这使得系统性的实验成为可能，而这在以前是无法手动追踪的。

团队影响

在重复性任务上节省了大量时间

Claude Code 将广告文案创作时间从 2 小时减少到 15 分钟，为团队腾出更多时间进行战略性工作。

创意产出增加 10 倍

通过自动化广告生成和 Figma 集成，团队现在可以在各个渠道测试更多的广告变体，以获取最新的视觉设计元素。

像一个更大的团队一样运作

团队可以处理传统上需要专门工程资源的大型开发任务。

战略焦点的转移

团队可以花更多时间在整体战略和构建智能体自动化上，而不是手动执行。

来自增长营销团队的顶级建议

识别支持 API 的重复性任务

寻找涉及使用带有 API 的工具（如广告平台、设计工具、分析平台）进行重复性操作的工作流。这些是自动化的主要候选者，也是 Claude Code 提供最大价值的地方。

将复杂工作流分解为专门的子智能体

不要试图在一个提示或工作流中处理所有事情，而是为特定任务创建单独的智能体（例如标题智能体 vs. 描述智能体）。这在处理复杂需求时使调试更容易，并提高了输出质量。

在编码前进行彻底的头脑风暴和提示规划

花大量时间预先使用 Claude.ai 来思考你的整个工作流，然后让 Claude.ai 为 Claude Code 创建一个全面的提示和代码结构以供参考。此外，要循序渐进地工作，而不是要求一次性的解决方案，以避免 Claude 被复杂的任务压垮。

Claude Code 在产品设计领域的应用

产品设计团队支持 Claude Code、Claude.ai 和 Anthropic API，专注于构建 AI 产品。即使是非开发人员也可以使用 Claude Code 来弥合设计和工程之间的传统鸿沟，使他们能够直接实现其设计愿景，而无需与工程师进行大量的来回迭代。

主要 Claude Code 用例

前端润色和状态管理变更

团队不再创建详尽的设计文档，并与工程师就视觉调整（字体、颜色、间距）进行多轮反馈，而是直接使用 Claude Code 实现这些更改。工程师们注意到，他们正在进行“通常不会看到设计师做出的大的状态管理更改”，这使他们能够达到他们所设想的确切质量。

GitHub Actions 自动化工单处理

利用 Claude Code 的 GitHub 集成，他们只需提交描述所需更改的问题/工单，Claude 就会自动提出代码解决方案，而无需打开 Claude Code，为他们持续积压的润色任务创建了一个无缝的错误修复和功能优化工作流。

快速交互式原型制作

通过将模型图像粘贴到 Claude Code 中，他们可以生成功能齐全的原型，工程师可以立即理解并在此基础上进行迭代，取代了传统的静态 Figma 设计周期，后者需要大量的解释和到工作代码的转换。

边缘案例发现和系统架构理解

团队使用 Claude Code 来绘制错误状态、逻辑流和不同的系统状态，使他们能够在设计阶段识别边缘案例，而不是在开发后期才发现，从而从根本上提高了他们初始设计的质量。

复杂的文案更改和法律合规

对于像在整个代码库中移除“研究预览”消息这样的任务，他们使用 Claude Code 查找所有实例，审查周围的文案，与法务部门实时协调更改，并实施更新，这个过程只需要两个 30 分钟的电话会议，而不是一周的来回协调。

团队影响

转变了核心工作流

Claude Code 成为主要的设计工具，Figma 和 Claude Code 的使用时间占到了 80%。

2-3 倍的执行速度

以前需要与工程师大量来回沟通的视觉和状态管理更改现在可以直接实现。

周期时间从数周缩短到数小时

像发布 Google Analytics 消息这样需要一周协调的复杂项目，现在可以在两个 30 分钟的电话会议中完成。

两种截然不同的用户体验

开发者获得了一种“增强的工作流”（更快的执行），而非技术用户则获得了“天哪，我现在也能像开发者一样工作了！”的工作流。

改善了设计与工程的协作

Claude Code 改善了沟通和问题解决速度，因为设计师在不必与工程师紧密合作的情况下，就能理解系统的约束和可能性。

来自产品设计团队的顶级建议

从工程师那里获得正确的设置帮助

让工程团队的同事帮助进行初始的代码仓库设置和权限配置——对于非开发人员来说，技术入职具有挑战性，但一旦配置完成，它将为日常工作流带来变革。

使用自定义记忆文件来引导 Claude 的行为

创建具体的指令，告诉 Claude 你是一个编码经验很少的设计师，需要详细的解释和更小、增量的更改，这会显著提高 Claude 响应的质量，并使其不那么令人生畏。

利用图像粘贴进行原型制作

使用 Command+V 将截图直接粘贴到 Claude Code 中。它在读取设计和生成功能代码方面表现出色，对于将静态模型转化为工程师可以立即理解和构建的交互式原型非常有价值。

Claude Code 在 RL 工程领域的应用

RL 工程团队专注于 RL 中的高效采样和跨集群的权重传输。他们主要使用 Claude Code 编写中小型功能、进行调试，以及理解复杂的代码库，采用一种包含频繁检查点和回滚的迭代方法。

主要 Claude Code 用例

有监督的自主功能开发

团队让 Claude Code 编写大部分中小型功能的代码，同时提供监督，例如为权重传输组件实现认证机制。他们以交互方式工作，允许 Claude 主导，但在其偏离轨道时进行引导。

测试生成与代码审查

在自己实现更改后，团队会要求 Claude Code 添加测试或审查他们的代码。这种自动化的测试工作流在常规但重要的质量保证任务上节省了大量时间。

调试和错误调查

他们使用 Claude Code 调试错误，结果好坏参半。有时它能立即识别问题并添加相关测试，而其他时候它难以理解问题，但总的来说，在它起作用时提供了价值。

代码库理解和调用栈分析

他们工作流程中最大的变化之一是使用 Claude Code 快速获取相关组件和调用栈的摘要，取代了手动阅读代码或生成大量调试输出。

Kubernetes 操作指导

他们经常向 Claude 询问 Kubernetes 操作，这些操作通常需要大量的谷歌搜索或询问基础设施工程的同事，从而获得配置和部署问题的即时答案。

开发工作流影响

启用了实验性方法

他们现在使用一种“尝试并回滚”的方法，频繁提交检查点，以便测试 Claude 的自主实现尝试，并在需要时恢复，从而实现更具实验性的开发。

加速了文档工作

Claude Code 自动添加有用的注释，节省了大量的文档时间，尽管他们注意到它有时会在奇怪的地方添加注释或使用有问题的代码组织方式。

有局限性的提速

虽然 Claude Code 可以在“相对较少的时间”内实现中小型 PR，但他们承认，它只有大约三分之一的时间能在第一次尝试时成功，需要额外的指导或手动干预。

来自 RL 工程团队的顶级建议

为特定模式定制你的 Claude.md 文件

在你的 Claude.md 文件中添加指令，以防止 Claude 犯重复的工具调用错误，比如告诉它“运行 pytest 而不是 run，不要不必要地 cd – 只需使用正确的路径。” 这显著提高了一致性。

使用检查点密集的工作流

在 Claude 进行更改时定期提交你的工作，以便在实验不成功时轻松回滚。这使得开发能够采用更具实验性的方法，而没有风险。

先尝试一次性完成，然后协作

给 Claude 一个快速的提示，让它尝试完成整个实现。如果成功了（大约三分之一的时间），你就节省了大量时间。如果没有，那就切换到更具协作性的、引导式的方法。

Claude Code 在法务领域的应用

法务团队通过实验和了解 Anthropic 产品供应的愿望，发现了 Claude Code 的潜力。此外，一名团队成员有一个个人用例，涉及为家庭和工作创建可访问性工具原型，展示了该技术为非开发人员提供的力量。

主要 Claude Code 用例

为家庭成员定制的可访问性解决方案

团队成员为有医疗诊断导致说话困难的家庭成员构建了沟通助手。在短短一个小时内，一个人使用原生的语音到文本功能创建了一个预测性文本应用，该应用能建议回复并使用语音库说出它们，解决了语言治疗师推荐的现有可访问性工具中的空白。

法务部门工作流自动化

团队创建了原型“电话树”系统，以帮助团队成员在 Anthropic 与合适的律师联系，展示了法务部门如何在没有传统开发资源的情况下为常见任务构建自定义工具。

团队协调工具

经理们构建了 G Suite 应用，可以自动化每周的团队更新，并跨产品跟踪法律审查状态，使律师能够通过简单的按钮点击而不是电子表格管理来快速标记需要审查的项目。

用于解决方案验证的快速原型制作

他们使用 Claude Code 快速构建功能原型，可以向领域专家展示（比如向 UCSF 的专家展示可访问性工具），以验证想法并在投入更多时间之前识别现有解决方案。

工作风格与影响

在 Claude.ai 中规划，在 Claude Code 中构建

他们使用一个两步流程，首先在 Claude.ai 中进行头脑风暴和规划，然后转移到 Claude Code 进行实现，要求它放慢速度并逐步工作，而不是一次性输出所有内容。

视觉优先的方法

他们经常使用截图向 Claude Code 展示他们想要的界面外观，然后根据视觉反馈进行迭代，而不是用文字描述功能。

原型驱动的创新

他们强调克服分享“傻瓜式”或“玩具式”原型的恐惧，因为这些演示能激励他人看到他们以前没有想到的可能性。

安全与合规意识

MCP 集成问题

产品律师使用 Claude Code 立即识别深度 MCP 集成的安全影响，指出随着 AI 工具访问更敏感的系统，保守的安全态势将构成障碍。

合规工具的优先级

他们倡导随着 AI 能力的扩展迅速构建合规工具，认识到创新与风险管理之间的平衡。

来自法务部门的顶级建议

首先在 Claude.ai 中进行详尽规划

在转向 Claude Code 之前，使用 Claude 的对话界面充实你的整个想法。然后要求 Claude 将所有内容总结成一个分步的实现提示。

增量和可视化地工作

要求 Claude 放慢速度，一次实现一个步骤，这样你就可以复制粘贴而不会被淹没。大量使用截图来展示你想要的界面外观。

尽管不完美也要分享原型

克服隐藏“玩具”项目或未完成工作的冲动。分享原型有助于他人看到可能性，并激发通常不互动的部门之间的创新。

立即开始使用 Claude Code吧。

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

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

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

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

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

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

Tony Bai 一个程序员的心路历程

• Google Go语言编码风格规范

  • Google Go语言编码风格规范：指南篇
  • Google Go语言编码风格规范：决定篇
  • Google Go语言编码风格规范：最佳实践篇

• Go语言第一课FAQ

• Go语言进阶课FAQ

• 关于我

• 我的技术专栏

• 文章列表

AI 正在重写“软件工程师”的岗位描述：未来你需要这 6 项核心技能

• 七月 15, 2025
• 0 条评论

本文永久链接 – https://tonybai.com/2025/07/15/the-agentic-software-engineer

大家好，我是Tony Bai。

最近，如果你和身边的程序员朋友聊天，很可能会感受到一丝寒意。是的，软件工程行业正在经历一个自 2008 年以来最冷的冬天。职位空缺大幅减少，大厂裁员的新闻不绝于耳。

很多人将矛头指向了 AI：“是 AI 抢了我们的饭碗！”

然而，一篇来自 DoltHub 的深刻文章《The Agentic Software Engineer》提出了一个更本质的观点：别怪 AI，杀死软件工程师黄金时代的，是互联网的普及。

过去 25 年，从互联网到移动互联网的浪潮，创造了海量的工程需求，软件工程师也因此成为了时代的宠儿。但现在，这波巨大的增长红利期已经结束。

那下一个浪潮是什么？文章给出了答案：Agentic AI (智能体 AI)。

这不仅仅是一个新技术，它将彻底重塑我们的工作方式，重写“软件工程师”这个岗位的核心要求。这不是一次普通的更新，这是一场彻底的进化。

告别“代码工人”，拥抱“智能体工程师”

文章预言，软件工程师不会被淘汰，而是将进化，去“驾驭”这波新的 AI 浪潮。我们将成为所谓的 “智能体软件工程师” (Agentic Software Engineer)。

在这个新角色下，我们的工作不再是整天埋头编写成千上万行代码。AI Agent 可以比我们更快、更不知疲倦地完成这项任务。我们的核心职责，将转变为：

一个指挥、协调、审查和运维 AI Agent 军团的专家。

我们从亲自下场比赛的“运动员”，变成了运筹帷幄的“教练”。

AI 时代的生存指南：你的技能升级清单

那么，要成为一名合格的“智能体软件工程师”，我们需要点亮哪些新的技能树？文章为我们梳理了一份极其宝贵的“技能升值/贬值清单”。

技能升值 (Skills++)：这 6 项能力将是你未来的护城河

• 版本控制 (Version Control)

Git 不再仅仅是你个人的代码管理工具，它将成为协调你与成百上千个“AI 码农”协同工作的核心骨干。你需要用它来管理 Agent 的并行工作流、审查 Agent 提交的 PR、以及在 Agent 犯错时进行回滚。精通 Git 模型，将是从业基础。

• 产品思维 (“Product”)

AI Agent 擅长执行，但前提是指令必须清晰。任务分解、需求定义、接口设计等产品经理的核心技能，将成为每个工程师的必备能力。如果你无法将一个模糊的想法拆解成 Agent 可以处理的、足够小的任务块，你将无法与 Agent 高效协作。

• 代码审查 (Code Review)

这是未来我们耗时最多的日常工作。当 Agent 可以在 10 分钟内生成 500 行复杂的代码时，你的价值就体现在审查这些代码的正确性、可维护性和安全性上。接受吧，你正在从一个 Code Writer 变成一个 Code Editor。

• 测试 (Testing)

文章说：“We’re all SDETs now.”（我们现在都是软件测试开发工程师了）。面对一个可能会“创造性”地修改代码以绕过测试的 Agent，编写精准、全面的测试用例，是约束和指导 Agent 行为的最有力工具。 那些热衷于寻找边界条件、享受“破坏”代码乐趣的工程师，将在新时代中变得极其宝贵。

• 系统设计 (System Design)

未来的系统设计，需要更多地考虑如何容纳和管理不那么可靠的 Agent。你需要设计出具有清晰边界、强健接口、高度可测试性的系统，这样即使 Agent 的某个部分出错，也不会导致整个系统崩溃。

• 运维 (Operations)

我们都将成为 “智能体可靠性工程师” (Agent Reliability Engineer)。你需要设计、部署、监控和调试由无数 Agent 组成的复杂网络。当仪表盘上警报响起时，你需要快速定位问题是出在哪个 Agent 的行为上。学习大规模系统的运维之道，宜早不宜迟。

技能贬值 (Skills–)：这些技能正在被 AI 替代

• LeetCode 式算法题： AI 已经能在瞬间解决大部分算法题。
• 语言语法熟练度： Agent 知道所有语法细节，你只需能读懂代码即可。
• 打字速度： AI “思考”和“打字”的速度，是人类无法企及的。

现在，立即开始行动

这篇文章给我们的不应是焦虑，而是行动的路线图。我们应该如何开始？

1. 亲自使用 Agent： 去尝试 Claude Code、Gemini CLI 等领先的编码智能体。找一个终端窗口，看着它工作 15 分钟，感受一下未来的工作形态。
2. “外包”你的日常工作： 在你现有的开发流程中，寻找那些可以“委托”给 Agent 的任务。比如：“为我刚才的提交补充单元测试”，或者“重构这个函数，让它更具可读性”。
3. 刻意练习新技能： 将你的学习时间，有意识地投入到上述 6 项“升值技能”上。

小结：浪潮已至，要么驾驭，要么被吞没

软件工程师的“25年黄金时代”或许已经落幕，但这不意味着职业的终结。

一个由 AI 驱动的、充满无限可能的新时代正在开启。这场变革是不可避免的，拥抱 Agent 的公司，必将“碾压”那些固步自封的公司。而能够驾驭 Agent 的工程师，也必将成为这些公司的核心。

角色的转变或许是痛苦的，甚至会像文章所说的那样，变得有些“无聊”。我们可能会失去一些亲手创造的“流心”时刻。但这是进化的代价，也是我们保持价值的唯一途径。

现在，拿起你的冲浪板，开始学习如何驾驭这波巨浪吧。

成为一名“智能体软件工程师”，从今天开始。

资料链接：https://www.dolthub.com/blog/2025-07-02-the-agentic-software-engineer

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

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

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

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

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

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