阅读视图

发现新文章,点击刷新页面。
🔲 ☆

一天重写 JSONata,我用 400 美元干掉了公司 50 万美元的 K8s 集群

本文永久链接 – https://tonybai.com/2026/04/01/rewrote-jsonata-in-golang-with-ai

大家好,我是Tony Bai。

过去的几年,我们见证了 AI 编程工具从“玩具”到“神器”的进化。无数开发者都在分享自己效率翻倍的喜悦。

你有没有想过,用 AI 来完成一次“外科手术式”的精准重构,一天之内,就能帮你把公司每年烧掉的 50 万美元(约 360 万人民币)的服务器成本,直接砍到零?

这听起来像天方夜谭,但它真实地发生了。

就在前几天,以色列安全公司 Reco 的工程师 Nir Barak 发表了一篇极其硬核的博客。他详细复盘了自己是如何在一天之内,花费了仅仅 400 美元的 Token 费用,利用 AI 将一个用 JavaScript 编写的核心组件 JSONata,完美地重写为了纯 Go 版本,最终为公司节省了每年 50 万美元的开销,并带来了 1000 倍的性能提升。

这不仅仅是一个“AI 真牛逼”的简单故事。它背后揭示的,是一套足以改变我们未来架构选型和技术债偿还方式的“AI 驱动重构(AI-Driven Refactoring)”实用方法。

跨语言 RPC,微服务架构中最昂贵的“性能税”

要理解这次重构的意义有多么重大,首先得看看 Nir Barak 的团队曾经陷入了多深的泥潭。

他们的核心业务是一个用 Go 编写的高性能数据管道,每天处理数十亿的事件。但其中有一个环节,需要用到一个名为 JSONata 的查询语言(你可以把它想象成带 Lambda 函数的 jq)来执行动态策略。

尴尬的是,JSONata 的官方实现是 JavaScript 写的。

这就导致了一个极其痛苦的架构:他们的主业务 Go 服务,为了执行这些规则,不得不去远程调用(RPC)一个专门部署在 Kubernetes 上的庞大的 Node.js 服务集群。

这个“小小的”跨语言调用,给他们带来了三大噩梦:

  1. 恐怖的成本:为了扛住流量,这个 jsonata-js 集群常年需要维持 300 多个 Pod 副本,光是这部分,每年就要烧掉 30 万美元的计算资源。
  2. 惊人的延迟:一次最简单的字段查找,比如 email = “admin@co.com”,在 Node.js 内部执行可能只需要几纳秒。但算上序列化、跨进程网络往返的开销,一次 RPC 调用在啥也没干之前,150 微秒的延迟就先进来了。对于一个每天处理几十亿事件的系统来说,这简直是灾难。
  3. 意想不到的运维黑洞:随着业务增长,Pod 数量一度多到耗尽了 Kubernetes 集群的 IP 地址分配上限!

Nir Barak 的团队当然也尝试过各种小修小补:优化表达式、加缓存、甚至用 CGO 把 V8 引擎直接嵌进 Go 里……但这些都只是“头痛医头”,无法根治“跨语言”这颗毒瘤。

Cloudflare 的“抄作业”哲学

转机发生在前几周。Nir Barak 看到了 Cloudflare 那篇刷爆全网的文章《我们如何用 AI 在一周内重构 Next.js》。

Cloudflare 的做法极其“暴力”且有效:他们没有让 AI 去创造新东西,而是把 Next.js 现成的spec,以及包含几千个 case 的官方测试套件(Test Suite)直接扔给大模型,然后对 AI 下达了一个简单粗暴的指令:

“我不管你怎么实现,给我写一个能在 Vite 上跑通所有这些测试的 API 就行!”

Nir Barak 看到这里,瞬间被点醒了:“我们面临的问题一模一样!我们也有 jsonata-js 官方那套包含 1778 个测试用例的完整套件啊!”

与其让 AI 去搞创新,不如把它变成一个任劳任怨、24 小时待命的“代码翻译工”!

