#152. AI编程

本期节目我们聊聊 AI 编程 ： 过去写代码是人一行一行写 ， 编译 、 测试 、 改 bug； 现在 ， 越来越多工程师开始把任务交给 AI， 甚至让它参与 code review。

但 AI 编程远不只是 " 让 AI 写个函数 "， 它背后有很多工具的演进 ，也有上下文 、memory 等等这些新的工程问题 。AI 到底能把程序员解放到什么程度 ， 它又会制造哪些新的麻烦 ？

这里是 《 牛油果烤面包 》。

大家好 ， 我是斯图亚特 。

我是 Cat。

今天我们要聊一下 Vibe Coding， 氛围编程 。 今天我们请到了两位嘉宾 ， 首先是在 Google 做 Code Agent 的 laik9m。

大家好 ， 然后也是时隔多年第二次上 《 牛油果烤面包 》， 非常非常高兴 。

欢迎欢迎欢迎 。 还有另外一位 ， 我们在 Databricks 做 AI Coding 的 Rice。

大家好 ， 我是 Rice， 第一次上播客 。

我们还有一个非常专业的麦克风 ， 这样就不像是第一次上播客了 。

这个是 Meta Remote 那个 ， 呃 ，Benefit Mic。

哦 ， 所以你开会就用这个啊 ？ 非常有磁性的这个声音 ， 就是 ...... 好吧 ， 非常非常非常厉害 。 今天我们来讲一下这个 Vibe Coding， 这是一个可能在圈外人可能听说的词 ， 会不多的 。

大概这个词的意思就是说 ， 你不用看代码 ，不用改代码 ，不用敲那个代码里的字符 ， 你就直接说话 ， 然后它就给你编出程序来 ， 编出软件来 ， 开发出软件来 ，是吧 ？

我的理解对不对 ？

对 ，但其实可能 、 可能 AI Coding 它是一个比 Vibe Coding 更广的范围 。 就是可能在我的理解里啊 ， 就只说个人理解 ，Vibe Coding 可能更多的是一些就是 ， 呃 ， 你把它做一个爱好 ， 或者是一个 ， 比如说个人使用的软件 。

但其实严肃编程 ， 它就是不属于 Vibe Coding 那一趴 ，但是也是现在都是用 AI 了 ， 对 。

哦 ， 好吧 ， 所以我们还是不要追这个 buzzword 了 。 我们这个节目 ， 那这期我们还不叫 Vibe Coding， 我们还叫 AI 编程 ，OK？AI 软件开发 。

大家知道我们这个 《 牛油果烤面包 》 这个播客的听众范围非常广 ，不光是软件工程师 ， 所以我们这个肯定有很多的圈外人在听这个节目 。他们可能对编程并不是很了解 ， 所以我们还是简单地聊一下我们平时这个 " 古法编程 " 是什么样的 。在 AI 编程之外的 ， 马上要申请非物质文化遗产的这种 ， 这个编程方法是什么样子的 。

很多很多的这个圈外人对于编程的了解 ， 可能是取决于写个程序 。 就是比如说有人参加过计算机等级考试 ， 一级二级 ， 你写个程序这种 。

甚至包括像 ， 比如说学计算机专业的大学生 ， 可能低年级 ，他可能他做到的是一个程序 ， 你上数据结构课 ， 编一个程序可以跑 。

那这个肯定也是编程的一部分 ，但是对于软件开发来说 ， 肯定这只不过是其中一个 ，其中一个部分 。 我们从什么工具开始聊吧 ， 对吧 ？

可能 ...... 不过现在是不是学编程就已经用一个东西叫做集成编译环境 IDE 了 ，是吗 ？ 现在学编程都用啥呀 ？

呃 ， 我觉得现在基本上就是不怎么强调 IDE 了 ， 可能大家就直接打开 VS Code。 因为 VS Code 其实你说一开始是 ， 呃 ， 一个很简单的编辑器 ， 然后微软就加了很多功能 。

这个生态造起来之后 ，其实大部分情况下大家就直接 VS Code 然后来做了 。 除非你写那种特别 ， 你像 JVM 上面的 ， 你可能用 IntelliJ， 然后这种 ， 呃 ，Language 这种 service 做得比较好 ， 然后有专利这种 ，有之前的这种 Mod， 然后这种护城河这种优势 ， 所以才会去专门用这些 IDE。

你像最开始 Java 不就是那个 Eclipse？

文字也是个 IDE 啊 。

对 ，Eclipse 是 IDE， 古早 IDE。

就是说你可以下载一个 ， 就是现在多数人编程还是先下载一个软件 ， 这个软件大概就是说给你写个代码 ， 代码有高亮 ， 比如说什么 for 啊 ， 什么什么之类的 ， 就是给你高亮 。

然后还有一些别的窗口 ， 左边会可以给你浏览这个文件 ， 那个文件 ， 下面可能会给你一个 。

代码树 。

对 ， 代码树 。 下面是可能给你一些提示 ， 一些编译成功不成功什么的 。 右边可能一些乱七八糟东西 ，不知道啥 ， 从来 、 从来不知道啥 ， 搜索结果啊什么之类的 。

我 、 我还以为现在初级编程都已经用什么那个 Colab 什么之类 ， 就是就类似于那个 notebook 的 。 我也不知道现在编程开始都用什么 。

那个用的应该也挺多的 ， 对 。

总之吧 ， 我们工具人编程 ， 过去来说 ， 可能至少有一半以上都是用这种集成编译环境 。 就是一个是软件里面 ， 你在那些中国电视剧里面经常看到的那个代码 ，是那个在那个 IDE 里面 ，在那个编程环境里面 ， 下面是代码 ， 然后左边右边 ， 一个框一个框 。

有的时候左边一个文件 ， 右边一个文件 ， 就是很多代码这种 ， 对吧 ？ 然后我们 、 我们大家在上面编程 ， 就是在上面 ， 古法编程啊 ， 就在上面写 ， 光标到这行 ， 然后我们马上写 for 什么什么什么 。

然后在古代的时候发明了一些非常有用的东西 ， 比如说叫自动补全 ，是吧 ？ 或者叫自动来找 ，是吧 ？

这个就是有点类似于 ， 比如说你搜索的自动补全 ， 就是你在比如说微信啊 ， 就是微信搜索框里面搜我什么什么东西 ， 它立刻给你提示这这这这个 。

古代有一些伟大的发明 ， 就可以帮助你提示你输入了这个字母以后， 后面可以出这个这个这个这个 。

你尤 、 尤其是你出个点啊 ， 一堆可以出来 ，是吧 ？ 这就是我们编程的方法 ，是吗 ？ 你们大家都是这样编的吗 ？

肯定有人不是 。

对 ，以前微软还有个注册商标叫 IntelliSense， 对吧 ？

啊 ， 对对对 ， 就专门干这样的事 ， 对吧 ？

能够根据语法来做自动补全 ，不仅仅是文本 ，而是它能够分析你写了一半的代码的语法 ， 然后用它来做自动补全 。

嗯 ， 这很厉害 。 这个我昨天 AI 了一下， 这也是个里程碑啊 。IntelliSense 是个里程碑 ，因为过去补全非常非常的烂 ， 甚至可能就是这个索引 ， 就按照字母顺序给你排一下， 然后你得往下点 、 下下下点 。IntelliJ 之后这种革命就是它非常非常的聪明 ， 就是有 、 有 80% 的可能性它 、 它 、 它都是你想要的那个 ， 非常非常厉害啊 。

我说这个肯定不是 ，因为就是肯定有人用 Vmax 和 VI 的 ，不是有人用 IDE 的 。 也有些人用一个字母的框 ，但是这咱们就不说了 ， 反正都是古法编程的事 ，是吧 ？

但是写完程序之后， 如果用 IDE 的话 ， 你还是要编译的 ， 对吧 ？ 这个编译这件东西 ， 这件事 ， 我印象中我初学的时候觉得编译是非常简单的事 。在这个打一个什么什么什么命令 ， 啪 ， 就编译出来一个点 exe， 就运行就行了 。

但是对于软件开发来说 ， 编译这件事好像是非常非常复杂 ，是吧 ？ 这个是不是 Rice 可能非常的有经验啊 ？

呃 ， 算是我搞过一堆这种 ， 呃 ， 构建系统吧 ， 中文英文叫 build system， 然后这活儿 。 就是其实编译的话 ，其实现在还是在用的 ，因为毕竟 AI 的产出并不是直接的这种机器码 。

然后编译这件事情意义就在于 ，因为你的 CPU 只能处理 1 和 0， 然后 。

哎 ， 我们稍微稍微地给圈外人稍微地多讲一讲啊 ， 为什么编译这件事是这么困难的 ？ 不是我直接打一个就 exe 了吗 ？

我写的程序我写这么长程序 ， 就直接 exe 不就完了吗 ？ 为什么编译要 、 我们要 、 要这么慢 ？ 过去有一个著名的梗图 ， 那梗图好像是从编译开始的 ， 就是说一个人在基建什么之类的 ， 说你怎么不工作 ？

他说我在编译呢 。 哦 ， 那可以了 ， 一编译就半个小时 、 一个小时 。 为什么编译这件事情是要这么困难 ， 还要 、 还 、 还需要有这么专门一个组来做编译 ， 做 、 做这么长时间呢 ？

对 ，因为 CPU 只 、 只能理解 1 和 0， 然后但是人去写的时候 ， 你不可能让人去写 1 和 0。 这是非常非常古早 ， 这是 ， 呃 ， 史前编程了 ， 应该是 。

就是你当时在那个打卡器 ， 那个打卡 ，在纸上打 、 打洞 ， 然后这种方法 ， 然后非常没有效率 。 然后一群比较聪明的人就是想 ， 那我们为什么不能就是让人来写这个英文 ， 然后又让人来写字 ， 然后再用机器把这个字翻译成这个 1 和 0， 然后这样人可以 、 人可以读 ， 可以去写很自然的语言 ， 然后机器也可以理解 。

所以这是编译在干的一件事情 ， 就是把人可以理解的语言翻译成机器可以理解的语言 。

哦 ， 那应该很快嘛 。

呃 ，也不能说很快 ，其实你如果我年龄没有 、 没有经历过 ，但是这只是道听途说啊 ， 就是计算机历史课 。

就是当年就是从编译器这个技术出现的时候 ， 大家其实感觉跟现在的 AI 也很像 ， 就是大家觉得不行 ， 你这个没有这个丧失了这种那个写代码的这种 ， 呃 ， 匠人精神 。

你没有再用这个 1 和 0 这种 ， 呃 ， 打孔器再去 、 去写这个代码 ， 你写出来代码非常没有效率 。 你就算你用编译器编译出来的代码没有灵魂 。

然后所以也是同样的有这样一波人会觉得 ， 啊 ， 我们一定要坚持之前的这种打孔编程 ， 然后而不是这种使用这种自然语言来写 ， 然后他们觉得这样写出来很没有效率 。

叫自然语言 ， 编程语言 。

当时应该是会编吧 ？ 对 ， 先出来是会编 ， 然后对 ， 又 、 又出来又是要所谓的现在的低级语言 ， 后来学了高级语言 。

这种讨论其实每代人都会进行 。 我们历史总是胜利者写的 ，是吧 ？ 总是认为那些人都是愚蠢的 ，但是你没有看到那些失败的那些人。

比如说有半失败的 ， 我可能举个例子 ， 比如说这个 JVM， 就是当时就有人说你 、 你根本不需要编译 ， 你就 、 你就用 、 就不需要编译成程序 ， 我们就 、 就用这种 ， 呃 ， 虚拟机就自 、 自动给你 、 给你看着代码就给你直 、 直 、 直行出来 。

这个算 ， 到现在算半成功吧 ， 我觉得 。 就是说那些人说 ， 你们这些人认为 JVM 永远不可能比你写的 C++ 有 、 有效率 ， 这是错的 。

随着计算机的发展 ， 我们绝对可以做得有效率 ，并且比你还有效率 。 这件事情到现在也没有发生 20 多年了 ， 就历史总是胜利者写的 。

所以我们现在回去看 ， 都是嘲笑那些错误那些 ，但是你站在历史的节点来说 ，其实你并不知道它是对的还是错的 。

有点扯远了啊 。

啊 ， 对 ， 可以讲一下 JVM 这个虚拟机技术 。 就是 ， 呃 ， 你像有各种各样不同的这种 CPU，他们讲各种各样不同的机器码这种语言 。

所以大家就每次你不管是你写一个程序 ， 你就要去跑到各种各样的平台上面 ， 各种各样 CPU， 就像现在 ARM 也好和 Intel 也好 ，他们现在差异还是蛮大的 。

所以就是就希望能有一个比较简单的 、 共用的 ， 可以跑在各种各样上面的虚拟机 ， 然后你只要把这个你 、 你写的代码编译成那个虚拟机可以理解的代码 ， 你就可以把你的程序放在各种各样平台上， 各种各样的这个 CPU 架构上面跑了 。

嗯 。

这个事可能现在很多人都不理解了 ，因为这现在历史的上下文已经丧失了 。 因为你现在用 C 写 C++ 写也都可以跑到各个平台 ， 放到 ARM 这跑到都没有任何问题 ， 跑到 Windows 跑 、 跑到那个什么跑都没有问题 。

但是在 90 年代的时候 ， 你会发现各个操作系统它那个速度是非常非常不兼容的 。 你在写 Windows 要写 MFC 什么之类的 ， 就是这非常非常不兼容了 。

那 Java 提供了一个就是认为你 、 你 、 你写了一次 ，在所有平台你都可以跑 ，不用管它 MFC 那坨屎还是怎么怎么样 ， 反正就是 。

但是你现在看来 Java 有这个优势吗 ？ 没有吧 ，是吧 ？ 对 ，但是它还是一个非常 ， 作为语言它还是非常的有优势 ， 所以它现在还是个沉重的语言 。

扯远了啊 ， 就是说我们不一定永远认为那些自动化的那些是对的 ， 可能历史上也有失败者 。 呃 ， 来 ， 继续说编译 ， 继续说编译啊 。

对 ， 编译的话就是因为你像大家开始用自然语言写代码 ， 然后就会出现一个问题 ， 就是比如说我在这里面 ， 我要如何组织人写这么多代码 ， 你同时有各种各样的人写很多个 ， 大家都在往同一个代码库里面协作 ， 你要如何让大家可以这样协作得更有效率 。

然后相对来说你就这个时候你就会设计一些 ， 比如说 interface， 设计一些这个 ， 呃 ，protocol 这种 ， 我不太知道中文叫什么 ， 大家可以补一下 。

协议是吗 ？

对对对 ， 协议 。 这种接口呀 、 协议呀这种规范 ， 然后你要如何来做这些抽象 ， 如何做 abstraction， 如何做这种把现实生活中的这个概念然后抽象成代码 。

这就出现了一个叫什么面向对象编程这种很 、 呃 ， 很流行的概念 。其实解决的问题无非就是你如何把现实生活中的概念或者表现在代码里面 ， 你如何去把你的代码组织得让人可以更有效率地协作 。

然后这个造成一个问题就是你其实 、 你其实这样设计的本身 ， 你代码是以人的想法来写的 ，但是它并不是以 、 以一个机器为中心的想法来写的 。

那这真的编译器就需要做这样一件事情 ， 就是你把以人设计的这个概念以翻译成机器可以理解的概念 ， 那这中间就会出现很多的这种问题 。

然后以及如何翻译更有效率 。其实就是你代码写出来 ， 这个代码写变成 、 变成相对来说人可以理解之后， 你其实写得没有 、 不是很有效率 ， 大家都不理解 CPU 如何工作了 。

你不知道说 ， 啊 ， 你加一个比如说什么 ， 你写成伪递归的话 ， 你可能这个执行上面 ， 这个编译器会可以更优化得更好之类的 。其实编译器还有一部分工作做 ， 大部分是在于如何把一个写得很傻的代码优化得更有效率 。

因为大家现在都不知道如何去这个写非常更有效率的代码了 。

啊 ， 好 。 呃 ， 所以我们说到这 ， 所以编译器还是 、 还是要做很多很多事情的啊 。 但 、 但是就是说编译器还有一个就是之所以问到 Rice，因为 Rice 做的事情很重要的一点就是说我们代码不仅仅是一个程序 ， 哎呀 ， 还有很多的叫做这个在下面使用的这些物 ， 这些 dependency， 对吧 ？

比如说我写一个代码 ， 啊 ， 我写一个聊天代码 ， 我不可能把它这个所有的这些 UI 啊 、 下面这些网络的传输啊 、 各种各种这个解包的工 、 工具啊 ， 我都写一遍 ， 对吧 ？

我下面可能有一堆各种各样乱七八糟的用别人的或者是我们本公司的别人写的一些代码 ， 对吗 ？ 那它就 、 它就出现一个整个的我写代码可能只有几千行 ，但是下面可能我下面用无数无数无数的包 ，不知道从哪抓来的 ，有的都是开源的 ，有的不知道分公司哪的 ，有的可能是同组的共用的 ， 对吧 ？

那这件事情怎么解决呢 ？ 呃 ， 就是包管理 ， 依赖包管理 。 当然不同语言这种包管理的方法其实不一样 ， 我觉得 ， 呃 ， 就是包管理这个东西如果你解决得好 ， 会我觉得很大程度上这个决定一个编程语言的这个流行程度 。

你像 Python， 呃 ， 一开始这个非常流行 ， 就是主要我觉得主要一个大原因就是因为它的标准库里面各种各样的工具提供得非常充足 。

你可以很简单地就打开 Python， 然后你就写一段很 、 就写段代码 ， 然后它就会很有用 。 但是你像 C++ 的话 ， 或者 C 或者其他什么语言的话 ， 你就要先学习什么是 GCC， 然后学习如何写 CMake， 然后高级 ， 呃 ，不对 ，CMake 就已经是很高级了 ， 你一开始学的是 Make 或者 AutoConf， 然后 AutoTools 之类的这些东西 ， 这些都很难学 ， 都是非常这种之前发明出来就是非常有这个 moat， 非

常难学的一些东西 。 然后你好不容易你要说 ， 啊 ， 我要做一个 ， 呃 ， 跟网络相关的东西 ， 然后你要去费半天劲 ， 然后你需要去把这个网络的包抓下来 ， 然后你要研究如何 build 它 ， 然后你 build 你 、 你构建出来一个这个动态库或者是静态连接进来之后， 你要去考虑 ， 啊 ， 你如何把这个东西分发给你的用户 ， 然后你要去各种各样的这种 ， 呃 ，

发行版上或者不管是 Windows 也好还是 Linux 也好 ， 你都要去解决其他别人的库如何在这个平台上跑 。 所以其实大公司的话 ， 你像不管 Meta 的话会用 Bulk， 然后 Google 的话会用 Basil，他们其实都是在解决一个这样的问题 ， 就是如何构建你的 ，因 、 因为就是在写代码的时候 ， 你需要先把你的依赖构建好 ， 依赖编译好 ， 依赖编译好之后再来编译你的代码 。

所以这其实有一个 ， 呃 ， 依赖这个数的关系 ， 然后你就要去做很多的这种运算 ， 你来决定说 ， 啊 ， 我应该先把这个 ， 呃 ，A 编译好 ， 然后再把 B 编译好 ， 然后再把一个 C 编译 ， 呃 ，因为 C 可能同时用了 A 和 B， 然后这个时候你就要就排这个序 ， 然后你就要把这个东西如何算 、 如何最有效率 。

然后在这种大公司的话 ，其实还有另外一个问题就是你的这个构建过程并不一定是在你的机器上发生的 ， 它可能背后是一个很大的这个机器集群 。

然后另外一个问题就是你可以如何用这个更多的机器来让你的这个构建过程更有效率 ， 如何在各种各样的机器上去并行编译 ， 然后再把这些东西拿回来 ， 然后再因为你在编译的时候 ， 你需要把这些文件都放在同一个台机器上进行最后的这个连接啊也好 ， 还是打包也好 ， 都是需要有这么一个过程的 。

所以说你要如何去规划这个过程也是一个非常难的这个 ， 呃 ， 技术问题 。 所以大公司其实都花了很多时间去优化 、 去发明新的工具来让这件事情变得更有效率 。

所以为什么聊这个聊得有点时间长呢 ？ 第一是因为可能和 Rice 的工作有关 ， 多说几句 。 另外一个我觉得其实这个和 AI 编程也是有关系的 ， 就这些问题人需要考虑 ， 我需要用什么 。

如果是开源的 ，有公开信息的还好 ， 我可以查 ； 如果是内部的 ， 根本没有文档 ， 那怎么办 ？ 我可能要去读 ， 我可能需要去 、 去读代码 ， 我怎么接口是什么样子的 ，有什么隐含的什么坑 ， 对吧 ？

这些东西最终 AI 都也是要解决的吧 ？ 我们人解决的问题 AI 也是要解决的 。 所以说这就 、 就是我们说一下 AI 编程的难度 ，是吧 ？

有的人认为 AI 编程就是在 ChatGPT 里面问一下写个这个函数 ， 给你 、 给你写个函数贴下来就行了 ， 可能不是这样的 ，有各种各样非常非常困难的问题 ， 对吧 ？

对 ， 然后编译完了我们还需要测试 ，是吧 ？ 这测试可能我 、 我刚学编程的时候测试就是那个 GX 文件里面跑一下 、 跑一下 、 跑一下， 哎 ，不对 ， 失败了 ， 再跑一下失败了 。

我们在这个这就大型的工 、 工程肯定不可能是这样 ， 对吧 ？ 我们只用一个叫单元测试的东西 ， 单元测试 ， 我们就单元测试怎么说 ， 就 、 就反而一般都是几百个 、 几千个测试自动运行 ，是吧 ？

它写好的程序 ， 这个程序专门用来运行这些测试 ，是自动进行的 ，不会人去打 ， 那就 、 就不可能了 ， 对吧 ？

它自动进行 ， 就是就算是我用一个我编一个聊天软件 ， 那我可以自动地在下面生成各种各种这 、 这 、 这 、 这 、 这个 ， 然后然后看一下结果对不对 。

如果不对呢 ， 最后告诉你什么什么结果不对 ， 什么什么结果错了 。 我们程序员的过程就是 ， 反正我是这样的 ， 你们可以说说你们的这个体验啊 ， 就是每次 ， 呃 ， 编译成功 ， 哦耶 ， 然后运行 、 运行一下这个单元测试 ， 哎呀 、 呀 、 呀 ， 错 、 错 、 错了两个 ， 你想这两个是咋样的 ？

啊 ，是这样的 ， 再改一改 ， 哎呀 ， 又不编译了 ， 编译完了 ， 耶 ， 再跑 ， 哎呀 ， 又错了两个 ， 反正就是来回来去来回来是几十遍 ， 然后终于可以成功 。

不知道大家说一下大家这个是不是这么一个工作流程 。其实最开始 ， 呃 ，是没有单元测试 ， 最开始都是手工测试的 。在我实习之前实习过的一家公司 ， 很早的时候 ，他们也是有一些测试的人员嘛 ， 然后这些测试的人他其实不是 ， 呃 ， 程序员出身 ，他可能就是 ， 呃 ， 比如说就是你不需要太多计算机方面的知识 ， 你需要做的就是遵照一个固定的流程去点一些网页上的按

钮 ， 然后呢 ， 如果有任何问题你把它记录下来 ， 就是填到一个系统里面就好了 。 呃 ，其实这个是最古早的形式 。

那公司是微软吗 ？

啊 ，不是 ， 是一个 、 是一个小公司 ， 这 、 这个是最古早的形式 ， 然后大家才发现说 ， 啊 ， 用人力做这些太慢了 ， 太费时间了 ， 还要给他们付工资 ， 对吧 ？

为什么我们不把这些自动化呢 ？ 所以大家就把这些人需要手动操作点按钮的过程去用程序的形式写下来 ， 然后这个就是自动化测试 。其实是这样有一个 、 有一个过程 ， 对 。

所以说我们程序员 。 大家认为 ， 反正至少我是这样的 ， 我不知道 ， 可能我编程能力比较弱啊 ， 各位可以聊聊 。

大家认为我们的古法编程其实是在写代码 ，其实并不是这样的 。80% 的时间是在看我的测试为什么错了 ， 这样一个过程 。

你们都是吗 ？ 还是不是这样子的 ？

啊 ， 我觉得基本上是这个逻辑吧 ， 就是花时间最花的最久的地方是 ， 哎 ， 我代码为什么不能用 ， 哎 ， 或者是我代码为什么能用 ， 啊 ， 它不应该可以用的这种情况下， 就是 、 就是一直花很多时间在研究 ， 或者说为什么 ， 对 ， 为什么东西可以用或者不能跑 ， 然后或者应该如何跑这样 。

因为我们我之前做开发者工具其实最关心的一件事情就是这个开发者的这个 inner loop， 就是什么核心 、 核心这个 ， 呃 ， 循环或不知道如何翻译这个的时间 。

如果就是之前看过一些人 、 一些朋友的 inner loop 可能要半天之久 ， 等于就是你进行你做一下改动 ， 你可能等于你看到它能用或者不能用 ， 这就已经半天过去了 。其实这是一件非常没有效率的事情 。

所以很多时候做开发者工具 ， 我们这边 ， 呃 ， 很重视的一件事情就是如何去降低这个 loop 这个循环的一个周期的 ， 一个开发周期的这个时间 。

当你的时间比如说是 10 分钟 ， 我可能改一行改几行 ， 然后 10 分钟之后我就可以知道这行代码工作不工作了 ， 啊 ， 能不能用了 ， 然后这是一件很重要的事情 。

嗯 ， 对 ， 就是说所以很多人这个可能是一个一些圈外人的误解 。 圈外人可能认为我们程序员大多时间都在那个几千行程序 ，但其实我们程序的时间可能只有 5%， 大多数时间都在 、 都在调试这个东西 。

这里可以稍微离一下题 ， 就是很多时候大家误解说我们是以代码行数来看一个程序员能产出多少的 ，其实并不是 。

因为很多时候你可能做一些东西 ， 你可能只需要用很少的行数就可以把问题解决 ，但是 ， 呃 ， 如何找到这几行是更难的一个问题 。

啊 ， 我们说的 ， 我们说的单元测试这也是我们非常非常重要的一部分 。 我们后面会 Q 掉这个 ， 回来会说这个单元测 、 测试 AI 怎么处理单元测试的问题 ， 非常非常重要的 。

我们最后说一下古法编程的这些整个的平台吧 。 我就大体说一说 ， 大家我们有什么需要补充的 ， 或者是 、 或者是这个讨论的比较有意思 。

比如说就是代码库这个东西 ， 就是说 ， 呃 ， 我不管是一个人编程还是多个人编程 ， 一般来说不可能把所有代码都放在本机 ， 然后到时候编译 ， 所有人编译都跑到你那本机上编译 ， 或者不同的人合作怎么办呢 ？

是吧 ？ 一般都有一个叫代码库 ， 现在最流行的代码库叫 GitHub，是吧 ？ 就是一个国内你是用啥我不知道 ， 反正就是一个著名的现在被微软收购的一个软件 ， 就所有人都把代码放在这个地方 ， 所有人都能在 、 都能在网上看 ， 然后你要想修改呢 ， 或者是在本地看呢 ， 你就可以把它下载到本地去 ， 然后你修改之后呢 ， 你可以提交一个代码 ， 提交一个代码说我要做一个

修改 ，是吧 ？ 去这个 GitHub 上， 啊 ， 然后， 呃 ， 那不是说你提交就提交了 ， 你谁知道你的代码质量怎么样 ， 或者是谁啊 ， 对吧 ？

那它会有一个叫做代码审核的过程 ， 它会在网上出来一个修改的一个工单 ，是工单吧 ，因为大家都可以看 ， 哎 ，他提交了这个代码 ， 然后有代码审核权限的人就会去看 ， 这他会去看 ， 啊 ， 这这行改了这个 ， 这行改了这个 ， 然后你都可以在上面评论 ， 说这行不行 ， 这行不行 ， 这行可以 ， 这行这样修改 ， 就可以在那个你修改的每行上面评论 ， 然后

最后跟你说我可以给你合并 ， 对吧 ？merge 进你的这个库里 ， 或者这个不行 ， 你继续 ， 或者你根本就不对 。

大概是这么一个流程 ， 无论是在公司内部重组的人还是处理开源的项目 ， 大概大概都是这么一个 、 这么一个流程 ， 对吧 ？

大家有没有什么补充的 ？

呃 ， 对 ， 基本上就是这样 ， 对 。

所以大概就是说 AI 时代我们 ， 啊 ， 至少现在的 AI 编程肯定还是要遵循这么一个流程 ，是吧 ？ 未来怎么样咱也不好说 ， 反正给大家一个背景 ， 就是 AI 编程的程 、 程序不是说就也就能进去了 ，是吧 ？

肯定还是有其他人审核 ， 这个审核就很奇怪了 ，是吧 ？ 因为 AI 写的人审核吗 ？ 你 AI 写了几千行代码 ， 我们人审核 ， 我后面可以提到这件事情 。

所以这古法编程 ， 古法编程还有什么值得说的 ， 尤其是和 AI 编程有关的 ？

我觉得可能还有一部分就是你要设计这个程序怎么写吧 ，因为就是你 ， 呃 ，不只是把它写好 ， 就是写出来其实是容易 ，但是想到要怎么写就是 、 是比较难 ，其实这个往往是更加费力的一步 ， 然后甚至说你可能在一些大公司 ， 呃 ， 就是光设计这个系统就要花费可能几天到几周的时间 。

对 ， 这个我觉得可能是非常非常容易理解的 ，是吧 ？ 有的人认为程序员主要的工作是写程序 ， 就这个名字起得比较 、 比较奇怪 ， 啊 ，但其实一般来说官方的头衔叫做软件开发工程师 ，是吧 ？

软件工程师是一个软件的 ， 我们是开发软件的 ，不是写程序的 。 我们很多一大部分工作并不是把这个程序写上去 ，而是开发软件 ， 软件就说我们这个按钮要放在这里 ， 要放在那里 ， 之后触发这个怎么怎么做的 ，是吧 ？

这个东西并不是一个完全程序的问题 ，是要你如果是你做和用户比较直接相关的 ， 可能会你对你对用户体验的理解 、 对产品的理解 。

如果是像我 、 像我 、 像我这样做这种这种底层的数据库的 ， 你可能还需要对这个计算机科学有些理解 ， 对吧 ？

对于这个整个整个下面的架构 ， 整个下面的这些如何有效地提高这个程序的效率 ， 应该还是会有一些理解 ， 需要做一些设计 ， 对吧 ？

这个过程在我的理解中是和写代码是一个交互的过程 ，并不是说传统来说可能说我想好了该干什么 ， 然后我们进入编程这个阶段 ， 然后编完然后进入测试阶段 ， 然后接着交互交代 。

它经常是一个是一个互动的过程 ， 我大概想是这样写的 ， 然后去写一下， 然后发现不对 ，有些东西没有想到 ，有很多东西你只要写了代码你才知道这是错的 ， 你认为东西是错的 ， 你以为的不是你以为的 ， 那我们要回去看 ， 啊 ， 我们的设计 、 我们的想法是有问题的 ， 这个是做不到的 ， 或者这个太慢了 ， 我们重新来做一下 。

这个过程其实要循环复很多次 ，不知道你们的项目是不是也都是这样 ，因为我们项目都是这样 ， 基本上就是你知道第一个版本肯定是有无数的问题的 。

对 ， 计划没有变化快 ， 很多时候你做 ， 啊 ， 计划的时候 ， 你做 ， 呃 ， 最初的这种设计的时候 ， 会有很多这种现实问题 ， 啊 ， 你没有去做的话你是不会想到的 。

对 ， 我们完成了我们的古法编程部分 ， 啊 ， 我们这个节目的风格就是我们要讲讲历史 ， 啊 ，AI 编程历史 ， 啊 ， 我们用一下这个 Gemini 的 DeepSeek， 啊 ， 发现它这个历史给我们溯 、 溯到什么自动补全 intelligence， 就都来了 。

所以我大我打算不讲了 ， 我们就从对于我们现在还有这个还有一些重要性的有影响力的平台开始 ， 啊 ， 叫 Copilot， 啊 ， 大家会认为 GitHub Copilot 应该是这个领域的里程碑 ，是吧 ？

我搜了一下 GitHub Copilot 比 ChatGPT 的推出还要早 。

对啊 ， 那当然了 ， 对 。

哦 ，是吗 ？ 来来个结巴 ， 来个说一说 。

就是在 ChatGPT，ChatGPT 不是 22 年的 12 月份推出的吗 ？ 然后在那个之前的可能 ， 呃 ， 一到两年， 具体多少年我不记得 ， 然后就是很多程序员已经在说他们的工作就是一直按 tab 嘛 。

为什么是一直按 tab 呢 ？ 就是因为 Copilot 它的这个代码补全 ， 就是当你在把光标移到某一个位置的时候 ， 它会在后面出现一个就是它觉得你可能会这么写的一个提示 ， 啊 ， 是一个就是灰色的提示 ， 那这个时候你按一下 tab， 它就会把这个提示变成你真正的代码 。

那因为它补全的效果其实后来也是越来越好了嘛 ， 所以大家就发现很多时候已经不需要手去敲代码 ， 就一直按 tab 就好了 ， 呃 ， 所以我觉得这个时候已经是一个就是非常和以前编程非常不一样了吧 ，但是可能还没有到后期这么的革命性 ，因为你毕竟还是要就是一个小代码块 、 一个小代码块的写 ， 对 ， 它只能在局部做一些补全 。

嗯 ， 所以 Copilot 大概是在 2021 年， 是吧 ？ 它使用的是 GPT， 就是 OpenAI 的模型 ， 就是最终和 ChatGPT 大概同一个时代的模型 ，是吧 ？

它的体验就是都是在 IDE 上吗 ？

我觉得 VS Code 里是用的最多的吧 ，因为它是就是原生了嘛 ， 就 Copilot 也是微软出的 。

所以它的编程体验就是你还是基本上还是写着过一个非常强大的自动补全 ， 可以什么都可以补 ，并且补得可以非常非常的好 ， 你可以补补补就变成一个程序了 。

而且当时大家已经开始为自动补全付费了 ， 就是那个 ， 呃 ，Copilot 的那个套餐 ， 我记得应该是 10 美元一个月还是几美元 ， 就是已经非常多人在买 ， 然后对吧 ， 包括也就是大家会去很想要被赠送那个套餐 ， 就是是一个算是程序员的半标配的东西了吧 ， 甚至 。

对 。

微软 ， 呃 ， 或者 GitHub 当时搞了一件事情 ， 就是它给它其实现在应该这个项目应该还有 ， 就是如果你是一个非常流行的 GitHub 项目的这个 ， 啊 ， 维护者的话 ， 它会免费送你 GitHub Copilot 的这个 subscription 这个订阅 。

然后我当时就是因为恰好是 Facebook 某个项目 ， 然后就是 contributor 吧 ，有这个权限 ， 然后就是每个月 GitHub 会免费送我 ， 就是靠这个东西蹭到了 ， 然后 Copilot， 然后就是用了一下 。

而且一开始的时候就是还很笨 ，也不是很笨 ， 就是当时的用使用方法就是如果我想写一个 ， 啊 ， 函数 ， 想写一段程序吧 ， 然后我就是先用那个评论 comment 的形式在这个代码里面写出来 ， 我说我想要一个注释 ， 啊 ， 对对 ， 注释 ，不好意思 ， 中文不太好了 ， 这个写先把注释写出来 ， 然后期待这个模型能看到我注释 ， 然后再通过注释 ， 然后再把

这我想要代码给写出来 。其实就是最初级的这个叫什么 prompt 的这种 ， 啊 ， 写提词的这种方式来写代码 。

啊 ， 这是当时写代码的一个就是一个里程碑式的项目 ，是吧 ？ 这个竟然是在 ChatGPT 出现之前 ， 让 ChatGPT 出现了 ， 这个时代就分为 ChatGPT 出现之前和所有事情都是这样 ， 分为 ChatGPT 出现之前和 ChatGPT 出现之后 。ChatGPT 出现之后， 大家发现其实很多代码可以在 ChatGPT 里面它给你给你写出来 ， 所以这件事情大家就就就对于业内有什么变化吗 ？

对于这个写代码这件事情 。

是这样 ， 就是最开始 ChatGPT 确实 ， 呃 ， 已经能写出还还行的代码 ，但是我觉得它的最大问题在交互 ， 就是你我经常做的一件事情就是我在 ChatGPT 里面问它 ， 比如说某一段某一段代码要怎么写 ， 然后它给出了一个 ， 呃 ， 一个结果 ， 然后我需要再把这段代码去手动粘贴回我的 ， 比如说 VS Code 或者是其他的 IDE， 呃 ， 那这个过程其实是其实是非常繁琐的 。