于是,他花了一个周末,用 AI 制定了一个极其清晰的“三步走”作战计划:

  1. 第一步(人类智慧):用 Go 语言把 jsonata-js 的测试套件先“翻译”过来。
  2. 第二步(AI 体力):把 JSONata 2.x 的官方文档和规范全部喂给 AI。
  3. 第三步(测试驱动):对 AI 下达指令:“开始写 Go 代码,目标是跑通第一步的所有测试用例。”

第二天,他按下了“开始键”。

7 小时,400 美元,13000 行 Go 代码

接下来的故事,充满了令人肾上腺素飙升的极客快感。

Nir Barak 坐在电脑前,看着 AI Agent 像一台失控的缝纫机一样,疯狂地生成 Go 代码、运行测试、读取报错、然后自我修正。

整个过程被划分成了几个“波次(Waves)”:先实现核心解析器,再实现内置函数,最后处理各种边缘 case。

在 AI 与测试用例的左右互搏之下,仅仅 7 个小时 后,奇迹发生了:

一个包含 13,000 多行纯 Go 代码的、名为 gnata 的全新 JSONata 实现诞生了。它完美通过了官方所有的 1778 个测试用例。

而这整个过程的成本呢?

400 美元的 Token 费用。

Nir Barak 在博客中晒出了一张截图,数据显示,在重构 gnata 的那一天,AI 生成的代码占比高达 91.7%

当他把这个 PR 提交到公司内部时,立刻有人质疑 ROI(投资回报率)。而他的回答简单粗暴:

“上个月,jsonata-js 集群的成本是 2.5 万美元。现在,是 0。”

百倍性能与意外之喜:“手术刀式”重构的深远影响

成本降为零已经足够震撼,但性能上的收益更是堪称“恐怖”。

这还只是开始。由于 gnata 是纯 Go 实现,Nir Barak 团队得以进行更深度的“魔改”:他们设计了一套两层评估架构。对于简单的字段查找,gnata 直接在原始的 JSON 字节流上操作,实现了 零堆内存分配(Zero Heap Allocations)!只有遇到复杂表达式时,才会启动完整的解析器。

在接下来的两周内,他们乘胜追击,用 gnata 的批量处理能力,替换掉了主数据管道中另一个极其臃肿、靠启动上万个 Goroutine 来并发处理规则的旧引擎。 结果:又省下了每年 20 万美元。

短短两周,两次“外科手术式”的重构,总共为公司节省了每年 50 万美元的开销。

最让人意想不到的是,这次重构还带来了组织层面的“意外之喜”:

gnata 是公司内部第一个完全由 AI Agent 大规模参与生成的 PR。在 Code Review 的过程中,团队成员被迫去学习如何分辨“AI 真正发现的并发 Bug”和“AI 瞎操心的代码格式问题”。这次经历,为他们后续制定全公司的 AI Code Review 规范积累了宝贵的实战经验。

小结:我们不再只是“氛围感编码”

在文章的结尾,Nir Barak 提到了 AI 大神 Andrej Karpathy 最近的观点,大意是:

“编程正在变得面目全非。在底层,深厚的技术专长正成为比以往任何时候都更强大的‘乘数效应放大器’。”

Nir Barak 感慨道,直到最近,他自己都对那种完全由 AI Agent 生成代码的“氛围编码(Vibe coding)”持怀疑态度。但 2026 年 2 月,成为了一个连他这样固执的开发者都无法忽视的“拐点”

gnata 的诞生,标志着我们不再只是用 AI 去写一些无关紧要的玩具项目。在拥有明确测试用例和边界规范的前提下,AI 已经具备了对生产环境核心组件进行“手术刀式重构”的惊人能力。

你准备好拿起这把名为“AI”的手术刀,去切掉你系统里那些最昂贵、最臃肿的“技术肿瘤”了吗?

资料链接:https://www.reco.ai/blog/we-rewrote-jsonata-with-ai


今日互动探讨:

在你的公司里,是否存在类似的“异构技术栈”调用导致的性能瓶颈或成本黑洞?你有没有想过,可以用 AI + 测试用例的方式,对某个核心组件进行“代码翻译”式的重构?