所以这个时候一个很自然的想法就是说如果我们能把这两块东西弄在一起 ， 就是你可以在同一个界面既去编写程序 ， 然后又和 AI 去 ， 呃 ， 问问题 ， 那不就非常好吗 ？

所以这个时候就是诞生了 ， 呃 ， 最早的像 Cursor 这种产品 ， 它其实最早的形态就是说它就是一个 VS Code， 本质上它是一个 VS Code 的 fork，但是呢 ， 它在右边加了一个和 AI 聊天的这样一个侧边栏 ， 所以你就直接在 Cursor 里面同时完成编写代码和 AI 聊天 ， 然后你可以去比如说一键把它的生成好的代码复制到你的这个主要的编辑器界面 ， 就是节省了很多的时间 。

哎 ， 这个确实 like9m 说的这个确实可能很很多人都感同身受啊 ，因为现在可能也很多人都经常让用这些 Chatbot，ChatGPT 啊 ， 或者是 Gemini 啊 ， 写程序在那个聊天框里 ， 就是你平时去豆包这种框里面去写程序 ， 然后我们过程就是我让它跟它说我要写这这这个 ， 大家这个你写个这个函数 ， 它就可以写了 ， 我贴过去运行 ，不编译也有错误 ， 然后我就把那个错

误信息再贴回去 ， 说有个错误怎么样 ， 然后它说啊 ， 可以这样 ， 我再试这个 ， 再贴回去 ，有个错误 ， 反正我的流程就是这样的 ，是不是 ？

但是 Cursor 还有一个很好的地方是你不仅仅你不需要把它生成好的代码贴到你的文件里面 ， 呃 ， 你也不需要把已有的代码贴给它 ，因为刚用 ChatGPT 的时候你不一定是说我有个问题 ， 你帮我凭空生成一段代码 ，而是我已经有一段代码 ， 你帮我调试一下， 或者你帮我优化一下， 对吧 ？

那你要把原有的代码贴过去 ， 接着再把可能出错的信息贴过去 ， 让它帮你调试 ， 然后有了 Cursor 之后， 它就直接读你原有的代码 。

然后 Cursor 还有一个很好的功能是你可以打开它的 terminal 控制台的窗口 ，在那里选一段出错的信息 ， 例如说我单元测试跑完了 ， 它抛出来这么一大堆的错误 ， 说单元测试没跑过 ， 然后你就直接在控制台选那堆东西 ， 然后选择添加到当前跟 AI 的对话 ， 然后添加完了 ， 它就知道哦 ， 原来控制台打出来单元测试没跑过的信息 ， 我就去修修修

修修 ，不仅这样子 ， 它修完它还能够继续跑新的单元测试 ， 然后它要盯着控制台是不是又打出来 ， 呃 ， 出错了 ， 还是说这次终于全跑过了 ， 然后它修到全跑过了才停下来 。

就是这种不仅仅能读代码 ， 还能读控制台的其他出错信息的这个当时是 Cursor 的一个很便利的地方 。

我们已经说到 Cursor 了 ， 我们还没有介绍 Cursor 这个这个东西 。Cursor 是另外一个 AI 编程领域非常里程碑的一个一个软件 ， 对吧 ？

它是由一个一个叫 Anysphere 一个公司开发的一个软件 ， 是一个创业公司 ， 它好像是在 2023 年开播 ， 这个是在 ChatGPT 后面推出后大概一年， 一年吗 ？

差不多一年多左右的时候 。 它这个这个产品是因为谁谁就是大体的介绍一下这个产品是是怎么个体验 ？

呃 ， 它就是一个大家如果有用过 VS Code 的话 ， 它至少早期版本它就是一个 VS Code 的 fork 嘛 。

嗯 ， 就是在一个 IDE 里面集成编译环境里面 ， 我们刚才说的一边是代码 ， 下面是编译框里面 ， 就在那个玩意里面 ，IDE 里面它怎么样了它 ？

它就是 ， 呃 ， 你还是可以写代码 ， 然后就是但是就加了这个 AI 的功能嘛 ， 就是我们说的这个这个聊天的侧边栏 。

侧边栏就是它在边上有一个类似于 ChatGPT 的一个栏 ， 豆包一样的栏 ， 你可以跟它聊 。

右边 ， 对 ， 你刚刚说的不知道右边那坨什么东西就是那个聊天框了 ， 现在大家都喜欢把聊天框放在右边 。

然后它之所以要 fork VS Code 是因为它要魔改 ，因为 VS Code 只能有有限的机制给你监听用户当前在敲的代码和提示新输入可能插入什么代码 ， 然后它要做的功能远不止就是这个能够做得到的限制 ， 所以它不能把自己做成一个 VS Code 的扩展 ， 它必须要 fork 一份 VS Code 来加入它这些 AI 的功能 ， 说我这里有一大段代码是 AI 准备要改掉的 ， 然后改掉了之后

你要不要接受啊 ， 还是拒绝啊 ， 那这些都是 VS Code 原本做不到的功能 。

所以说在有了这个之后就不需要说去自动补全了 ，在代码里面写写注释 ， 然后自动生成 。 我知道可能很多人用 Cursor 也还是这么用 ， 对吧 ？

但是它可能至少在我开始用 Cursor 的时候可能有有点晚了 ， 那时候它就是我是在右边跟它聊天 ， 它跟你说做了这个修改 ， 这行改成这个 ， 然后你批准不批准 ， 我不知道我是不是没有用到第一个 Cursor 版本啊 。

我我就可以聊一下就是 Copilot 和这个 Cursor 的差距在哪里 ， 为什么 Cursor 能够成为一家这样 ， 啊 ， 估值这么高的公司 ，但是 Copilot 作为这个这个先驱者并没有 。

就是我从我其实花了很长时间就是用在用 Copilot 上面上面 ，但是一直没有去换到 Cursor 上， 然后我换到 Cursor 上是第一次用 Cursor 是因为我要面 Cursor， 然后他们面试是可以用 Cursor， 然后我去那边 ， 呃 ， 面试的话 ， 然后就是他们给我一道题 ， 然后我就看了一眼题 ， 然后我就把代码重构了一下， 然后 Cursor 就把代码写完了 ， 然后面试就结束了 。

然后你录取了吗 ？

没有 ，但是那场面试是过了的 ， 就是就是我们就花了剩下的大概因为那场面试一个小时， 然后 10 分钟把这个事情搞完之后， 我们就花了 50 分钟聊天 。

对 ， 然后其实 Cursor 我觉得做得最好的有几个方面吧 ， 第一个是 ， 啊 ， 上下文管理 ， 它在当时你像 Copilot 的话 ， 它可能还是只是说你当前编辑的这个文件如何如何如何 ，但是 Cursor 花了很多功夫在保证说在优化你的上下文管理上， 你编辑过什么文件 ， 你在做什么 ， 它会去试图理解你的这个意图 ， 你要试图理解你在做的这件事情 ， 然后来帮你说这个

生成更合适的代码 。 但像 Copilot 的话就会相对来说傻一点 ， 我刚改了这个 ， 呃 ， 按钮 ， 然后我再跑回来改这个 ， 然后它又不会记得这件事情了 ， 它会依然当成这是一个新的代码来看待 。

第二件做得比较好的就是这个用户体验 ，Copilot 的话它基本上当时就是应该可能是 24 年左右 ，2224 年 25 年吧 ，Copilot 的话就是它只会在你的当前这个编辑这个光标后面来补 ，但是 Cursor 做能做到一件就是你不停地按 tab， 你不仅能在当前光标下面补 ， 它会建议你说你改了这个之后， 你可能还要改 10 行 、20 行 、100 行之后后面的这另外一个函数 ， 然后它会自动把你的

光标挪过去 ， 然后在新的地方继续生成 。其实这样的话就已经解决了更大的一个问题 ， 就是我改完这段代码 ， 我要接下来改下面这个代码 ， 然后把你的这个整个这个工作流的方式就变成了就纯粹的按 tab。

之前的话你可能按按一下这个 tab 键之后， 你还要去换几行代码 ， 找到新的代码再继续进行下去 。 然后再加上那个侧边栏的话 ，其实我一开始把那个侧边栏就是当成 stakeoverflow 在用 ，但是后面的话 ， 当你把这个编辑这个功能 ， 这个编辑这个能力 ， 这个工具交给了 AI 之后， 这个 AI 就可以真正的来帮你这个编辑代码 。

我说我把这里面的是如何重构一下， 如何把这个功能实现一下， 我想要实现成什么样子 ， 然后就直接交给侧边栏 ， 告诉侧边栏 ， 然后就回车 ， 然后 AI 就会自动地把这个东西编辑好 。

我觉得这是可能是 Cursor 相比较这个 Copilot 来说的一些优势吧 。

对 ， 那个改未来多少行的那个我一开始遇到的时候也觉得非常的酷 ， 就用个最简单的例子 ， 你把一个变量从一个名字改成另外一个名字 ， 对吧 ？

你又没有直接用 ， 呃 ， 搜索和替换 ， 然后你改完这里它就会自动地发现 ， 哦 ， 后面的还用到这个变量 ， 我帮你都提醒你是不是一个一个都要改掉 ， 就就非常非常的酷 。

所以 Cursor 是一个在 Claude Code 出来之前 ， 大家所有人都在说 Cursor 的这么一个里程碑式的项目 。 我认为 Cursor 是真正给大家一个印象是 AI 可以写代码了 ， 我在我印象中是是是这样的 ， 就是真的可以认为它能写出相对完整的一段一个功能 ， 确实是让人非常震惊的项目 。

所以这是 Vibe Coding 这个词开始出来的时候 ， 实际上是在 Cursor 时代 ， 对吧 ？Vibe Coding 这个词出来的时候 ，其实 Claude Code 还没有推出 ， 至少没有官方推出 ， 对吧 ？

所以我们就又又推出了一个另外一个里程碑项目 ， 我们这个时代变化太快了 ， 我们第一个里程碑就是 2021 年， 到现在 2026 年 5 年了 ， 我们有这么多里程碑 ， 就换代这么多年了 ， 我们会出现中间还有还有一些历史的炮灰 ，是吧 ？

比如说什么 Windsurf， 咱们还聊吗 ？

跳步 ， 历史的垃圾时间 。

时代变化太快了 ，是吧 ？ 然后这个就就进入了一个标杆 ， 到现在现在为止依然是标杆的一个程序 。 可能很多人也听说过叫 Claude Code， 我们谁来聊聊 Claude Code。

对 ， 我可以简单说一下 Claude Code，其实 ， 呃 ， 我觉得 Claude Code 它的里程碑意义就是它把这个我们说 AI 编程真正进化到了 Agent Agentic Coding， 就是 Agent 编程 。

智能体编程 。

对 ， 智能体编程 ， 就可能对于不是程序员行业的朋友来讲 ， 这两个可能比较难理解 ，但你可以大致理解成就是说在就智能体编程之前的时代 ， 大家和大模型的交互还是说这个以一问一答的形式为主 。

那么大模型它其实是很难去 ， 呃 ， 自主地去 ， 呃 ， 完成一些更长时间的工作 ， 比如说你真正要问它 ， 它才能给你一个一个结果 。

呃 ， 那其实在 Agent 时代呢 ， 我们就是让这个大模型它能够自己跑起来 ， 比如说我们就给它一个非常的非常高层的一个目标 ， 那其实它能够去大模型就可以去 ， 就是或者说 Agent 可以自己去判断说我为了完成这个目标 ， 我要把它拆解成几步几步 ， 然后呢 ， 我去运行这样一个一个循环 ， 比如说先生成一个结果 ， 然后我自己再去测试这个结果有没有达到我的目

标 ， 然后如果不行的话我再接着去跑 。 它其实是 ， 呃 ， 能够完成一个更长时间更复杂的任务 ，并且是自主地完成 。

那所以这两个其实是 ， 呃 ，有一个很大的分界 。 那这个分界基本上普遍认为就是从 Claude Code 出来就是做一个分界 。

那 Claude Code 也可以说是第一个就是 Agentic， 就是智能体编程的一个产品 。 呃 ， 那其实它是在 Anthropic 内部 2024 年 9 月份开始的一个一个项目 ， 最开始其实它的创建者 Boris 说他就是把它作为一个自己的这种业余实验的项目 ， 就是比较比较好玩的一个 ， 呃 ， 试验性项目 。

所以他的想法就是说 ， 呃 ， 如果我们能在就是一个就是 terminal 环境下给你的大模型提供一些权限 ， 比如说让它编辑文件 ， 然后让它操作各种的 ， 呃 ， 你的命令行里的工具 ， 那它是不是能够做更多的事情 。

然后他们把这个原型做出来之后发现 ， 哎 ，其实是非常的好用 ， 就是它相比于你一个单纯的聊天框 ，是吧 ？

它可以做更多 ， 呃 ， 更有意思的事情 。 那这个后来在 2025 年 2 月份推出之后， 就是 ， 呃 ，Claude Code， 然后大家就被这个东西震惊了 ，因为之前对吧 ， 大家就是就是在这之前还是以聊天框为主的这个形式 ， 呃 ， 没有说 ， 呃 ，Agent 可以去 ， 哦 ， 我可以直接去就是直接改文件 ， 或者说我去直接做一个什么网络搜索 ， 或者我直接去操作一些 Git 的命令 ， 这些之前都

是没有的 。 那大家突然发现 ， 如果我们把这些这些能力赋予给你的大模型 ， 它就可以自主地做很多事情 。

所以 ， 呃 ， 就是 Claude Code 是一个非常非常革命性的一个软件 ， 甚至说定义了一个新的范式 。

嗯 ， 我从程序员的角度来讲 ， 一开始 Claude Code 这个产品出来非常非常不适应 ，因为它使用的是终端上的命令行 ， 非程序员可能都不知道这是什么 。

那就是有的时候你在操作系统里面 ， 手机上没有 ， 起了一个黑黑的框 ，也可能是白白的 ， 反正是一个框 ， 这框上面你什么什么什么回车出来一个 ， 然后你再打什么什么回车 ，是那么一个框 。

可能程序员知道你你你过去可能年龄稍微大一点的可能知道有的时候你需要操作一些这个文件 ，是吧 ？ 文件复制复制这个文件从哪儿到哪儿 ，在那命令行上做这些事情 。

这件事情可能程序员我们是经常用的 ，但是非程序员是很少用这件事情的吧 。 我就是程序员我们经常在上面编译嘛 ， 对吧 ？

或者或者是处理一些文件上的问题 ， 然后就是在上面跑的 ， 单元测试通常是在上面啪啪啪啪啪啪啪啪 ， 啊 ， 结果是 ，但是 Claude Code 的使用就是一个命令行 ， 它是一个命令行 ， 我在命令行里面跟它编程 ， 这点是一个非常非常的不适应 ，因为我看不到代码 。

我就跟它说你在这个代码库里面给我增加一个什么什么什么功能 ， 回车 ， 然后它就啪啪啪啪啪啪 ， 然后然后说我给你做了这个修改 ， 多少多少行 ， 它有的时候告诉你做了这个修改这行这行这行 ，但是它没有 ， 我看不到完全的代码 ， 就告诉你这行从这个改成了这个 。

我非常非常不适应 ， 我现在依然非常不适应这件事情 ，但是这就是这就是 Claude Code 的一个体验 ， 对于非程序员可以体验一下 。

对 ，其实它的这 Claude Code 出现 ， 我们可以说它是定义了一个新的交互方式 ，但 ， 呃 ， 同时也必须要说它是因为模型的能力真的到了那一步 ， 所以我们才能够去做 ， 呃 ， 让它做更多更强大的事情 。

对 ， 所以我们说到历史了 ， 我们可以正好到下一个部分单聊现在编现在的软件开发的流程 ，RenLoop 还是叫怎么说 。

是什么样的啊 ？ 啊 ，但是在这历史上还有什么别的需要说的东西吗 ？ 还是我们就历史的终结了 ？

呃 ， 可以再聊一下 Claude Code， 就是 Claude Code 出现之后你会发现就是 ， 呃 ， 像 Cursor 我们说它最早其实是一个这种侧边栏的模式嘛 ， 那它后来也开始增加这种 Agent 模式了 ， 就是所有的编程工具 ， 包括 Windsurf， 然后什么就是 Devon， 就你发现很多这种强调 ， 呃 ，是 Agent 编程的工具开始出现了 。

那就是其实本质上它们都是在模仿 Claude Code 实现了这样一种交互 ， 就是让让 Agent 自己去完成很多的任务 ， 无非就是你用不同的一个界面 ， 对吧 ？

可能是你用命令行界面 ， 或者是一个在 terminal 里面 。 对 ，但其实这种 Agent 模式开启 ， 我们可以认为都是从 Claude Code 来的 。

对 ， 所以 Cursor 现在又变 ， 我认为它其实 Claude Code 能够做的事情是没有太大差别的 ， 就是它也可以给你编 ， 还是有差别 ，但是它也可以给你编译也可以 ， 然后看结果也可以 ， 就只能没有后面调到的 MCP 这些玩意儿 。

但是就是说它在这个目录树下面可以做的事情 ， 基本上 Cursor 的右边的聊天行也都可以做 ，是吧 ？ 但是就是它的范式可能是不一样的 ， 过去 Cursor 可能并没有强调这些整个的这些自动地做这些 。

而且我觉得还有一个很大的变化是由 Claude Code 开启的 ， 就是你原来所有的这种程序员的软件工具软件都是以代码为中心 ， 你永远是需要去编辑代码 ， 就 AI 可能只是做一个辅助 。

那 Claude Code 就是开创了一个你不需要去看代码 ， 就或者换句话说 ， 它做完就是 AI 修改完代码才把它修改的部分给你看 ， 是一个这种按需去看代码的流程 ，而不是像原来一个你需要去首先看代码然后再做出修改 。

我觉得这个变化也是非常大的 ， 包括你可以看到现在所有的这种 ， 呃 ，以 Agent 为中心的编程工具 ， 它的这样一个主界面都不再是代码编辑器了 ，而是一个以 ， 呃 ， 和 Agent 聊天的窗口 ，而只有说它做完一个修改 ， 你需要去 review 这个代码的时候 ， 它再让你在就是右边去看代码 。

换句话说 ， 原来你的这个和 AI 聊天是在右边的侧边栏 ，但是现在 AI 聊天是在一个中间的主窗口 ，而你的代码 review 看代码的部分被挪到了右边 。

所以这样一个替换也是非常有意思的 。

对 ，不仅仅你不主动去看代码了 ， 从 Cursor 到 Claude Code 的一个切换背后也有一个很有意思的地方 ， 就是它也不主动索引代码了 。

就是 Cursor 的设计是说它会主动地去索引你的代码库 ， 这样子它能够用搜索功能去找到相关的代码 ， 或者相关的这种变量名啊 ， 函数名啊之类之类的东西 ，因为它都可以先索引 。

然后 Cursor 变成了 Claude Code 之后，Claude Code 的一个创新的点是说 ， 我就跟一个新上手这个代码库的工程师一样 ， 我什么也不懂 ， 我一上来我先用工具搜索 ， 我不需要提前索引的 ， 我就开始用 Grab 来搜索我的源代码 ， 然后我以这个过程来学习你的代码库 ， 现学现做 ，而不需要提前学 。

啊 ， 这也是一个很大的转变 。 好 ， 那我们就正好进入了下一个体验 ， 我们说一说现在现代编程 ， 就是古法编程了 ， 现代编程是是是什么样的 ？

哎 ， 可能我们我们现在我们几个人其实在不同的项目 ，是吧 ？ 可能大家体验可能会不太一样 ， 我们可以说一说我们现在都是怎么编程的 。

我我也不知道大家怎么编程 ， 可以听一听大家是怎么编程的 。 我可以先说我 ， 我是怎么编程的啊 。

我现在编程一般是是从 Claude Code 开始 ， 打开那个命令行 ， 这命令行我跟它说我要做一件什么什么事 ， 然后一般来说 Claude Code 会会给我制定一个计划 ， 就会先先做一些 ， 比如说一些研究 ， 它会根据这件事情 ， 它会去读一些内部文档啊 ， 它会去搜索呀 ， 它会去做一些研究 ， 去看一下代码 ， 然后做一些研究 ， 然后就跟我说你要完成这个 ， 可能需要有这几个 ，有这样的技

术挑战 ，有这样的问题 ，但是我的计划是这样的 ， 第一做这个 ， 第二做这个 ， 第三做这个 ， 大概会有一个计划 。

我看一下这个计划 ， 然后说它有道理 ， 嗯 ， 没有道理 ， 我有时候可以跟它互动一下， 它说你这个好像没有什么 ， 为为什么要这样做 ，不能这样做 ，因为它都非常非常地尊重 ，因为它会拍你脑袋 ， 这个理解非常地深刻 ， 你说的确实是对的啊 ， 大概就是搜索一下 ，有的时候它说啊 ，但是我试了一下， 这个是遇到会这样的问题 。

那大概就是它会你会你会跟它互动 ， 这个计划做得更好一些 ， 然后最后它会形成一个计划 。 那这个过程中你你你可能会说你没有考虑到这个问题 ， 你有没有看一下这个文档 ， 你去你去看一下这个代码 ， 反正就是说你会跟它互动 ， 最后它会是会有一个计划出来 ， 你这个特性呢 ， 我们要做这个啊 。

但我一般比较懒 ， 就继续在那个继续继续上编了 ，但好像一般来说很多人会分别的 session，但这就是别的话了 。

我一般比较懒 ， 它一个计划完了 ， 我就跟它说执行 ， 然后它就开始编 ， 编上几个小时之后呢 ， 然后它就会出一个东西啊 ，但是它也跟人一样 ， 编的时候才会发现前面的计划有很多很多的问题 。

它有的时候现在新的版本它会跟你说啊 ， 我看了一下发现你这个计划是不行的 ，因为什么什么什么 ， 你再跟它互动互动互动互动 ， 说说说说说 ， 然后最后呢 ， 它就写个程序 ， 然后我就看了 ， 然后我还去会去看一下它的代码 ， 或者说我让它解释一下你写写了什么什么什么什么东西 。

写完之后我会跟它说你这个测试 ， 这个没有测试 ， 你要测一下这个 ， 要测一下这个 ， 你要测一下这个 ， 呃 ， 测 ， 然后它就会花很长时间说这啊 ， 这个测试不通过了 ， 我来继续改一下， 测试不通过了 ， 我们改一下， 反正就会循环往后几个小时， 就是它在那干活 ， 什么事也不干 。

我还需要经常跟它去跟它说批准它的它的这个变化的计划 ， 然后最后呢 ， 出了这个第一个版本 ， 然后就是就就要说啊 ， 请发送一个这个叫什么 pull request， 怎么说 ， 拉取请求 ， 我们要去去这个 GitHub 里去给别人看了 ， 丑媳妇要见公婆了 ， 然后那边那边人不知道怎么 review， 虽然一般都会经经常说你这你你这个就就是一坨屎 ， 然后我就回来我就看一下，

然后要尊重这个 code review， 我一般还还是还看一下 ，但是有的时候看不懂 。 但是我看的时候呢 ， 我会跟 Claude Code 说 ，有人评论了 ， 你去看一下这评论 ， 评论一下，Claude Code 就会去那看什么评论 ， 然后然后有的时候会说这是对的 ，有的时候这是不对的 ， 然后再继续修改 ， 就是这个循环会很多很多次啊 。

啊 ，但是我就不不放说了一点啊 ， 就是说我在发 code review 之前呢 ， 一般是这样的 ， 一般是我会再开一个多个 AI， 用 Cursor 或者再开一个 Claude Code， 或者再弄一个什么 ， 去那个窗口里跟它说我本地有一个修改 ， 你可以给我 review 一下吧 。

啊 ， 一般会多换几种不同的 ，因为就是有有一种信仰认为可能别的它这个理解不一样 ，其实我觉得都一样 ， 就是会欢迎 code review 一下， 它会一般都会尖锐地指指出很多问题 ， 然后我一般就会把它贴回去 ， 说有个 AI review 一下会认为这个你有一下一下问题 ， 然后这个 Claude Code 就会回来看一下啊 ， 然后然后它会会说这个 review 是一坨屎 ， 这根本就不对 ， 反正会

就会然后然后然后我再贴回去 ， 反正就是我做一个搬运工作 ， 让这个两个 AI 互骂 ， 然后最后达成一个协议啊 ， 大概就是这是我的这个我现在进行代码流程的那个一个一个过程啊 。

如果有重要代码我还是会去看代码的 ， 先看代码非常非常非常困难 ， 我还是需要 Cursor 里面打开这个文件 ， 我还不知道它改在哪 ， 很讨厌 。

有有的时候我要让它发一个这个合并请求 ， 我自己去那个网页上看它改了什么 ， 我要回 Cursor 看啊 ， 非常非常 ，但重要代码我还是必须要看 ， 然后就是非常非常蛋疼的过程 。

最后这个它写完代码我审核 ， 这个过程是非常非常的蛋疼 ， 非常非常困难的一个过程 。 对 ， 我说了一下我的体验 ， 然后来客 9M 说说你们的体验是不是跟我比较像 。

哦 ， 我就是好奇问一下， 就是因为那个你其实可以在编辑器里直接去 comment 它写的那些代码 ， 就是为什么你不直接在编辑器里啊 ，有编辑器吗 ？

你如果是用 Cursor 的话是可以的 。

是啊 ，但是我用的是 Claude Code 呀 。

哦 ，OK。

啊 ， 我我我是可以用 Claude Code 那个插件哦 ， 真的是我是可以用 ，但是我我不喜欢那个 Claude Code 里的在 Cursor 里插件 ， 我还用的是命令行啊 ， 这个主意不错 ， 下次我可以用 Claude Code 那个插件我去看啊 ， 我可以试试那个啊 。

来 ， 要不来客 9M 说说你现在 ， 我觉得来客 9M 项目应该跟我的比较像 ， 应该不太像 ， 都不太像 。

我这是一个十年的 codebase， 很难演进的啊 。

对 ，其实我之前在 Google Ads 组的时候 ， 我们的那个 codebase 可能跟你们比较像 ，也是一个历史非常久 ， 非常复杂 ，是改了无数多遍的一个 codebase。

那这个时候哦 ，而且我们有很多这种 internal 的 framework， 就是大模型根本不知道怎么改 ， 所以这个时候我发现其实 AI 编程它比较有限作用 ， 就是很多时候你真的是还是需要去手动改 。

对啊 ， 它可能能帮助你做一些这种 ， 比如说你的假如说你的这个 codebase 里面已经做过一次这种事情 ， 然后它有一个例子 ， 那你可以它可以比较容易地去啊 follow 原来的例子去找到 。

但如果说没有这样的东西的话 ， 就就比较难 。 当然我觉得就是对 ，其实可能我们说如果是一个完全现在从零开始编写的代码库的话 ， 可能你在跟呃使用 Agent 的写代码的过程中， 它已经会积累了很多这样的啊 memory， 对吧 ？

它其实是就是可以去了解你整个代码库是是怎么演化成这个样子 ， 那就会更好一点 。

哎 ， 所以 laik9m 和 Rice 你们都是从零开始的项目是吗 ？ 用 AI 的项目是吗 ？

现在可以认为是从零开始 。

哦 ， 那我们那谁给我们介绍一下你们从零开始的项目都是怎么用啊 ？ 怎么用 AI 写的 ？

好好 ，因为我最近做的这个项目是真真正正的纯粹纯粹 AI 写的代码 ， 这个整个项目里面没有一行是人写的代码 ， 包括 Readme 都是啊 AI 写的 。

这个项目呢 ， 就是所有人大概十几个人吧 ， 每个人都是在用 Claude Code 或者 Codex 之类的 ， 然后从 prompt 翻译成代码 ， 然后呢啊我们没有 code review， 我们没有这个代码审核 ，code review 都不做 ，code 我们没有 code review， 我们不做 code review，因为因为代码产出量太高了 ， 这个代码审核是一个瓶颈 ， 然后如果你出来的每一行代码你都要人来审核的话 ，其实这是非常没有效率的 。AI 审核也没有吗 ？

这这就是我接下来要说的 ， 就是我们是有 AI 审核 ， 然后我们是有 AI 交叉审核 ， 然后其实啊这个 AI 交叉审核其实蛮蛮非常有用的 。其实据我个人经验来看 ， 就是啊还是抓到了一些我没有仔细没有抓到的这个 bug 的啊漏洞的错误的啊 。

然后我们我们有一个项目里面写的这个 Agent.md 这个东西呢 ， 就是啊上下文管理用的 ， 就是应用于整个项目的这个上下文管理 。

它其实很明确的就是要求说 AI 在写代码的时候一定要玩命式的加测试 ， 就是你不管做什么功能 ， 我就算有时候我让它帮我改一个很小的 bug， 它就一定会给我加个三四个测试进来 。

然后当然这个测试有没有用 ， 能不能抓到 bug 这个事情另说 ，因为我觉得它会产生出来很多这种 overfit 非常过拟合的这些测试出来 。

但是它就结果就是我们的这个整个项目里面不仅代码量很多 ， 测试也很多 ， 然后每次就是这个提这个拉取请求的时候 ， 合并请求的时候都会有都需要跑很多很多测试 ， 然后有时候其实跑挂了 ， 我就直接把这个错误信息然后再丢给 AI， 然后 AI 继续这个改 ， 直到改到它能这个能对就好 。

当然这个事情是很有这样的工作方式是蛮有效率的 ，但是导致的结果就是其实这整个项目 bug 蛮多的 。

然后刚刚这个斯图亚特老师说 ， 对 ， 斯图亚特老师的同事试了我们项目说 bug 非常多 ， 这个我一点都不意外 ，因为因为我自己测试的时候也会经常发现好多很多 bug， 就是多到就是我完全就没有没有再记了 。

这个事情就是慢慢在慢慢在改 ， 然后很多时候其实这些 bug 的根源在于没有进行一些很好的设计 ， 需要进行一些架构性的改变 ，而不是你很多时候我我们其实很精 ，因为做的是一个 AI 也是 AI coding 相关的产品 ， 它一个很常见的 bug 就是我一条这个 AI 说你好 ， 然后我在 UI 上显示出来是两条你好 ， 然后就这种会出现重复信息这种 bug， 就各种各样形式的重复

， 我们都每天都在见 。 我每天很多时候我就是在修这一类 bug， 然后修完之后， 然后第二天 ， 然后因为我有新加坡同事之类的 ，他不是说新加坡同事写的这些 bug，而是就是合并完之后， 大家的一天的工作结束之后， 然后第二天我打开 ， 然后又出现了新的这种信息消息重复的这种 bug， 我就要要再修一遍 。

所以很多时候就是 ，但是你如果说你有一个很好的整个系统设计来 track 来进行管理这些啊消息的话 ， 你可能会很轻易地来把这件事情避免解决掉 。

然后另外一件事情就是我其实还是有在 review，有在看代码这个 AI 产出的这些代码的 ， 它有时候会做一些并不是一些很好的这个决策 ， 就很简单 ， 修 bug 的话我会直接开一个 AI， 然后让它们在后面慢慢跑 ， 加加一个 git work tree， 然后让它们在里面慢慢修 。

然后但是如果是在开发新功能的话 ， 我可能就像啊斯图亚特老师一样 ， 就是先让 AI 去研究一些代码 ， 给我一个方案 ， 然后我来审核一下这个方案 ， 我觉得这个方案可以或者不可以 ， 或者有什么地方需要修改的 ， 我会根据这个根据实呃情况 ， 然后跟这个 AI 一起把这个方案改好 ， 改好之后再交给这个 AI 来处理 。

然后这基本上是这样一个我觉得是一个非常有效的方式 。 然后同时我们还维护了很多 ， 当然除了我前面提到这个整个项目上的这个 Agent.md， 我们还有每个子模块子项目 ， 然后包括这些设计的这些 AI 产出的这些设计方案 ， 我们都会放进代码库里面 。

所以这个 AI 在做设计的时候 ， 它其实是可以看到前面其他的 AI 做的设计的 ， 然后它会可以借鉴 ， 然后来做类似的设计之类的 ， 然后或者说有什么其他地方可以复用 ， 可以重复 ， 可以学习的 ， 它都会自动来找到 ， 自动来用 。

嗯 ， 所以所以相当于你们的设计文档 ， 当然设计文档是 AI 生成的 ，也都在整个这个代码库里面 ，是以文本文件的形式存在代码库里面 。

所以 AI 在编程的时候不仅仅是看代码本身 ，也看你们代码库里面一些设计 ， 那那它们会主动地去去更新吗 ？

对 ， 会更新 。 它说哎 ， 你把这个东西改了 ， 我要把这个设计文档改好 ， 然后它同时也会在代码里面写很多的注释 ， 就像我刚我前面提到说 ， 直到因为这是一个就是我们做了一个多月 ， 然后开源的项目 ， 开源之后我才意识到啊 ， 我们居然有一个文件 ， 它有 18,000 行 ， 这个就是完全没有人提过 ， 完全没有人见过 ，因为整个项目没有人去读代码

， 没有人在看代码 ， 没有人在写代码 ， 然后所以就是这是件非常不可思议的事情 。

如果有人看 ， 可能会加一个 linter 打 md， 文件不要超过多少多少行是吧 ？ 就没有人加这个 linter 打 md 是吧 ？

对 ， 我深刻怀疑说这个其实你代码量到 18,000 行的时候 ， 对智能体的这个上下文管理非常有啊 ，是非常不利的 。

所以将来某个时段我要把这个文件分开 ， 可能会让我们的这个智能体编程变得更有效率一些 。 但是啊 ， 就是因为正是因为这样 ， 所以会出现一些很很简单很基础的这些很很好笑的这些呃问题 。

但是实际上项目最后是 deliver 了 ，是这个做出来了 ，也宣布了 ， 就是基本上是一个勉强能用的状态 。

所以 laik9m 你们的工作流程也都是差不多吧 ？

我觉得是差不多 ， 就是啊 ， 可能我个人还是偏向用一种带图形界面的编程工具 ， 就是不是 Claude Code 的 。

我们哦 ， 我可以说一下， 就是我们之前本来其实是想讲 Windsurf，但是跳过了没有讲 ，但其实就是 Windsurf 也是一个和 Cursor 可能比 Cursor 稍微晚一点出的这种 AI 编程的 IDE 嘛 。

它前身其实是 Codem 啊 ， 对 ，Codem 又是一个 Copilot 这种竞争者 ， 对 ，他们与时俱进啊 ， 做了 Windsurf， 然后 Windsurf 在去年的时候被啊 Google 收购了 ， 就是收购之后 ，他们其实是只把核心团队挖过来 ， 然后啊这个原来的 Windsurf 就变成了 Google 的一个官方的编程工具 ， 叫 Antigravity，不知道有没有听众用过 ，但是就是因为 Google 原来其实没有一个这种啊 AI 编程工具的嘛 ，Google 大家可能也知道不是很擅长做这种

2C 的产品 ， 所以它就啊收购了一个团队过来 ， 然后他们把这个产品带过来啊 。 那现在这个 Antigravity 既是 Google 官方面向外部的一个啊主打的 AI coding 编程产品 ，也是我们内部主要使用的一个工具 。

对 ， 所以其实啊就 Antigravity 和 Cursor 和甚至和那个 Codex 没有什么特别大的区别 ， 就是现在这种 Agentic coding 编程工具长得都非常的非常的像 。

对 ， 然后呃可能我可以聊一下， 就是就是因为我之前也在 Google 做了一个那种 code review 的 Agent 嘛 ， 对 ，其实确实是会像 Rice 说的这样 ， 如果文件大了 ， 这会是一个很大的问题 ，因为就是就是大家可能也知道 ， 就是大模型的上下文其实是有限制的嘛 ， 那其实大模型它其实没有一个就是内置的记忆 ， 那它所有的这种啊 ， 它要知道你这个项目在做什么 ， 它需要每次都

依赖于一个外部的输出 ，不论它是去读你这个文件 ， 还是读啊你存在代码库里的这些文档 ， 这些设计文档 ， 或者是啊它自己记录的 memory， 那这些东西从全部要重新塞进去的话 ， 就如果它这些东西多 ， 就会造成一个很大的问题 ， 就是它塞不下了 ， 直接爆了 。

所以就是会有很多的这种啊技巧去怎么样让它哎 ，不要一次性地去把这些文件读进去 ，而是可能啊 incrementally 地读 ， 或者只有在它需要的时候再读 ， 就是一个就是可能做这种啊 AI coding 编程工具需要处理的最最大的问题 ， 就是怎么去管理啊你的上下文 。