欢迎在评论区分享你的架构痛点与大胆构想!


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

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

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


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

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

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

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

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


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

© 2026, bigwhite. 版权所有.

🔲 ☆

别再用 AI 疯狂撸代码了!我们正在把自己逼入“死胡同”

本文永久链接 – https://tonybai.com/2026/03/29/stop-mindless-ai-coding-we-are-heading-to-a-dead-end

大家好,我是Tony Bai。

过去的一年,大概是所有程序员肾上腺素飙升最快的一年。

从早期的 Copilot、Cursor到如今的Claude Code、Codex,再到各种号称能“全自动开发”的 Agent Swarm(智能体集群)。只要在周末花上几个小时,敲几句 Prompt,你就能把以前想做却没时间做的 Side Project 全部干出来。

甚至,连微软 CEO Satya Nadella 都在四处宣扬“微软现在有多少代码是 AI 写的”。仿佛在一夜之间,“一个人就是一家公司”、“一天撸完一个 SaaS 平台”成了技术圈的标配。

但在这场速度的狂欢中,你有没有感觉到一丝不对劲?

最近,国外资深开发者 Mario Zechner 写了一篇极其辛辣的文章《Thoughts on slowing the f**k down》。他毫不客气地戳破了这层“繁荣”的窗户纸:

当我们把 AI 智能体(Agent)全面引入生产代码库后,我们并没有迎来软件工程的乌托邦,反而正在以惊人的速度,制造着前所未有的“屎山”和灾难。

今天,我想结合他的反思,以及我最近在使用 AI 原生开发时的一些切身痛点,给大家浇一盆冷水。在被大模型彻底“惯坏”之前,我们必须看清,过度依赖 Agent 正在如何毁掉我们的系统,甚至我们的职业生涯。

100% AI 生成,等于 100% 的不可控

很多公司和独立开发者喜欢标榜:“我的产品 100% 是由 AI 写的。”

他们以为这是高科技的证明,但在行家眼里,这简直是灾难的代名词。

那些号称“完全脱手、让 Agent 自己去写”的代码库,往往充斥着你能想象到的最糟糕的垃圾:

高达几个 G 的内存泄漏、莫名其妙的 UI 闪烁、完全没有一致性的设计模式,以及一碰就碎的核心逻辑。

为什么会这样?难道现在的 AI 不够聪明吗?

原因在于:Agent 是“没有痛感”的,而人类有。

在传统的手工编码时代,人类程序员是一个天然的“物理瓶颈”。你一天最多只能写 500 行高质量代码。如果你在这个过程中犯了错(比如引入了某个不良的抽象,或者写了一个极其恶心的嵌套),你会立刻感到“痛苦”

为了避免这种痛苦,你会花时间去重构,去梳理架构,或者因为被 Reviewer 骂了一顿而痛改前非。

痛苦,逼着人类去学习和进化,逼着系统保持在一个“可维护”的边界内。

但 Agent 呢?它是一台没有感情的打字机。

它可以在几分钟内拉出两万行代码。如果其中包含了一个微小的设计缺陷,它不会感到痛苦。相反,它会在你看不见的地方,将这个缺陷以成百上千倍的速度“复利式地放大(Compound)”

等你回过神来,想要在这个 100% 由 AI 生成的系统上加一个新功能时,你会绝望地发现:你连它长什么样都不知道,而且它已经烂到连 AI 自己都改不动了。

为什么 AI 连自己写的屎山都修不好?

有人可能会说:“既然 AI 能写屎山,那我再派一个高级 Agent 去重构这堆屎山不就行了?”

这就是当下最可怕的“平替思维”陷阱。

现实是:当代码的复杂度和体积膨胀到一定程度后,AI 的“召回率(Recall)”会呈现断崖式下跌。

这不仅仅是上下文窗口大小(Context Window)的问题。在拥有百万行代码的迷宫中,Agent 根本不知道该去哪里找相关的依赖,不知道哪些旧代码可以复用。它只能基于极其局部的视野(Local View)去做决策。