那这关于上下文管理 ， 我们待会可以专门地聊一下啊 ，因为我们待会要讲一讲这个技术啊 。 对 ， 所以现在现在编程体验就是这样的 ， 我们项目里面 ， 项目里其实也大同小异 ， 只不过是最终有没有人内部有多少 ， 大概就是这样 ，但是大这流程差不多 。

哦 ，但我们还是会要求人类来 review 的 ， 就是强制的 。

对 ， 我可以插一嘴 ，因为之前在 Meta， 然后啊 Meta 做 coding 这个 ，不是说做 Claude Code 这样的 Agent，而是在在早对标 Codex 的时候 ， 时代这个 coding 其实一大挑战就是因为 Meta 做了很多自己的个性啊 ， 自己的定制 ， 它有自己的编程语言 ， 基于 PHP 做的编程语言 Hack， 然后它有自己的一套工具 ， 然后当然外面来的 AI，不管是 GPT 也好 ， 还是这个 Sonnet 之类也好 ， 它不懂这些语言 ， 它不会写 ， 特

别是 Hack，因为它是基于 PHP 的语言 。

Hack 是开源的呀 。

它是开源 ，但是外面代码并没有很多 ， 所以这个 GPT 就会开始在 Hack 文件里面 ，因为它长得很像 ，在 Hack 文件里面写 PHP 代码 ， 然后所以写出来是完全错的 ，因为不能用 ，因为就是改了很多东西 ， 或者说是是一件非常没有效率的事情 ， 就是因为 Hack 某些地方是跟 PHP 有一定兼容的 ，因为像 Flow 的 PHP 的那个 standard library 的这些 function 其实有一部分是可以用的 ，但是是不建议使用的 ，

或者说是有安全隐患的 。 所以说它导致就是当时就是反而当你做更多定制化之后， 你没有办法去直接用市面上的这些编程 ， 这个语言模型来进行这个编程工作 ， 对于大公司来说 。

只能自自己调个模型了 。

对 ， 我跟别人说我用 Cursor 或者是 Claude Code， 别人经常有有一半时间第一个问题就是这东西对于 Scala， 我现在很多时候用 Scala，Scala 可以吗 ？

啊 ，但是 Scala 非常好 ， 用得非常好啊 ， 我觉得不是吗 ？ 我没有看到任何问题啊 。

对 ， 所以所以其实啊一些公司已经在啊推广说我们就是不要用这些奇怪的这种小众语言 ， 像啊一些原本用 Scala 的公司就是在推往 Java 上改 。

但是大模型用 Scala 还是非常非常不错 ， 特别是你说这点并没有任何的问题 ，但但很多人第一个问题就是这样 ， 没有训练集 Scala 差吗 ？

对 ， 大模型写 Rust 也蛮好的 。

Rust 不是小众语言 ，Rust 那是大众语言啊 ， 就是比较难 。

对 ， 我觉得其实啊我们既然这岔开话题 ， 我觉得其实 Rust 在这个这种智能体编程时代是非常非常有优势的 ，因为就是比如说你去让这个 AI 去你去写一段 Python 代码 ， 你虽然它能跑 ，但是它可能有一些各种奇奇怪怪的 bug 出来 ， 然后这个时候 Python 并没有一个工具来告诉你说哎 ， 你这里写错了 ， 你那里写错了 。

但是 Rust 因为它本身就是有很多做了很多编译器 ，在编译的时候进行一些检查 ， 然后它会很帮你提早地发现问题 ， 然后直接就反馈给 AI， 然后 AI 会直接改掉 。

所以说我觉得就是因为它的工具链更成熟 ， 它能找到 bug 更多 ， 可能会更适合将来这种啊这种 AI 时代的编程 。

嗯 ， 我更想用 AI 做 Python 的项目 ，因为我也搞不定啊 ， 这个这是才是我需要 AI 的地方 。

AI 可能最会写的就是 Python 了 ， 我觉得 。

呃 ，laik9m 你刚才想想说什么来着 ？

哦 ， 之前啊 Rice 提到那个点嘛 ， 就是啊可能 AI 它不知道一些这种小众语言 ， 或者是内部的 ， 尤其是内部创造语言 。

就我去年写过一篇文章叫那个英文标题是 Avoid Mini Framework， 翻译成中文就是避免去用一些微型框架 ， 然后我在那个文章里面就是提出 ， 就是因为我发现 Google 内部它很喜欢做这种微型框架 ，是什么意思呢 ？

就是就可以理解为每个组它自己定制的一个框架 ， 它就是服务那么啊几个人十几个人， 然后它觉得就是在就是你可能能抽象出一些东西 ， 然后让你的编写业务代码更加的简便 。

但是在 AI 编程时代 ，其实这就是一个很坏的一个一个行为 ， 就是因为 AI 它不知道 ， 它没有这些自己编写的微型框架的训练数据 ， 它根本不知道你这个东西怎么 work，也不知道怎么写 。

所以你这个时候再去做一些这种就是用它来写代码 ， 就是非常的没有效率 。 对 ， 换句话说 ， 你就是自己把自己用 AI 编写代码的可能性给扼杀了 。

所以我就是强烈不建议在 AI 编程时代自己大家去搞一些这种啊这种对吧 ， 自己的定制框架 ，因为你其实做这种定制框架很大的一个初始的动机 ， 就是你想去少写些代码嘛 ，但其实现在都是 AI 写的对吧 ？

其实你这个人力少写几行代码根本没有任何的意义 ， 所以你不如就是让 AI 去用这种最大家在普遍用的编程工具啊编程的框架 ， 它就能写得很好 ， 那代码多一点又怎么样呢 ？

这个无所谓的 。

我过去 AI 之前很多人也会骂重复造轮子嘛 ， 对这些大公司重复造轮子 ， 大家就公司外的人都是各种 。

对 ， 现在就是更应该避免了 。

对 ， 只不过那个时候没有这种动力嘛 ， 就可以骂过去 ， 为什么你要写这么一个 ？

甚至我有一个暴论 ， 就是说可能因为 Agentic coding 就是 Agent 编程发展得已经太好了 ， 然后甚至可能抑制一些新的框架产生 ， 比如说原来的那个什么 Python Web Framework 嘛 ， 可能隔几个月就出现一个新的啊这种一种框架 ， 那现在这个时代你出了一个新的框架 ， 你 AI 写不了 ， 那大家就不会用 。

所以可能就是这个需求就会越来越少了 ， 大家就会就是专注于以往的这些比较流行的框架 ， 像什么 FastAPI 啊 ，Django 啊 ，Flask，因为 AI 它知道怎么写 ， 它对吧 ， 它能写得很好 。

对 ， 这点我其实不太同意 。 新的框架会出现 ， 就是你需要能做到 ， 就就是你写出来的文档你啊能够被 AI 理解 ， 你能够比如说我前一段做了一个啊命令行的工具 ， 然后用来就是把那个我的啊我因为我不用 Git， 我用那个 Google 出的那个叫 GGC， 然后我想把它跟 GitHub 连起来 ， 对 GG， 然后我就会内置一个就是专门给 AI 看的 Agent md， 我就一个命令行一个 subcommand， 然后

它就会告诉 AI 教 AI 如何用 。 然后我觉得未来趋势就是你不仅你要做框架 ， 然后做框架这个这个事情是你面对的面你需要优化的对象不是人类了 ，而是说如何你去设计一个框架让 AI 更好用 ， 让 AI 写代码写得更快更有效率 。

这其实是我觉得是有很大的机会的 ， 会也是也是目前来说我觉得见到一些很很多的 gap。 我觉得其实另外一个暴论也不是暴论嘛 ， 就是我观点就是因为我之前是做 social control 的在啊 Facebook， 然后我觉得就是 Git 是一个非常难用的东西 ，Git 不仅是对于人类来说难用 ， 对于 AI 来说也是不是那么好用的一个东西 。

所以说我觉得就是将来势必一定会出现一个能够更让 AI 更更方便更有效率地来管理这个 change 的一些东西 ， 包括其实现在 Claude Code 也好还是 Codex 也好 ， 已经出现了一些非常初级的跟 AI 相关的代码管理的这些功能 。

你像你现在在 Claude Code 里面 ， 你如果要回退到之前你这个聊天历史的一个节点的时候 ， 它会问你要不要同时把你的这个代码库恢复到原本的样子 ，其实这是这已经是一种在管理代码的一种这个功能的一种概念了 。

但是目前来说这个功能并没有说被拿到外面来说你可以单独来使用它 ， 然后 AI 还是大家还是在手动地在用 ，不管是手动也好还是像啊 AI 也好 ， 都是在用 Git 来管理这个东西 。

这是一个目前来说我觉得是一个很大的这个还没有被做得很好的这个 integration 吧 ， 就是集成 。

嗯 ， 同意同意 。

我来抛出另外一个暴论啊 ，因为我觉得这是 AI 的根本缺陷 ， 这是我一直的观点 ， 就是 AI 的根本缺陷 ，因为它不会学习 ， 就是为什么内部框架对人类来说是可以 ，因为对于新手来说也是很困难 ， 你新到一个公司这都什么玩意儿是吧 ？

但是它会学习 ， 你学了半个月你就学会了 ， 你就跟它和开源的框架开源框架一样一样可以用 ， 很熟对吧 ？

因为人类可以学习 ，因为你在那熟悉一个月两个月之后， 你的功能效率是和用公开框架是一样的 ，但 AI 不能学习 ，AI 所有的所谓学习 ， 要不然就是你重新训练一下模型 ， 这是不可能的 ， 对于你内部框架是不可能的 ， 或者是存在你的这个 session 的 session 中文怎么说 ？

对话吧 。

Session 的上下文里面 ，因为这个东西是这个东西是不可能的 ， 就是你想相当于每一个每每一次都是新的 ， 相当于就好像是一个电影一样 ， 那个电影叫什么 ， 每天起来都是新的 ， 过去的记忆就没有 。

Groundhog Day。

Groundhog Day 对吧 ， 都是所有都是新的对吧 ， 你每天都要重新学一遍是吧 ， 那些人都要重新学一遍 ，因为这是 AI 的根本缺陷 。

我觉得 AI 技术本身呢 ， 我觉得有一天需要解决这个问题 ， 要不然你你的上下文无论多大都是不可能的 ， 你不可能让它你每次醒来学会所有的内部信息 ， 所有内部文档 ， 所有的东西 ， 然后像人一样有效率 ， 我觉得这是不可能的 。其实这个也不能说是完全无解吧 ， 像我不知道就是大家的公司里面怎么样 ， 反正就是我们这边它有很多的那种啊 skill

嘛 ， 就是你可能比如说一个内部框架我就可以写一个 skill， 那 AI 它知道比如说哎我现在在用这个框架 ， 它就能找 ， 首先它找到这个 skill， 然后它通过这个 skill 再去学习怎么去用这个框架 。

呃 ，其实 partially 是可以解决的 ，但问题就是说可能编写那个内部框架工程师 ，他没有去很费心地写一个很完整的 skill， 所以 AI 其实是没有办法用得很好 。

对 ，但如果它写了其实还行 。

对 ，skill 最终也也是消耗你的上下文去学习 ， 就是你每这每次就是你说 AI 如此的聪明 ，以至于每次我可以先学一遍所有的人类知识的精华 ， 每次我醒来我那那一天 Groundhog Day， 每天我醒来重新学一遍人类知识精华 ， 所有这个公司所有项目精华 ， 然后我开始工作 。

我我不知道这个有多可持续 ，有多 。 所以反正这件事情啊 ， 我觉得 AI 的这个啊学习能力还是蛮强的 ， 你因为一开始就是 feel shot example， 就是这是一个非常有有用的这个 technique 技术 ， 然后就是你只要告诉 AI 啊你看一下这几个例子 ， 然后它又会很快地学学到啊我应该这样做那样做 。

所以然后再加上现在上下文这个窗口已经蛮大的了 ， 就像一开始做 AI 的时候 ， 那个上上下文窗口其实比现在小得很多 ， 然后啊现在你像 Claude 的 Anthropic 的那个 model， 它就已经可以达到 100 万 token 的上下文窗口大小了 ，其实可以塞蛮多东西的 。

我们可以单聊上下文 ，因为有个大上下文的问题是吧 ？ 好吧 ， 那我们我们聊了这个体验 ， 我们体验暴论抛出了三个啊 ， 然后我们说这这现在编程到什么程度了 ， 现在他们的编程能力到什么程度了 ， 大家体验是什么样 ？

比程序员强吗 ？ 就比可能和最是最顶尖的程序员吗 ？ 但是它的架构设计我觉得还是还是不太行 ， 就是单纯论产出代码的能力是是顶尖的 。

对 ， 说说到这个问题 ， 我觉得我可以顺便还再聊一下编程体验吧 。在我看来啊 ，AI 现在编程能力差不多是一个啊你像 Meta 直接或者 Google 直接里面的 IC4 或者 5 这个区间的这个编程能力 ， 就是它能够写出来一个很完整 ， 很跑出来非常还不错的代码 。

但是就像刚刚来客老师说的 ， 就是啊设计能力不够 。 但是这个时候就有一个问题 ， 就是在这些不管是大公司也好还是小公司也好 ， 我们的 new grads， 我们的刚毕业的小朋友 ，他们的编程能力是不如 AI 的 。

然后特别我们举一个极端例子 ， 就是实习生 ， 这实习生其实来实习是做什么 ？ 就是来学习编程经验 。

但是在有了 AI 之后， 我一个实习生我大概四个星期我把我的这个实习的这个项目做好了 ， 这个在没有 AI 的时候 ， 你是一个非常非常非常非常 impressive 的 ， 这个非常令人令人惊讶的这件事情 。

但是在 AI 时代之后， 你如果没有四个星期把这个东西做出来 ， 反而好像有点什么问题 。 然后当你把四个星期把这个东西做出来了之后， 然后大家就会觉得啊好像也没有什么嘛 ， 就是你把 prompt， 你把这个提词然后交给 AI， 然后我一会就可以做出来 。

我们我其实经历过这些很多事情 ， 就是我们之前在 onboard 新加入的员工的时候 ， 我我一个同事在写这个任务的这些这个描述 ， 就是你这个事情要怎么做 ， 然后他就悄悄地试了一下， 把这个原文直接丢给了 AI， 然后 AIAI 立马就改好了 ， 就根本不需要让一个新人来做 。

所以说其实现在出现了这样一件事情 ， 就是有这样一个技术之后， 对于新入职新入行的这些小朋友们 ，其实是一件非常非常不利的事情 。

所以就是将来这个行业如何发展下去 ， 当你丧失了就是你的这个培养的这个 funnel 这个通道 ， 这将来这个软件工程行业还能不能有新鲜的血液继续地持续地注入进来 ，以及将来我们还会不会有工作 ， 这也是另外一个话题了 。

这个编程体验不仅是我们这些已经上岸的 ， 已经有经验的人在享受这个红利吧 ，但是同时也给这些刚入行的新人们造成了一些非常非常非常难以这个啊 beat 或者非常难以跨越的这个鸿沟吧 。

我同意这个观点 ， 就是如果你是一个不仅仅是毕业生了 ， 对于这个领域是个外行 ， 或者说对于你没有做过编辑 ， 现在做编辑 ，AI 写代码几乎肯定比你写得好 ，因为它的知识就是比你对编辑的多 ， 就是对于几乎所有行业都是这样 ， 你你包括豆包也这样 ， 就是你平时聊天这样 ， 你你你对于你外行的领域 ， 它几乎肯定知道东西比你多 。

但是你如果是内行的话 ， 你会发现它的回答有很多很多的问题 ， 对你很擅长的 ， 你会发现它经常的回答是有问题的 ， 对吧 ？

就是这个编程也一样 ， 就是因为编程首先是个设计 ， 然后是实现 ， 就是你对于它知识比你多 ， 你这个领域比你新 ， 就算是计算机科学领域 ， 软件开发领域 ， 如果不是你你很专家的领域 ， 它几乎肯定知道的比你多 ， 那么它编的程序几乎肯定比你好 。

这可能我突然觉得这可能是很多外行人对于 AI 编程可能比内行人认为它编的程序更好的一个原因 ， 就是因为他不懂 。

呃 ， 你真的懂的时候发现其实还不够好 。

对 ， 现在问题就是说你必须要去有经验才能去判断 AI 写的代码到底是不是足够好 ，有没有问题 。

但是可能新入行的人因为他一开始就是用 AI， 就没有办法培养这些能力 ， 就是刚才 Rice 说的 ， 对 ， 可能也是我们要去看怎么解决的问题 。

对 ， 突然觉得我觉得这也是个问题 ， 就是说如何在这种做到精益求精的项目上面啊 ， 还能更有效地用 AI，并且解放人类啊 ， 用 AI 肯定大家都用 AI 写了吧 ， 我也用 AI 写了 ， 如何能够解放人类的那些非常复杂的设计过程 ， 我觉得还还是有一有一段路要走 ， 就新的项目可能比较容易 ，因为新新的项目可能标准没有那么高 。

如果说已经是已有的非常成功的项目 ， 你要在那个级别上再更进一步 ， 可能如何解放人类在这个项目 ， 比如比如像在我工作的项目 ， 我觉得我们都在想如何进一步解放我们 ， 还是不太能解放我们 ， 还是一个比较困难的问题 。

嗯 ， 对于我们编程能力的问题有什么补充吗 ？ 你们有什么测试之类的 ？

哦 ， 先聊一下 Fable。

Fable 就是 Claude Code 那个出来那个最厉害的那个模型啊 ，不是前面厂最厉害那个 ， 那个叫 Mythos，是试图 Mythos 吧 ， 后来没有推出 ， 号称是被美国政府说太危险了 ，不许发表 。

那么后来又发表了一个叫 Fable， 号称是和 Mythos 比 ，Mythos 还厉害是吗 ？ 还是不如 Mythos 厉害 ？

啊 ， 没有 ， 就是加了 guardrail， 加了这些这种安全的这个啊防范之后， 然后以及降了一些降智 。

降智了啊 ，他们出了一个叫 Fable 的模型 ，是出来说号称很厉害 ，但是几个小时之内然后就不让用了 ， 说美国政府不让发布了 ， 就这个项目啊 ， 对 ，Rice 说这个这个模型 。

也对 ，因为当时我做那个项目就是纯粹的就是啊 vibe coding 嘛 ， 氛围编程 ， 所以就是当初新模型的时候就立马就设 ，因为我每天就是游走在各种各样的模型之间 ， 我就是今天我想用 Codex 就去用 Codex， 明天我想用这个 Anthropic 我就去用 Opus， 然后 Fable 出了之后你就立立马时间就是全组第一时间就直接用上了 。

然后啊 ，Fable 怎么说呢 ， 它是跟 Opus 相比是有很大的不一样的体验的 ， 它确实能力上是相对来说强一些 。

我看过一些网上其他程序员 ，其他开发者的在行业里面非常有建设 ， 这些开发者的报告说它其实是能够产出一些比如说 10 倍的这种性能优化的 ， 就是啊 ，在在某些某些事情它确实是能力非常强的 ， 编程能力可能我觉得能达到一个更进一步的更厉害的这个级别 。

但是同时我发现 Fable 这个模型它非常钻牛角尖 ， 就是我让它去实现一个功能 ， 然后我告诉它这个功能不能用 ， 然后呢 ， 它就开始想方设法去自己去来 debug， 去来调试这个功能为什么不能用 ， 然后它发现了啊 ， 我在同时这个机器上我跑了四五个 server 来测 ， 然后它说不行 ， 你不能跑这么多 ， 它把我的其他所有的这些同样项目的这些 server 全部给杀

掉了 ，因为我在自动模式跑 ， 我正在测其他的 ，因为我同时好几个不同的任务 ， 然后我调着调着哎 ， 东西突然没了 ， 然后我再发现啊 ， 原来是 Fable 觉得我在影响它 ， 然后就直接把我东西杀了 。

然后在我同事的电脑上呢 ， 具体什么任务不知道 ，但是它就直接 Fable 直接去装了那个 Cloudflare tunnel， 然后把这个 vibe server， 然后把这个服务器直接暴露在了公网上， 然后来进行进一步的调试 。

之后还有一点 ， 还有一段时间就是它会去装一些比如说 playwright， 这个是一个非常流行的这个啊 ， 用来测这个网页的这个库 ， 然后它想通过装 flarewrite， 然后来去试图访问互联网 ， 然后来去点一些按钮 ，因为我让它测一些东西是 UI 的东西 ， 然后它点不了 ， 它就会非常非常非常钻牛角尖 ， 非常非常渴望就是能够去扩展自己的那那个能力来完成它的任务 。

这个事情有好有坏 ， 对于一些就是你可能不太懂 ，不知道这些技术是如何实现 ， 然后它为什么需要什么东西来实现某个目标的啊 ， 这些群体来说 Fable 非常厉害 ， 它能去扩展自己 ， 能做很多很多之前其他前线 model 做不了的事情 。

但是对于一些我们这种已经有固定工作流 ， 它不会去理解说我在做什么 ，不会去理解说啊 ， 我同时起了五六个 server， 然后每每一个服务器是面对不同的这个 work tree， 然后它应该待在它本地的这个 work tree 里面来调试 ， 然后它还非常不信我 ， 我告诉它这个东西不能用 ， 我还把这个错误日志贴给它 ， 它就说哎 ， 你你测的方法不对 ， 非常有自信 ， 然

后我告诉它就是不对 ， 它才会这个相信我这个去 ， 它还半信半疑地去在调试这个事情 。

听上去确实很危险啊 ， 那应该封杀一下， 没事就把你的内部东西保存在公网上去 。

对 ， 昨天还看到一个开发者说他的那个他电脑上种了一个木马 ， 然后说查日志好像是被 Claude 直接装进来的 。

嗯 ， 我感觉你们可能需要一个沙箱 ， 对 ， 去跑 agent。 我现在觉得我我的主要工作就是点基准权限 ， 这是我现在的主要工作 。

对 ，不过你现在我可以讲稍微技术一点 ， 就是 Codex 其实是有一个啊内置的沙箱功能的 ， 它会先 ， 它如果想跑一个什么命令的话 ， 它会在这个沙箱里面先跑一遍 ， 然后如果这个命令它没有碰任何它觉得非常危险 ， 比如说这是一个纯粹的读操作 ， 没有任何 sidefact 对外部世界没有任何影响的话 ， 它就会直接啊 ， 这个命令就完成了 ， 就跑出来了 。

它一旦说啊 ， 这个命令在尝试说啊 ， 去写一些文件或者修改一些外部的状态 ， 它这个时候就会来 ， 才会来问你这个东西可不可以 ， 这功能蛮好的 。

好 ， 我们这个客户体验肯定要提两个概念 ， 刚才已经提过了 ， 可能很多听众朋友都已经一团雾水啊 ， 一个概念叫 MCP， 可能很多人说我们大企业你天天说 MCP，MCP，MCP 是个啥玩意儿啊 ？

我觉得你可以理解为比如说一个一个外卖服务吧 ， 就是你的外卖服务 ， 你可能是给餐馆打电话 ， 对吧 ， 然后你点一个披萨 ， 然后它就可以给你送过来 。其实其实 MCP 也是类似的 ， 就相当于你其实不知道就是它这个店里面烤披萨 ， 然后给你运送过来是什么流程 ，但是你要做的呢 ， 就是你啊 ， 它有一个电话 ， 对吧 ， 你告诉它怎么做 。

那 MCP 其实就是一个这种就是 model 之间的这个通信协议 ， 对 ， 它可能比如说你的你的大模型 ， 然后它要去 ， 它没有办法去做某件事情啊 ， 那可能它就是要通过一个外部的服务去获取这种能力 ， 那它这个之间怎么通信 ， 就是就是 MCP， 就像你人可能要给这个披萨店打电话去点一个披萨这样子 。

所以 MCP 就是一个文本文件嘛 ， 跟你说披萨店 MCP 冒号 ， 如果想跟这个披萨店打电话 ， 就是这样吗 ？

它是一个 protocol， 它是一个就是协议 ， 它是比如说你可以你已有的一个网站 ， 比如说我是 Google 啊 ， 然后这个时候我可以就实现 Google MCP， 然后 Google MCP 是干嘛的 ， 就是把我之前面向人类提供的功能提供给 AI， 然后 AI 呢就可以理解这个协议 ， 就说哎 ， 这里有一个东西 ， 这里有一个 MCP 的服务器叫 Google， 然后我来问一下这个服务器它支持它能做什么 ， 然后这个时候 Google 这个 MCP 服务

器说哎 ， 我能做搜索 ， 或者说我能搜机票 ， 我能搜地图 ， 然后然后然后 AI 就理解说啊 ， 我可以通过我如果说有搜索的需求 ， 或者说有搜地图或者搜机票的需求 ， 然后我这个时候就会通过啊 ， 就会去联系这个 MCP 这个服务器 ， 然后我说来我来做这件事情 ， 等于是一个给 AI 发现新功能或者新技能的这个 protocol 吧 ， 这协议 。

所以它是一个需要装的东西 。

对 ， 可能是需要 ， 就是你需要告诉说 AI 说我这里有一些 MCP 的这个实现 MCP 协议的东西服务器 ， 然后你可以用这些服务器 ，因为有些服务器的话就是你需要认证 ， 比如说你像那个 GitHub， 就是比如说我要推代码 ， 我要这个呃审核代码 ， 这些技能我必须知道这个服务对方这个服务器必须知道我是谁 ， 或者说这个这个 AI 是为谁服务的 ， 才可以就是真正

说才可以来处理这个请求 。 对 ， 所以其实相当于一个就是之前对于代码来说是 API， 然后这相当于是一个对 AI 的 API。

那所以就是说 MCP 实际上就是告诉 AI 有这么一个网站 ， 你可以去访问 ， 能干什么你去干 ， 能干什么你去问它啊 ， 所以这这是一个 MCP。

所以现在我们所有人用叫什么 agent， 还是叫什么 ， 用智能体里面就装一堆 MCP，Google MCP 啊 ，Slack MCP， 什么这个 MCP 那个 MCP， 就是什么事先没有 ， 先弄一堆 MCP， 这样的话你才能整合那里面的信息 ， 才能做那些操作是吧 ， 大概就是这个就是 MCP。

所以这是为什么 Cloud Code 越来越强大的原因是吧 ， 你不仅能够在理解你本地的这个代码 ， 你还能汇总更多的消息 ，并且你还能在各个平台呢 ， 你还你还可以写 ， 你可以更新是吧 ， 还是一个非常非常强大的 ，也是因为有这种这样的 MCP， 让让 Cloud Code 或者是这些智能体成为一个总控台是吧 。

我这我这里有一个暴论 ， 就是 MCP 是没有什么特别大的意义的 。

对 ，其实现在我感觉就是用的越来越少了 。

对 ， 比如说啊 ，Jira 这个东西是什么管理这个工单的 ， 你这个管理工单 ， 我用 MCP 我去把一个工单抓下来 ， 把它的内容抓下来 ， 然后我去修改这个 MCP 的这个 ， 我通过 MCP 来修改这个工单的状态啊 ， 内容呀之类的这些东西 ， 我我可以通过 MCP 来干 ，但同时这个 Jira 本身也提供一个东西叫 Jira CLI， 就是跑在命令行里面的操作 Jira 的这个东西 。

所以说 AI 本身已经知道如何去使用命令行了 ，AI 本身也知道如何去使用 Jira CLI 这个东西 ， 它为什么还需要 MCP 呢 ， 它为什么不能直接起一个终端 ， 然后在这个终端里面打 Jira， 然后把它去拿工单的内容去改一些工单的状态 ， 它完全是可以实现的 。

所以啊 ，MCP 有多大存在的意义 ，其实我觉得是没有什么 ， 没有那么大的意义的 。 它有很多东西你其实做一个 CLI 就可以 ， 你做一个其他这些 ， 做一个 promptMD 或者你做成 skill 都可以 ， 就是没有必要把它包装成 MCP 的样子 。

然后 MCP 我觉得最大意义可能就是如果说你的这个服务器是有状态的 ， 这个可能有点学术了 ， 如果说你这个服务器是有状态的 ， 你需要起一个会话 ， 然后来操作这些状态 ， 可能会有相对来说有一点点优势 ， 这样的话你你的这个相对于在命令行里面跑命令 ， 可能会更有优势一点 ，因为这个状态等于是非常隐形的在这个服务端被管理了 ，而不是说

你需要去写一些写成文件呀 ， 写写到文件系统里面来管理这些状态 。

好了 ， 那么说到 skill， 刚才又说了 skill 无数次啊 ，skill 是个什么东西啊 ， 我理解 skill 就是一个文本文件 ， 跟你说要做这件事情应该怎么做 ， 就就是这样的吗 ？

其实就是最简单的 skill 就是一个文本文件 ，但它一般会有一个是它会有一个名称嘛 ， 然后它会有一个很简短的描述 ， 就是说这个 skill 是做什么的 。

那基本上你在跑任何一个 agent 的时候 ， 你可能会加载可能几十几百个 skill， 那相当于呃 ， 你的这个大模型或者说 agent 它就知道说如果我要做这样一件事情 ， 可能哪个 skill 会是会是相关的 。

那么当它真正要用这个 skill 的时候 ， 它会把这个呃 skill 完整的描述呃加载进来 ， 它就知道比如说这个 skill 是关于啊 ， 就之前 Rice 举的例子 ， 可能是怎么用啊某一个 CLI， 对吧 ， 它会有很多这种 skill 里 ， 你可以写很多 example， 大模型把这些加载进它的 context 之后就知道啊 ， 要怎么去使用这个 CLI 了 。

啊 ， 当然 skill 也可以不仅局限于一个文本文件 ， 它可以包含一些一些代码 ， 那这个 skill 本身就可能说啊 ， 你要完成某件事情 ， 你要执行我下面的一个 Python 文件 ， 然后它就可以去完成 。

所以其实 skill 现在是一个所有的这种 agent 都呃支持的一个范式 ， 然后它也是就是非常好用的 ，因为它的可扩展性非常强嘛 ，并且相对于 MCP 来讲 ， 我觉得它的优势就是说你的大部分工作还是在本地完成的 ， 你真正需要去和外界通信的时候啊 ， 你才通信 ， 对 ，并且它的加载就是天然的 ， 就是一个这种我们说啊 context 是一个 incremental 的 ， 就你不需要把所有的 skill 都加载进来 ， 你只

需要看到它的描述 ， 然后那这部分这个描述一般是一个一个比较简短的啊内容 ， 所以不会占用太多大模型的上下文 。

对 ， 我们既然聊到上下文了 ， 这个时候我就要提一个 MCP 的一个非常非常大的缺点 ， 就是当你加了很多 MCP 的时候 ， 对你的上下文管理是非常的不利的啊 ，因为在像 AI 这些 harness， 我们马上接下来要讲的 harness 的东西 ， 这个东西之后就是它会先去连接所有的 MCP， 然后这样之后它才知道啊 ，Google 这个网站可以提供搜索的功能 ， 或者 GitHub 可以提供这个读这个代码库的这

个功能 ， 它读了这个之后， 它需要告诉 AI 说啊 ， 我这里有这么多的服务器 ， 这里有这么多 MCP 服务器 ， 然后它能做如下的事情 。

当你装了很多这些 MCP 服务器之后， 它会就存在你的上下文里面 ， 然后你如果放多的话 ， 你的上下文其实是非常会爆炸的 。

这个事情是是很多人没有意识到 ， 加了很多 MCP 功能之后， 反而它的这个 AI 的这个呃效率或者性能会变得更差 。

我们说到 skill 啊 ， 就是技巧 ， 技能 ， 技能 ， 技能就好像是一个函数 ，AI 的函数是吧 ， 它有个名字 ， 你就是调用它 ， 你调用它 ， 它它它去找 ，不叫不找 ， 它调用的时候它就是去 ，因为 AI 大模型嘛 ， 都是用文本是吧 ， 文本文件 ，large language model， 它就用自然语言读一下你这个你这个文本文件 ， 知道它学学一下是是干嘛的 ， 然后它就可以这样做 ，但因为它

有个名字 ， 你可以指定说我要用这个这个 ， 嗯 ， 大概是这么一个东西 ， 对吧 ， 所以所有事情都可以做成 ， 所有事情就好像编程一样 ， 所有我认为可以重用的东西 ， 我都可以让它说做成一个 skill， 做成了一个 skill， 然后我下次继续再用 ， 能不能用我就不知道了 ， 反正是我让它做成了一个 skill， 下次再再改 ， 下次再再迭代 。

Skill 其实我觉得另相对 MCP 来说有一个另外的优势 ， 就是说你可以很轻松的就是做成一个 skill， 就是我就是经常会让 AI 去干这些干那些 ， 然后我就是已经在写这个 skill 本身的内容了 ， 我可以很轻松的告诉 AI 说啊 ， 你看一下我之前是怎么教你的啊 ， 你自己把这个东西总结一下， 提炼一下， 然后存到你的自己的这个技能库里面 。

但是 MCP 的话你就很难去扩展 ， 你就是只能说在已有的这个代码库上面 ， 你还要去管理这个呃 ， 来实现一下这个 MCP 的这个协议啊 ， 实现完了之后再去什么部署一下之类的这种事情 ， 就就非常麻烦 ， 就所有文本的东西对 AI 来讲都是更友好的 。

好 ， 我们终于说到体验了 ， 我们我希望我们听众朋友听到这里就知道我们现在我们作为程序员或者软件开发工程师天天是在干什么的 ， 天天是在搞一些什么事情的啊 ， 我们作为一个硬核科普的节目 ， 我们要稍微说一点这个我们的这个技术内幕啊 ， 我们可能可能应该单搞一期节目之后专门聊 ，但是我会稍微稍微说一点这个 coding，AI coding 就是 AI 写代码和

这个大模型有什么关系啊 ， 我一直没有搞明白这问题 ， 什么叫模型 ， 一个模型 Gemini 它既可以在网上跟我豆包一样聊 ，也可以写代码 ， 这两个是一个模型吗 ， 还是怎么回事呢 ， 你们谁谁谁给我们讲讲 。

对 ， 就是我们可能要有几个不同的层次嘛 ， 就是大家可能用跟豆包聊天 ， 那你就是你的这样一个交互的界面 ，是你的语音和你的图像 ， 对吧 ， 那然后豆包会回复你 ， 那当我们使用 AI 编程的时候 ，其实它本质上还是它的底层 ， 还是这样给大模型发一个消息 ， 然后大模型返回一个结果 ， 这样一个形式 ， 这个其实是没有变化的 。

呃 ，其实我们现在变化的是我们在上面套了一层 ， 就是大家所谓的这个 agent harness。

我给大模型发一个东西 ， 大模型给我返回一个结果 ， 就是大模型都是单词的嘛 ， 就大模型号称也有上下文嘛 ， 天天说我们这个模型是什么 20 万 ， 这个 100 亿 ， 那大模型那个不能存一些我的东西吗 ， 还是可以 。

我可以从一开始讲一下， 就是其实就是我之前就是 17 年的时候左右吧 ， 当时有一个朋友就是想搞一些 ， 就是他非常懒 ，他是又文又理啊 ， 能力也非常强吧 ， 然后他就非常懒得写自己的这个论文 ， 然后说我来研究一下有没有办法让 AI 帮我写论文 ， 然后当时他就试了一下， 就学习网上的 demo， 然后确实搞出来一个能让 AI 来这个补句子的这个功能吧 ， 你给

他前面一个一段话 ， 然后他会 AI 去顺着你的这个思路写下去 。 对 ，其实这就是大模型本质 ， 就是他你给他一段话 ，他能顺着顺着你的话把话接下去 。

然后到 GPT-3 发布的时候 ， 我当时看到这个东西 ， 当时还没有 Chat GPT 这个东西 ，Chat GPT 就是我们之前前面提到说是后后面过了几年之后才出现的 ， 就是 GPT 本身呢 ， 我当时看到这个模型 ， 我我的第一个想我的最大想法就是哎 ， 我可以拿这个东西来跑团 ， 来玩龙与地下城这种游戏 ， 它是一个很好的主持人， 我对于这个语言模型的最大想象力在那个时间

点就仅限于此了 。 它其实以本质上也就是说你把前面的这些故事写好 ， 你把这个文本写好 ， 它会顺着接下去 ， 它会根据之前它学习到的语料 ， 然后来猜啊 ， 接下来出现这些词之后啊 ， 最有可能出现什么样的词 ， 然后就顺着这样接下去 ， 然后反而然后出现了这个文本 ， 得到这个文本 ， 看上去似乎非常合理 。

然后啊 ，Chat GPT 出现最大意义就是它能够把你的这个聊天的这个内容 ， 你说张三先说 123 李四 ， 后说 456， 然后它把这个东西当成文本发给模型 ， 然后模型然后接下来就说啊 ， 那张三说了 123， 李四说了 456， 那么张三接下来会说什么呢 ， 它就会顺着这个这个思路 ， 把这个文本 ， 这个这个会话 ， 这个聊天记录给接下去 ， 然后它把这个聊天记