这就导致了极度荒谬的现象:Agent 在重构时,不仅找不到病根,反而会发明出更多为了抽象而抽象的垃圾代码,让屎山开出更加绚丽的“奇葩”。

人类制造企业级的屎山,需要几十个程序员耗费好几年的时间来堆砌;

而你,只需要带上 2 个 AI Agent,几个星期就能搞出一个连上帝都看不懂的废墟。

当你发现连号称 100% 覆盖率的 AI 测试用例都在撒谎时,除了手动去点产品、祈祷它别崩溃,你已经失去了对系统的任何掌控力。

我们该如何与 Agent 共生?

难道我们要砸烂电脑,退回到手敲汇编的时代吗?当然不是。

Agent 就像古希腊神话中的海妖塞壬(Sirens),用极速的快感诱惑着你。我们必须在它摧毁我们的工程纪律之前,重新夺回主动权。

真正的顶级开发者,绝不会对 AI 说:“嘿,帮我把这个系统全干了。”

他们与 Agent 的协作,遵循着极其严苛的边界:

1. 坚决把控“系统的整体结构”

什么是系统的整体结构?那是你的核心架构设计、API 的边界、数据库的实体关系,以及整个系统跑起来时的“手感”。

这些东西,必须由你亲手来写,或者通过 Pair Programming(结对编程)一行一行地推敲。

只有亲手写过,感受到那份“摩擦力”,你才能在脑海中建立起对系统的上帝视角。这是目前任何 SOTA(最先进)大模型都无法替代的品味与经验。

2. 让 AI 去干“不用动脑子”的脏活

Agent 最适合的场景,是那些不需要全局视野的局部任务:写一段正则、爬个数据、写几条枯燥的单元测试,或者是写一个就算坏了也不影响公司赚钱的内部临时脚本。

把时间花在“决定做什么”和“决定不做什么”上。学会对需求说“不”,本身就是最高级的特性。

3. 强制减速

这是最反直觉,也是最重要的一条建议。

不要为了追求那虚荣的“代码生成量”而沾沾自喜。给自己设定一个限制:每天 AI 生成的代码量,绝对不能超过你“能够深入 Review 和理解”的极限。

你必须确保,如果明天所有的 AI 公司突然破产,你依然能从容地接管这个系统,因为它的每一根骨架,都在你的掌控之中。

小结:只有人类,才能兜住底线

在过去的一年里,我们把太多的权力让渡给了机器,以至于我们忘记了软件工程的本质。

在这个鼓吹“快、更快、再快一点”的癫狂时代,慢下来,反而成了最稀缺的竞争力。

你的代码可能不再是纯手工敲出来的了,但你的架构品味、你的工程纪律、你在出 Bug 时能一针见血找到根源的敏锐直觉,才是你在这个时代安身立命的根本。

一切自动化,最终都需要人类的纪律(Discipline)与主体性(Agency)来兜底。

机器可以写代码,但只有人类,才能为系统注入灵魂。

资料链接:https://mariozechner.at/posts/2026-03-25-thoughts-on-slowing-the-fuck-down


今日互动探讨:

在日常开发中,你有没有遇到过被 AI 生成的“看似完美、实则藏雷”的代码坑得很惨的经历?你是怎么发现并解决的?

在 AI 编程的浪潮中,你觉得人类程序员最不可被替代的核心能力是什么?

欢迎在评论区分享你的血泪史与思考!


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

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

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


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

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

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

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

img{512x368}


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

© 2026, bigwhite. 版权所有.

🔲 ☆

输入需求,输出系统:AI Agent 正在实现软件工程的“终极梦想” —— 软件工厂!

本文永久链接 – 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技能再上一个新台阶!


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

© 2026, bigwhite. 版权所有.

🔲 ☆

承认吧,AI 写的代码,平均质量已经超过了 80% 的人类程序员!

本文永久链接 – 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技能再上一个新台阶!


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

© 2026, bigwhite. 版权所有.

❌