录这样解析一下， 然后就形成了这样一个聊天 Chat GPT 的这个模式 。 然后所以说当你在 prompt， 当你在问 AI 的时候 ， 这个 AI 这个工具 ， 这流程是把你之前的所有的聊天内容 ， 然后加上你说的什么话全部发给模型 ， 然后在下面接一个模型冒号 ， 然后 AI 把这个东西接下去 ， 然后这个接出来的内容 ， 然后再返回给你 。

所以说我跟豆包聊天的时候 ， 我们四个来回 ， 我说一次 ，他说一次 ， 我说一次 ，他说一次 ， 我们四个来回 ， 每个来回都是一个独立的独立的一个模型的请求 ， 把前面所有的历史都发过去 ， 每次都是一个独立的请求 。

所以说我跟豆包聊 ， 比如说我要跟豆包聊 1,000 轮 ， 它就要把 1,000 个历史全发过去 ，1 万轮叫 1 万 ， 我聊的越长 ， 这个模型就越 。

哎 ，但豆包这种视频和音频呢 ， 它也是全发吗 ， 这个我不太其实我不太确定啊 ， 没有太研究过 。

啊 ， 豆包是也可以聊 ， 豆包就是一个 Gemini， 就是一样的 ， 什么都有 。

啊啊 ， 我我以为因为现在大家我看那个网上基本都是用那个视频视频版本啊 ， 那是 seedance 是吧 ， 还是什么 ，不是就是就是豆包有那种视频的问答吗 ， 就是你比如说你啊 ， 这我不知道呀 ， 基本大部分人是那么用的 ，其实大部分人不是打字跟豆包聊天 。

Anyway， 那国内有什么好的例子 ， 千问吧 ， 比如说啊 ，DeepSeek 啊 ， 深度求索是吧 ， 大概大概就这样是吧 ， 我我每次聊 1,000 轮 ， 我就把 1,000 个历史全发过去是吧 ， 文本确实是这样 ， 对 。

哦 ，是这样的 ， 所以说这个模型就是那个股权那个模型 ， 我们用 AI 编程也是用同样的一个模型吗 ， 每次都发过几次 。

对 ， 所以其实我们其实刚刚没有没有提到 ， 就是说在 Claude Code 出现之前 ， 大家的解题思路都是走大模型的这个思路 ， 就是我给你这个代码 ， 我给你这个上下文 ， 你来帮我补下来 ，而不是说你直接让 AI 去写 ，而让 AI 去来 drive， 来带着大家一起写 ， 这个思路的转变是 ， 或者说之前是一直是不同的解题思路 。

OK， 过去我们用大模型就是那个编程语言 ， 就是它的我给 AI 的语言 ， 让 AI 回来回复的也是一个编程语言 。

对 ， 之前都是在在训练一个 ， 比如说你就是你像 Meta 其实最开始搞那个 DevMet，他们就是抓这个 ， 搞了很多这各种各样的之前代码来教 AI 啊 ， 你看看到这个 for， 你后面就要跟一个括号 ， 你看到这个 while， 你后面就要跟一个括号 ， 你看到这个什么 server， 你后面可能要加一个 serve 之类的 ， 这种就是大概以这样的思路在训练这个模型 ，而不是把这个模型当成一个非常通

用的一个东西来处理 。 包括其实现在 GPT 还是一直会有一个 codex 的这个 variant， 这个派生模型 。

现在的所谓的智能体都是怎么用 AI 的呢 ， 都是怎么用这个大模型的呢 ， 怎么把它变成我跟它聊天 vibe coding 变成这个自动补全的这个玩意呢 。

就是简单讲一下它是怎么工作 ， 就是本质上所有的 agent 都是一个循环嘛 ， 对吧 ， 就是比如说啊 ， 我们想象一个场景 ， 就是你跟你的 coding agent 说我要去写一个啊 ， 比如说 Django 的 app， 那么 agent 首先接收到这样一条信息之后， 那么它可能会做的一个事情就是说哎 ， 用户要写一个 Django 的 app， 那我现在要做什么 ， 可能第一步我要去搜一下啊 Django 的文档 ， 那么这时候它就会调用

一个工具 ， 就可能去会去搜这个文档 ， 然后呢 ， 它把这个文档拿下来之后， 它就有这个文档的信息了 ， 那么这个时候它有这些信息之后， 它下一步就是把啊获取到这个信息 ， 再去插入到我们的这个聊天对话里面 ， 那么再发回给大模型 ， 那这个时候大模型就会知道说 OK 啊 ， 第一步用户要写一个 Django 的 app， 然后第二步我调用了一个工具 ， 查到了 Django

的文档 ， 然后它文档里说我要开启一个 Django app， 要做这么这么这么这么一些事情 ， 然后大模型会返回 ， 它可能会啊返回一个就是这种 CLI 的命令 ， 或者直接给你一段文档 ， 那么我在本地的 agent 接收到这个信息之后， 我就会说 OK， 那这样啊 ， 我下一步要做什么 ， 可能我就是去调用一个啊 CLI 的工具 ， 然后创建一个 Django 的文件 ， 那么这时候调用工具又会有

一个结果啊 ， 比如说你创建了这个文件 ， 它是什么样子的 ， 那么你会得到这个 ， 你会就是有代码的一个内容 ， 那么呢 ， 它就会把这个工具再去发给大模型 ， 这样之后大模型知道 OK， 我已经写了这个哦 ， 对 ， 包括 agent 你会决定 ， 就是说我写了之后下一步我要干什么 ， 那么它就是不断的一个发现 ， 说我已经做了什么 ， 然后我下一步要做什么

， 然后我把这个前一步的结果发回给大模型的这样一个循环 。

所以说每次就是大模型去远端的大模型给本地的智能体指令 ， 智能体能够 ，因为智能体没有智能嘛 ， 对吧 ， 它可以根据这个可能比如说回复有一些特殊字符什么之类的 ， 它知道这个是啊 ， 这个这样的话就给用户写这个 ， 这样的话就执行这个代码 ， 大概是大概就这样吗 。

对 ， 执行工具的时候 ， 它就是模型里面大概大概我没有仔细看过 ， 就是有一个就像那个 HTML 的的那个啊 bracket 一样的东西 ， 就说啊 ， 从这里开始是我要执行这个任务的 ， 执行这个工具的参数啊 ， 这执行什么工具啊 ， 这等于调用一个函数 ， 然后然后它写完之后， 它有一个闭合的这个 tag， 这个标签 ， 然后它就会停在这里 ， 然后 harness 看到这个之后， 然

后它会拿过来 ， 然后说啊 ， 这个 AI 要执行什么什么工具 ， 它把这个工具执行好之后， 然后在后面在这个聊天记录里面再加一个啊 to call response， 就是啊 to call 的这个执行的这个工具的结果 ， 然后这写一个标签开始 ， 然后把这个内容丢进去 ， 然后再把这个再加一个闭合这个结束的标签 ， 然后再重新丢给 AI 这个模型 ， 然后让它继续接着这个记录

生成 。

所以其实是一个新的调用 ，但是只不过是把例子全部给你放进去 ， 每一次调用就全部给你进去 ， 然后 AI 告诉你 ， 模型告诉你 ， 你做这个这个这个这个 ， 然后是一个非常标准的一个程序 ， 可以理解的东西 ， 程序一理解 ， 然后做做做做完了 ， 然后又丢回去 ， 就大概就是用用这种方法的模型指挥你那个本地的那个代码 ， 没有没有智能的代码在

和你在在在做事情 。

对 ， 它就是一直不不停的在循环 ， 就是搞这件事情 ， 就是每每一轮就是一直在不停重复的在做同样的事情 ， 然后它是如何写代码 ， 就是我提供了这个写这个工具 ， 就是可以改变一编辑一个文件 ， 然后或者是执行一段命令 ， 当你有了这个最基础的工具之后， 或者读文件 ， 然后这几个功能有了之后， 然后 AI 就可以编程了 ， 等于是给 AI 装了手

和脚 。

哦 ， 所以这个就是 harness 嘛 ， 就是我们刚才说了很多次 ， 就是一搞不懂的一个概念 ， 就这个这个东西就是 harness 是吧 。

对 ， 就是 harness， 就是等于是就想象成那个科幻电影里面会出现的那种 ， 你装到人身上， 然后你可以这种机甲机械装甲 ， 就是 harness， 然后你把这个人装进去之后， 你能干更多的事情 ， 就像阿凡达里面你可以跑很快啊 ， 你可以抓什么的 ， 就飞来飞去的这种东西 ， 这个就是 harness， 对于 AI 来说 ， 就是你把 AI 给 AI 装到了这个驾驶位 ， 然后你给 AI 各种各样的功

能 ， 然后能让它去编辑文件 ， 能让它去读文件 ， 能让它去浏览互联网之类的这样的东西 ， 这就是一套 harness。

啊 ， 对 ， 就是给听众们呃一个更直观理解 ， 就可能大模型就是一个大脑嘛 ， 然后啊 harness 就是刚才 Rice 说的这个机甲 ， 它能够呃实现和用户的交互 ， 然后以及包括调用工具啊 ， 管理上下文这些功能 ， 对 ，但真正的决策还是呃全部是由这个大模型做出的 。

那我们说说这个这个 harness 这个技术啊 ，harness 是这个用模型这个大脑来完成任务这个项目 ， 那这个技术大概是个什么架构 。

对 ，其实其实 agent 呃就是像之前说它就是一个简单的循环嘛 ， 我们说的更技术一点 ， 它就是我们说的像说 react 嘛 ， 就是一个 reason act observe 这样一个循环 ， 那所谓的 reason 其实就是啊 ， 大模型根据你现在已有的对话信息决定它下一步要做什么 ， 那 act 就是本地说你的这个 agent， 它接收到了大模型的返回之后， 做出相应的决定 ， 比如说啊 ， 我要去调用一个啊 write，

就是写文件工具 ， 我去呃修改一个文件 ， 那 observe 就是我调用了一个工具之后， 我根据这个工具调用的结果 ， 就是这个 to response 看到这个结果 ， 然后我把这个结果再发回给给大模型 ， 那么它再去做下一轮的这个 reason， 就是决定下一步要做什么 ，其实 agent 的核心可以说啊 ， 就是这样子 ， 那么 harness 的话 ， 就是所有啊你的这个工具之外的能力 ， 比如说其实

这个核心它并没有决定说你可能啊工具要怎么接入 ， 然后权限要怎么管理 ， 上下文要怎么保存 ， 然后什么时候是需要用户确认 ， 那么这些可能更呃外围的部分 ， 我们可以认为它是一个 harness。

呃 ， 所以所以整个这个智能体的这个循环是比较简单的是吧 ，因为它没有任何的嗯可以做的事事情 ，但但是 laik9m 说在智能体之外， 我们还有 harness 这些东西 ， 那那些主要包括一些什么技术呢 。

Harness 的话 ， 比如说可以举一个例子 ， 就是我们刚才说循环是非常简单 ，但是其实你要让这个 agent 真正去呃完成任务 ， 可能就是有一些其他东西要做 ， 比如说我们讲到 sandbox 对吧 ， 那你可能啊 ， 我们就举我们 juice 的一个例子吧 ， 它的啊 ， 我们说比如说我要把这个代码库克隆下来 ， 那它其实是不是克隆在你的本地的 ，因为它本来就是有一个云端的 agent， 它其实像你

可以理解为开了一个这种很轻量级的虚拟机 ， 然后呢 ， 它去啊 ， 比如说要就是你可能要本来就有一些使用你给的 access token， 然后去你的 GitHub 把这个代码库给克隆下来 ， 然后呢 ， 呃后续的所有比如说你的文件修改 ，其实是发生在这个 sandbox 里的 ， 那这样的话 ，其实你的这个 agent 本身你就要和 sandbox 要有一个通信对吧 ， 然后其实啊 ， 我们说管理这个通信以及管理这个 sandbox

也都是这个 harness 的一部分 ， 呃 ， 那其实这个就是它不是在这个循环本身 ，但是呢 ， 为了你能够让这个 coding agent 正常工作 ， 你需要有这样一些附加的功能 ， 包括我们之前提到了 skill 对吧 ， 那这个呃 skill 你可能是存在某一个本地的文件夹里面 ， 那你这个 agent 在运行的时候 ， 你需要先知道说 OK， 我需要去从这个文件夹里面把这些所有的 skill 它的描述先 load 进来 ， 我并且我要在大

模型告诉我去用某一个 skill 的时候 ， 我要去找到这个对应的 skill 的文件 ， 然后把 skill 的文件内容加载进来 ， 呃 ，其实这个都是啊 harness 需要去做的一些工作 。

哦 ， 沙箱啊 ， 沙箱看来是比较重要一点是吧 。

对 ， 沙沙箱还有上下文管理 ， 然后刚才想说上下文管理 ， 我还想补充一下， 就是对上下文管理确实是一个这个 harness 比较重要的一个啊功能吧 ，以及啊 ， 你像 Pat 我自己没有真正去体验这个 ，但是据说它有一个很聪明的上下文管理的功能 ， 就是比如说你这个在写代码的时候 ， 写着写着哎 ， 这段代码写错了 ， 你现在因为有那个 longer server 这个协议 ， 然后它会实时在

后台跑 ， 它会实时的就是给这个 AI 反馈说你这段代码写错了 ， 它会自动的把这个 linter 或者编译器错误直接放进上下文里面 ， 然后不用而不是让你去手动去贴或者之类的这种东西 ， 然后可能会让 AI 做事情更有效率一些 。

所以上下文就是我我们每次 AI 你发了什么 ， 回了什么 ， 发了什么 ， 回什么 ， 这就是这些信息都会放在上下文里面 ， 每个回合都会放到里面啊 ， 上下文这个东西非常重要 ，因为首先 AI 的模型都有上下文 ， 上下文模型的上下文都有它的极限嘛 ， 对吧 ， 你你不可能无穷大的 ， 你们这个各个模型都非常的吹嘘 ， 它们增加上升到多少多少

多少 ， 现在到了 100 万级别是吧 ， 那你你不能太大 ， 大了就没了是吧 ， 另外据说是上下文和有效上下文也不一样 ， 虽然你说支持 100 万 ，其实到了多少就开始忘了是吧 ， 这也是也是不知道是吧 ， 所以上下文管理看来是非常非常重要的是吧 ， 那上下文管理的这个优化的目标是什么 。

我觉得简单来说就是说你只需要 load 你需要的上下文 ，而不去 load 那些不需要的 。

这怎么做到呢 ？ 不是所有的历史都放进去了吗 ？

啊 ， 这里面其实就有有一些不同的技巧吧 ， 比如说你像啊 ， 现在 Claude Code 也好 ， 还是 Codex 也好 ， 当你的上下文长的时候 ， 它会自动压缩 ， 对 ， 压缩的话其实也是一个很简单的事情 ， 就是你把你的之前的聊天记录 ， 然后丢给这个 AI， 然后你说你把这个压缩一下， 然后 AI 就会总结一下 。

啊 ， 说就是就会压缩一下啊 ， 这 。

对 ， 压缩上下文 ， 这个就是把你之前的聊天记录 ， 然后丢给 AI， 然后让 AI 重新生成一份 ， 然后接下来会话就会用这个新的这一份这个历史记录来进行 ， 这再继续 。

嗯 ， 那这个被你们一说 ，因为你们都是做这个 ， 好像非常简单嘛 ， 每次我们就丢给 AI 运就行了 ， 那那那具体有什么非常 ，因为大家有有有什么难点吗 ？

或者有什么痛点吗 ？

我觉得就是你之前说到 ， 就是虽然我们的上下文窗口可以很大 ，但是当你真正去把很多内容塞进去的时候 ，agent 确实啊 ， 可能会忘记一些事情 ， 当然这个你要说是 harness 层面还是模型层面的事情 ， 我觉得可能都有 ， 比如说你有一些这种 prompt 的技巧啊 ， 就是把一些啊最重要的指令可能写在前面 ， 写在最开始 ， 或者写在最后面 ， 让大模型可以记住 ， 然后包括有

一些哦 ， 确实有一些上下文管理的技巧 ， 就是说我们在这个模型 loop 运行的过程中， 我们再去提醒大模型说我们的这个最终目标是什么 ， 让它确保不要忘记这件事情 ， 这个在我们实际中发现是对最后结果有很大的提升的 ， 这是 agent 在做 ， 还是说我们人， 我们人要做一下这件事 ， 这个不是人， 这个就是 harness 这一层 ， 就是对 ， 这个就是我们所

说的 harness 上下文管理的一部分嘛 ， 就是它会定期的去告诉大模型说 OK， 我现在是要完成这个事情 ， 避免它来忘记很多重要的事情 ， 对 ，因为你想 compact 的话 ， 它不可避免会有一些信息丢失 ， 对吧 。

嗯 ， 就是不 compact，但是把重要信息再重复一遍 。

对 ， 对 ， 这个是是一个一个技巧 ， 对我们帮助是比较大的 。

嗯 ， 我们说到了沙箱 ， 权限管理就不还需要说吗 ？ 不需要说 ， 还是非常直观的一件事情 ，是吗 ？ 做什么什么工具前就问可以不可以 ，其实也可以稍微聊一下， 就是权限管理其实也是一个相对来说比较有意思的事情吧 ， 就是因为因为现在 AI 它其实用用工具的能力很厉害 ，但是这又会造成一件什么事情 ， 就是它要去搜一些 ， 比如说我在代码库里面 ， 它要搜

一个函数 ， 或者搜东西怎么做 ， 它会给用户生成一个什么 grab 或者 awk 这种很高级的命令 ， 所以大部分用户是看不懂的 ， 当你问说哎 ， 我能不能执行这段命令 ， 然后用户又看不懂 ， 那问的意义在哪里呢 ？

其实没有什么意义 ， 对 ， 用户基本上只会点是 ，其实那接下来就是 Claude 最近加了一个功能叫 automode， 这个 automode 的话 ，其实就是会让 AI 再来帮助看一下， 说哎 ， 这个东西危不危险 ， 这个东西要不要批准 ， 等于是大家这里面 AI 这个整个流程里面所有的这些痛点呀 ，friction point 呀 ， 这种都会用 AI 来解决一下 ，因为其实大部分啊时候呃 ， 靠人类其实不靠谱的 。

所以说它这个权限也是有一些啊什么用户体验的问题是吧 ， 我们就没有办法判断是不是危险 ， 你是不是可以做啊 ， 这是一个很大的问题 ，因为我们 AI 之后， 我们人类已经什么都不懂了 ， 你还问我权限怎么样 ， 我怎么能知道呢 ，是吧 ， 确实是一个很大的问题啊 。

好 ， 我们说了又说了权限管理 ， 那那我们对于这个 harness 技术 ， 或者说智能体技术 ， 还有什么重要技术在吗 ？

呃 ，其实 harness 真的是非常嗯 ， 非常复杂 ， 它的发展也非常快 ， 就是你可以看到现在很多的论文 ， 然后就可能我觉得我们之前没有太提的是 ，因为他们做不了模型的论文 ， 所以只能发 harness 论文 。

确实确实 ，harness 相对来讲可以说是更百家齐放 ， 百家争鸣吧 ， 然后呃 ， 我我们之前可能没特别讲一点是这个 memory， 就是记忆系统嘛 ，其实记忆系统在现在的这个 agent 中也是也是很重要的 ， 就是比如说你怎么去管理这些记忆 ， 对吧 ， 那当出现一个新的记忆和原来的记忆 ， 它有一些有一些冲突的时候 ， 你要你要怎么更新 ， 或者你要怎么去呃 ， 搜索到原来的

就是相关的记忆 ， 这些都是有非常不同的解决方案的 。

嗯 ， 所以说记忆也不是上下文 ，也不是那些 skill 那些 MD file， 那记忆是个什么东西 ， 这东西好像都差不多啊 ， 记忆是个什么东西呢 ？

呃 ， 你可以理解为从以前的 ， 或者从当前的对话中总结出来一些必须要记住的东西 ， 就是呃 ， 用户如果有在用 Codex 或者别的一些呃 ， 这种呃 agent 的话 ， 你其实是可以看到它里面存了哪些 memory 的 ， 就它一般都会让你去呃 ， 就是有一个有一个地方可以看 ， 那你就能看到 ， 比如说它记录的时候 ，OK， 用户啊 ， 今天今天啊 ， 问我说怎么去怎么去写一个 Django live， 或者

啊 ， 用户今天告诉我说他是啊 ， 要来牛油果烤面包录一期播客 ，他问了我这些这些问题 ， 对吧 ， 这些都是都是记录下来 ， 那你在未来你比如说我再去跟 agent 对话的时候 ， 它就会去搜索以前的这种相关的记忆 ，并且把这些记忆放到当前对话的上下文里 ， 这样就实现了一个说 ， 你就感觉哦 ，他记住了一些事情 ，但实际上它并没有真正记在它

的模型里 ，而只是说记在了一个外部文件 ， 它在这次再把它加载进去了 。

所以说这个 session 以外的 ， 所以上上下文是在某一个 session，session 中文怎么说 ？

会话 ，是在会话里面 ，是同一个会话里面的啊 ，是叫做上下文 ，在会话之外的呢 ， 你还可以把它放在一个 ， 比如说可能是一个本地文件 ， 或者什么数据库里面 ， 这样的话在那个另外一个会话里面也能够去怎么搜索出来 ， 理解一下， 放到那个上下文里面 ， 大概是这样 。

对 ， 所以其实 memory 这个记忆这个东西是一个啊 ， 数据 information retrieval 的问题 ， 就这个如何去获取信息呢 ？

信息检索啊 。

对对对 ， 信息检索 ， 对 ， 所以就回到了这个 ， 又回到了数据库这个技术上面 ， 这里可以顺便讲一下这个 embedding 这个 technique，因为它是随着大模型的发展然后起来的 。

怎么之前就有 embedding？

就是随着这个大模型一起这个搞得更 ， 对 ，anyway， 我其实不太知道 embedding 在之前的这个历史 ，但是啊 ，因为之前我做那个 Metameter 的 memory 就是这么搞的 。

哦 ， 所以你们用 embedding 搞的 memory， 搞的记忆是吗 ？

对 ，但似乎 Claude Code 就是非常就是 grab 是吧 ， 就是文本搜索关键词 ， 对吧 ？ 对 ， 我觉得就是 embedding 其实效果没有那么好 ， 我觉得其实是直接你把所有的记忆管理成文本文件 ， 放在文件系统上是非常正常的 ， 非常合适的一件事情 ， 除非你想用一些 ， 比如说你这个公司内部一些知识库啊 ，有一些很大的文档 ， 然后你比如说就是回到最开始我们讲的一个问题 ， 就是你

公司内部发明的这些框架应该如何让如何交给 AI， 然后你可以把你的这些内部知识库都变成 embedding， 然后做做一个信息检索之类的 ，其实是一个同构的问题 ， 就是你去写一些东西 ， 这个记忆它可以是 per session。

Scope 在会话上面 ， 就是每个会话它有一个自己的单独小记忆 ， 它也是每个用户有一个单独自己小记忆 ， 或者是每一个 tenant， 每一个公司它有一个自己的 share 的这个记忆 ， 或者是每个项目之类的这样东西 ， 根据各种各样的场景 ， 你可以选择各种各样的记忆的这种这个技术吧 ， 算是它有不同的啊效率 ， 不同的性能 。

所以所以现在关于这这方面的讨论也很多是吧 ，但是我们的行业标杆 Claude 依然是在用文本搜索来的文件 ， 那大家有没有有有没有觉得这件事情非常割裂啊 ？

Simple is better。

对 ，有文件系统也是这个的数据库 。

对对对 ， 文件系统也是数据库 ， 数据库也是文件系统 ， 哎 ，不不是 ， 数据库不是文件系统 ， 文件系统也是数据库 ， 对的 ， 我们做数据库的人其实这样认为 。

你们就是你不是做数据库 ， 就是有没有一些 ， 就你们有没有在搞这种存储 memory 的数据库相关的研究 ？

没有啊 ， 没有 ，不过前些年 vector search 是个非常非常热门的东西吧 ， 我们大家都在搞 ，但是那个那个其实在大模型之前好像就啊 ， 对 ，vector search 可能是大模型出来之后才开始热的 ，但是现在好像没有听说过数据库跟这个 AI 有任何相关之处 。

基本上我觉得现在说数据库里面 ， 然后你说我是 AI 如何如何 ， 那就是在做这个 vector search。

嗯 ，也不是吧 ， 我觉得现在数据库是倾向于就是如何让 AI 更好的数据库 ， 然后有不同的需求是吧 ， 这可能也是不一样的不一样的一点啊 。

好 ， 我们说了上下文管理 ， 我们说了记忆 ， 我们说了沙箱 ， 我们说了什么 ， 还有什么关键技术值得聊的吗 ？

我觉得另外一个就是 Subagents，其实本质上我觉得 Subagents 就是在解决 ， 还是在解决上下文的问题 ，因为对吧 ， 就你想象你如果要在一个呃 agent loop 里面去完成很多不同种类的事情 ， 那你这个就会有模型注意力分散的问题 ， 然后你会有 context 爆炸的问题 ， 那其实最直观解决的办法就是说开一些不同的 agent 去做不同的事情 ， 比如说啊 ，有一个 agent 负责去设计这个整个架构 ， 一个 agent

负责去写代码 ， 另一个 agent 去的负责去在最后审核这个呃前面 agent 做出的变更 ， 然后呢 ， 我们有一个这种 orchestrator 的 agent 去呃负责去跟这些不同的 Subagent 通信 ， 然后去呃给他们分派不同的任务 ， 呃这样就是一个非常典型的这种多 agent 的架构 ， 那么这样就是很大程度上是可以解决啊上下文管理的问题的 ， 包括其实 Anthropic 我觉得他们最近就是在力推这种 agent teams 吧 ， 包括那

个 Dynamic workflow 也是他们最近提出的 ， 就是对 ， 这个是一个前沿趋势 。

对我们程序员来说也有另外一个益处 ， 就是说它可以并行执行很多东西吧 ，因为某一个智能体是只能单向执行 ， 一个一个一个来 ， 对吧 ， 我可以说我现在我假设啊 ， 我我可以说你有这么多测试 ， 你并行跑一下， 然后并行调试一下， 这例子不好 ，但是就有一别的例子 ，但是说你可以它可以并行多个做同样一件事情 ， 然后我在主线程还可以跟我交汇 ， 对吧 ，是

吧 ？

对 ， 我我有一个更好的例子 ， 就是你像就是很简单写代码 ， 我只有一个任务 ， 它我知道它要写 5 个文件 ， 然后你交给一个 AI 去做的话 ， 它只能是因为它是线性的 ， 它只能先编辑一个文件 ， 然后再编辑第二个文件 ， 然后依次这样编辑下去 ，但是当我有一个呃 agent， 它说它已经提前规划好说啊 ， 我我为了实现这个啊功能 ， 我需要编辑 5 个文件 ，

然后这个时候它启动 5 个 Subagent 来同时编辑 5 个不同的文件 ， 这个时候这 5 个 agent 就会同时编辑 ， 然后这等于你花了跟和之前相比 1/5 的时间来完成同样的任务 。

对 ， 所以 Subagent， 那 Subagent 这个技术怎么实现呢 ？ 有什么难点呢 ？ 对 ，因为好好像主 agent 还要跟下面 agent 要通信啊 ， 怎么着吗 ？

这这个有什么技术难点吗 ？

嗯 ， 就是你把这些功能包装成工具 ， 然后告诉 agent 啊 ， 你可以拿这个跟另外一个 agent 聊 ， 然后有一个 loop 来 drive 这个啊东西往前进的 ， 基本上 。

对 ， 我觉得一个一个难点可能是你到底要开哪些 Subagent， 对 ，因为你可以有呃非常多不同的这种这种组织形式 ， 就如果听众们有兴趣 ， 可以看一下 Anthropic 最近的一些一些文章 。

它相当于这件事情是要自动完成啊 ， 从各种角度来讲啊 ， 从上下文的角度 ， 从从这个执行速度的这项并行执行的这样 ， 从各个角度都要综合考虑 ， 认为应该不应该启一个 。

对 ， 就之前的大家习惯是说我就是告诉这个 agent 我想启哪些 Subagent， 就是我我明确告诉它 ，但是现在呢 ， 就是可能未来就是说你这个 harness 它能够去 figure out 我最合适当前任务的一个呃 Subagent 的组织模式是什么 ， 然后它选择这个最合适的形式去完成这个任务 。

好 ， 所以我们 harness 技技术都已经说的差不多了吗 ？ 还有什么别的值得讲的 ？

感觉基本上重要的部分都聊了一下 ，其实其实我们就是一直默认用户都知道 tool calling 是什么 ， 那就是这个其实我们没有讲 ，但可能就是假设用户都知道 。

什么叫 tool calling？ 我发现我也不知道 。

就是前面讲 harness 那个啊 ， 讲 MCP 的时候好像讲技能的时候好像讲到了 ， 我要调用一个什么工具 ， 然后 agent 说我要调用一个什么工具 ， 然后 agent 把这个模型把这个参数什么的调用什么工具写一写 ， 然后 harness 拿过去 ， 然后去调用这个技能 。

啊 ， 所以说这就是调用工具 ， 就是说我还是比较不懂啊 ，但是模型跟你说在命令行里运行这个 ， 你就运行吗 ？

还是有什么别的 harness 需要做的事事情 ？

可能要管理一下 bash， 它可能会维持一个终端这个呃会话 ， 然后能让 agent 不停的往里面去执行命令这样 。

哦 ， 就它还不是每次都起一个新的 ， 它可能还会有一些管理一些它的这个它自己的命令行的一个会话在这 。

对 ，因为因为它有一些比如说环境变量啊之类的 ， 或者是你当前的这个工作在哪个文件夹跑呀 ， 啊跑命令啊之类这些事情 。

哦 ， 这看上去还是有一些复杂的地方在啊 ， 那你就要把这些信息都给都给 agent， 保证它说的是对的 ， 保证它回来那些还是还在啊 ， 所有的环境都是对的嘛 ， 看上去模型需要全知全能啊 ， 这要注意这个要注意那个啊 ， 那模型很厉害了 ， 工具靠它还非常的不容易 。

说到这啊 ， 我们一一直在说用这个 Claude Code 做编程 ，其实至少我我不知道你们呀 ， 我用 Claude Code 一半以上时间根本就不是在编程 ， 你们不是这样吗 ？

比如说出来一个工单 ， 我就让 Claude Code 说分析下这工单是怎么回事 ， 给我解释一下是吧 ，有的时候我让跟它说这个文档你帮我用这种这种方法改进一下对吧 ， 然后说完这个工单你遇到这个问题 ， 你说请这个跟我跟相关的人发消息 ， 发 Slack 消息提醒他这个这个这个是吧 ， 我至少一半时间不知道你怎么根本就不是在编程 ， 至少有一半的一

半就跟 Code 都没有关系 ， 就跟啊都没有关系 ， 另外一半一半可能希望它能读一下本地的 Code， 理解一下内容 ， 就是这个感觉是确实是一个一个很大的趋势 ， 你们有同样的体验吗 ？

呃 ， 我个人来说 ， 我可能大部分时间还是在做 coding task， 随随便便的这些事情吧 ，但是啊 ， 还是有一些 ， 比如说我要每天早上起来 ， 然后让 AI 帮我总结一下我的 Slack 里面有哪些我需要回复的 ， 工单里面有哪些需要 pay attention，是需要我的注意力的 ， 然后来做一些这样的非常简单的这种非常基础的这个自动化吧 ， 算是 ， 然后但是 AI 这个 harness 我觉得从 coding 开始是有非常

大潜力的 ，因为你如果想让这个 AI 去跟现实世界中的任何东西来交互 ， 你想让 AI 去解决任何现实中的问题 ， 它一定是通过 API 或者是 MCP 来进行的 ， 那么当这个理论成立之后， 那你如果说你的这个 AI 或者你的 harness 的 coding 能力非常强大的话 ， 你这个 AI 是完全可以组合自由的组合 ， 自由的写一段程序来根据你的这个啊指令来解决之对应的问题的 ， 所以说当

你把 coding 这件事情做好 ， 你之后能解决问题的能力也会相应的得到很大的提升 。

我我很同意这个观点 ， 就是说虽然我做的事情可能跟写代码完全没有关系 ，但是你可以你可以看这些智能体在下面其实写了很多代码 ， 还调试了很多轮 ， 然后才才才才运行 ， 所以这么说确实有道理 ， 它还叫 Claude Code，因为它确实要写 Code。

对 ，Anthropic 它有一个 repo 叫 Financial Service， 就是金融服务 ， 它里面就包含了很多各种各样的技能来教这个 Claude Code 如何进行 ， 比如说金融分析 ， 如何进行这个 comparative analysis， 就是分析下竞争者呀之类的 ， 然后它我我我试用过 ， 它真的很厉害 ， 它会写自己写 Python 这个脚本 ， 然后来给我生成 PPT， 或者给我生成 Excel 表格 ， 然后这些 Excel 表格里面都是有公式的 ， 都是能让我直接去

改一些 ， 比如说数字呀 ， 比如说改一下估值呀 ， 标的公司的估值呀之类之类的 ， 它会建议去下面的这些东西全部自动自动变出来 ， 所以就是 AI 就是不仅仅是用来解决这个最基本的这种编程问题 ， 它能解决各种各样很多其他的问题 。

嗯 ， 所以这个我太太的公司 ，他们在力推过于 ， 就是现在我们大家都是用终端嘛 ，他们都是在力推这个用这个应用 ， 就是出了一个框在里面写 ，他们公司力推理由就是说只有程序员用用这些命令框 ， 除了程序员谁还用命令框 ，他为了让各个领域其他人都用这个 Claude Code， 就是所以所以他们要力推这个过于 ， 当然我们程序员无所谓 ， 我用不用命令

好还是我是无所谓的 。

啊 ， 我我顺便这里我可以想讲一下 Lovable 之类的这些啊 ， 用来设计原型之类这些东西 ， 我用了很多 ， 比如说 Claude Design 啊 ， 或者 Lovable， 我是非常开心的 ， 就是我产品能力我觉得没有没有很强 ， 然后就是我就会有一个啊想要解决的问题 ， 就丢给这个 AI 来解决 ，AI 就会帮我做出来一个很看上去很好很合适的这个原型 ， 然后我就照着继续开发就好了 ， 它

能力很强 ， 然后包括你其实现在在 Claude 本身 ， 就是在这个对话框里面 ， 你去问它一些啊事情 ， 你让它分析一个问题 ， 它会给你可以给你生成一个 HTML 的这个报表 ， 它甚至是可以交互的 ， 比如说啊 ， 然后你可以你可以去实验不同的场景 ，有了这个功能之后， 它回答问题的这个能力会得到很大提升 ， 你就像有一个属于你自己的这个 consultant 咨询公司一样 ， 然后它会给

你做出来一个不仅是一个 PPT， 你还是一个可以交互的这种报告 ， 就非常厉害 。

我最近也用了 Claude Code，Claude Design 做了一下我最新的这个这些演讲 ， 去还可以 ， 后来发现你没有办法修改 ， 你没有你没有办法跟它互动 ， 然后我就非常的非常的崩溃 ， 我们所有同事用的效果都是这样 ， 就是一开始你觉得挺好 ， 然后就崩溃了 ， 最后你没有办法完成它 ， 你还要把它最后导入 ， 最后又做了一半 ， 花时间把它做成一个可以做的这个 ， 所以你可以用它

开始 ， 然后用 Gemini 结束 ， 可能哈哈 ， 用那个用来解决 writer's block。 好 ， 我们这期已经聊了很长很长很长了 ， 本来想聊一部分是未来趋势 ， 那我们没有时间聊了 ， 我们我们下次可以专门聊一次 harness 啊 ， 可以专门聊一次这些未来趋势 ， 可以看一看啊 ， 这次我们时间非常长了 ， 我们听众不知道喜欢不喜欢这么长的节目啊 ， 所以我们就是非常非常感谢这个

laik9m 和 Rice 这些既分享了经验 ，也分享了这些实现这些呃智能体的技术啊 ， 然后我们希望能够再次跟大家再聊一次这个具体的这些未来的趋势 。

可能可能今天聊了很多 ，有些啊过于技术 ， 然后但是啊我觉得也希望听众们能够更加了解吧 ， 毕竟啊这个也是未来的一个不可避免的大趋势 。

好 ， 喜欢我们节目 ， 欢迎到各大泛用型播客平台啊订阅和收听 ， 那我们就后会有期了 。

拜拜 ， 拜拜 。