从「氛围编程」到智能体工程

我们非常兴奋迎来第一位特邀嘉宾。他帮助构建了现代 AI，然后解释现代 AI，偶尔还重新命名现代 AI。他实际上就在这间办公室共同创立了 OpenAI，当年在特斯拉也是他让自动驾驶系统真正运转起来。他有一种罕见的天赋，能让最复杂的技术转变既显得平易近人又不可避免。大家都知道他去年创造了「氛围编程」这个词，但就在过去几个月里，他说了一句更令人震惊的话：他从未觉得自己作为程序员如此落后。这就是我们今天开始的地方。感谢 Andre 加入我们。

We're so excited for our very first special guest. He has helped build modern AI, then explain modern AI, and then occasionally rename modern AI. He actually helped co-found OpenAI right inside of this office, was the one who actually got autopilot working at Tesla back in the day. And he has a rare gift of making the most complex technical shifts feel both accessible and inevitable. You all know him for having coined the term vibe coding last year, but just in the last few months he said something even more startling, that he's never felt more behind as a programmer. That's where we're starting today. Thank you, Andre, for joining us.

是的，大家好。我很高兴来到这里，开启今天的对话。

Yeah, hello. I'm excited to be here and to kick us off.

好的，就在几个月前，你说你从未觉得自己作为程序员如此落后。从你口中听到这句话尤其令人震惊。你能帮我们解读一下吗？这种感觉是令人兴奋还是不安？

Okay, so just a couple months ago you said that you've never felt more behind as a programmer. That's startling to hear from you of all people. Can you help us unpack that? Was that feeling exhilarating or unsettling?

是的，两者兼有。首先，我想和你们许多人一样，我已经使用智能体式工具（比如 AlphaCode 之类的）一段时间了，大概从去年它们出现开始。它们很擅长生成代码块。有时会出错，你需要编辑它们，但还算有用。然后，我觉得十二月是一个明显的转折点，我当时在休假，所以有更多时间。我想很多人也类似。我开始注意到，用最新的模型，生成的代码块直接就很好了。然后我不断要求更多，结果都很好。然后我都不记得上次纠正它是什么时候了。我越来越信任这个系统。然后我就开始「氛围编程」了。所以这是一个非常鲜明的转变。我认为很多人实际上——我试图在 Twitter 或 X 上强调这一点——因为我认为很多人去年体验 AI 时还把它当作 ChatGPT 之类的东西，但你真的需要重新审视，尤其是从十二月开始，因为事情已经发生了根本性变化，特别是这种智能体式的连贯工作流真的开始奏效了。所以，是的，正是这个认识让我彻底陷入了无限副项目的兔子洞。我的副项目文件夹里塞满了各种随机的东西，我一直在编程。所以，大概就是十二月发生的。从那以后我一直在思考它的影响。

Yeah, mixture of both for sure. Well, first of all, I guess like many of you I've been using agentic tools like AlphaCode adjacent things for a while, maybe over the last year as it came out. And it was very good at chunks of code. And sometimes it would mess up and you have to edit them, and it was kind of helpful. And then I would say December was this clear point where for me I was on a break, so I had a bit more time. I think many other people were similar. And I just start to notice that with the latest models the chunks just came out fine. And then I kept asking for more, and just came out fine. And then I can't remember the last time I corrected it. And then I just trusted the system more and more. And then I was vibe coding. And so it was kind of a very stark transition. I think that a lot of people actually I tried to stress this on Twitter or X because I think a lot of people experienced AI last year as a ChatGPT adjacent thing, but you really had to look again, and you had to look as of December because things have changed fundamentally and especially on this agentic coherent workflow that really started to actually work. And so I would say that yeah, it was just that realization that really had me go down the whole rabbit hole of just, you know, infinity side project. My side projects folder is like extremely full with lots of random things and I've been coding all the time. So yeah, that kind of happened in December, I would say. And I was looking at the repercussions of that since.

你经常谈到 LLM 作为一种新计算机的想法。这不仅仅是更好的软件，而是一个全新的计算范式。软件 1.0 是显式规则，软件 2.0 是学习到的权重，软件 3.0 就是现在这个。如果这真的成立，那么一个团队真正相信这一点的那一天，他们会以什么不同的方式构建东西？

You've talked a lot about this idea of LLMs as a new computer. That it isn't just better software, it's a whole new computing paradigm. Software 1.0 was explicit rules, Software 2.0 was learned weights, Software 3.0 is this. If that's actually true, what does a team build differently the day they actually believe this?

没错。所以，软件 1.0 是我写代码，软件 2.0 是我通过创建数据集和训练神经网络来编程。所以编程有点像安排数据集，也许还有一些目标和神经网络架构。然后发生的事情是，基本上如果你在一个足够大的任务集上隐式地训练这些 GPT 模型或 LLM——因为通过在互联网上训练，你必须多任务处理数据集中的所有内容——它们实际上在某种意义上变成了一种可编程的计算机。所以软件 3.0 就是你的编程现在变成了提示，而上下文窗口中的内容是你控制解释器（即 LLM）的杠杆，它解释你的上下文并在数字信息空间中执行计算。所以我想这就是转变，我认为有几个例子让我真正理解了这一点，也许这些例子有启发意义。例如，当你想安装 OpenClaw 时，你通常会认为这是一个 bash 脚本，一个 shell 脚本。所以，运行 shell 脚本来安装 OpenClaw。但问题是，为了支持你可能运行 OpenClaw 的许多不同平台和不同类型的计算机，这些 shell 脚本通常会变得非常庞大和复杂。但问题是你仍然困在软件 1.0 的思维里，想要写代码。而实际上 OpenClaw 的安装是一段你要复制粘贴给你的智能体的文本。所以，基本上这是一个小技巧：复制粘贴这个，交给你的智能体，它就会安装 OpenClaw。这之所以强大得多，是因为你现在工作在软件 3.0 范式下，你不需要精确地列出所有设置的细节。智能体有自己的智能，它会打包起来，然后按照指令行事，它会查看你的环境、你的计算机，并执行智能操作来让事情运转，并在循环中调试。这强大得多，对吧？所以，我认为这是一种非常不同的思考方式。就是：你要复制粘贴给智能体的文本是什么？这就是现在的编程范式。我想还有一个更极端的例子，就是当我构建 MenuGen 的时候。MenuGen 的想法是，你走进一家餐厅，他们给你菜单，通常没有图片，所以我不知道这些东西是什么。通常大约 30%的东西我不知道是什么，甚至 50%。所以我想拍一张餐厅菜单的照片，然后得到这些菜品的通用图片。于是我构建了一个应用，让你上传照片，它做所有处理，运行在 Vercel 上，它基本上重新渲染菜单，列出所有菜品，并用图像生成器 OCR 所有标题，生成图片然后展示给你。然后我看到了软件 3.0 版本的实现，它让我震惊：就是直接拿你的照片，交给 Gemini，说「用 Nano Banana 把菜品覆盖到菜单上」。然后 Nano Banana 返回了一张图片，正是我拍的那张菜单照片，但它在像素中实际渲染了菜单上的不同菜品。这让我震惊，因为实际上我的整个 MenuGen 都是多余的。它工作在旧范式下，那个应用根本不应该存在。是的，软件 3.0 范式要原始得多。

Right. So, exactly. So Software 1.0 I'm writing code, Software 2.0 I'm actually programming by creating datasets and training neural networks. So the programming is kind of like arranging datasets and maybe some objectives and neural network architectures. And then what happened is that basically if you train one of these GPT models or LLMs on a sufficiently large set of tasks implicitly, because by training on the internet you have to multitask all the things that are in the dataset, these actually become kind of like a programmable computer in a certain sense. So Software 3.0 is kind of about your programming now turns to prompting and what's in the context window is your lever over the interpreter that is the LLM that is kind of like interpreting your context and performing computation in the digital information space. So I guess that's kind of the transition and I think there's a few examples that really drove it home for me and maybe that might be instructive. So for example, when you want to install OpenClaw, you would expect that normally this is a bash script, a shell script. So, run the shell script to install OpenClaw. But the thing is that in order to target lots of different platforms and lots of different types of computers you might run OpenClaw on, these shell scripts usually ballooned up and become extremely complex. But the thing is you're still stuck in a Software 1.0 universe of wanting to write the code. And actually the OpenClaw installation is a copy-paste of a bunch of text that you're supposed to give to your agent. So, basically it's a little skill of copy-paste this and give it to your agent and it will install OpenClaw. And the reason this is a lot more powerful is you're working now in the Software 3.0 paradigm where you don't have to precisely spell out all the individual details of that setup. The agent has its own intelligence that it packages up and then it follows the instructions and it looks at your environment, your computer, and it performs intelligent actions to make things work and debugs things in the loop. And it's just like so much more powerful, right? So, I think that's a very different kind of way of thinking about it. It's just like, what is the piece of text to copy-paste to your agent? That's the programming paradigm now. I think one more maybe example that comes to mind that is even more extreme than that is when I was building MenuGen. So, MenuGen is this idea where you come to a restaurant, they give you a menu, there's no pictures usually, so I don't know what any of these things are. Usually I like 30% of the things I have no idea what they are, 50%. So, I wanted to take a photo of the restaurant menu and to get pictures of what those things might look like in a generic sense. And so, I built this app that basically lets you upload a photo and it does all this stuff and it runs on Vercel and it basically re-renders the menu and it gives you all the items and it gives you a picture that it uses an image generator to basically OCR all the different titles, use the image generator to get pictures of them and then shows it to you. And then I saw the Software 3.0 version of this, which blew my mind, which is literally just take your photo, give it to Gemini, and say use Nano Banana to overlay the things onto the menu. And Nano Banana basically returned an image that is exactly the picture of the menu that I took, but it actually put into the pixels, it rendered the different things in the menu. And this blew my mind because actually all of my MenuGen is spurious. It's working in the old paradigm that app shouldn't exist. And yeah, the Software 3.0 paradigm is a lot more kind of raw.

现在是你的神经网络在做越来越多的工作，你的提示或上下文只是图像，输出也是图像，中间不需要任何应用。所以，我认为人们需要重新思考，不要停留在现有事物的范式里，只把它看作是对现有事物的加速。实际上，现在有了新的事物。回到你关于编程的问题，那也是旧思维模式的一个例子，因为这不仅仅是编程变得更快。这是更通用的信息处理，现在可以自动化了。所以，这不仅仅是代码的问题。以前的代码处理结构化数据，对吧？你在结构化数据上写代码。但例如，在我的 LLM 知识库项目中，你让 LLM 为你的组织或你个人创建维基等。这甚至不是一个程序。这在以前是不可能存在的，因为没有代码能基于一堆事实创建知识库。但现在你可以直接拿这些文档，以不同的方式重新编译、重新排序，创造出新的有趣的东西，作为数据的重新框架。所以，这些都是以前不可能的新事物。我一直想回到这一点：不仅是我们能更快地做以前能做的事，还有以前不可能实现的新机会。我几乎觉得这更令人兴奋。

It's your neural network doing more and more of the work, and your prompt or context is just the image, and the output is an image, and there's no need to have any app in between. So, I think that people have to reframe, not to work in the existing paradigm of what things existed and just think about it as a speedup of what exists. It's actually that new things are available now. And going back to your programming question, that's also an example of working in the old mindset because it's not just about programming becoming faster. This is more general information processing that is automatable now. So, it's not just about code. Previous code worked over structured data, right? You write code over structured data. But for example, with my LLM knowledge bases project, you get LLMs to create wikis for your organization or for you personally, etc. This is not even a program. This is not something that could exist before because there was no code that would create a knowledge base based on a bunch of facts. But now you can just take these documents and recompile them in a different way, reorder them, and create something new and interesting as a reframing of the data. So, these are new things that weren't possible. I keep trying to get back to this: not only what can we do that existed that is faster now, but there are new opportunities of things that couldn't be possible before. I almost think that's more exciting.

我喜欢你提出的 MenuGen 演进和二分法，我想在座的很多人都关注了你从去年十月到今年一月、二月的编程进展。如果再进一步推演，2026 年相当于 90 年代建网站、2010 年代建移动应用、上一个云时代建 SaaS 的会是什么？什么东西在事后看来会完全显而易见，而今天却基本没被构建？

I love the MenuGen progression and dichotomy that you laid out, and I think many folks here followed your own progression of programming from last October to early January, February this year. If you extrapolate that further, what is the 2026 equivalent for building websites in the '90s, building mobile apps in the 2010s, building SaaS in the last cloud era? What will look completely obvious in hindsight that is still mostly unbuilt today?

嗯，以 MenuGen 为例吧。很多这样的代码本不该存在，只是神经网络在做大部分工作。我确实觉得这种推演看起来很奇怪，因为你可以想象某种意义上的完全神经计算机。你输入原始视频，想象一个设备把原始视频或音频输入神经网络，用扩散模型渲染出一个在某种意义上独一无二的 UI。我觉得在计算机早期，人们有点困惑计算机会像计算器还是像神经网络。在五六十年代，哪种方向会胜出并不明显。当然，我们走了计算器的路，最终建立了经典计算，而神经网络目前虚拟化运行在现有计算机上。但你可以想象很多情况会翻转，神经网络成为主进程，CPU 成为协处理器。我们看到过这样的图景：智能算力将流向神经网络，成为 FLOPs 的主要消耗。所以，你可以想象一些非常奇怪和陌生的东西，神经网络做大部分重活，工具使用只是作为历史遗留的附属品用于某些确定性任务。但真正主导的是这些以某种方式联网的神经网络。所以，你可以想象非常陌生的推演结果，但我想我们会一步步达到。这个进展还待定，我会这么说。

Well, going with the example of MenuGen, I guess. So, a lot of this code shouldn't exist and it's just neural networks doing most of the work. I do think that the extrapolation looks very weird because you could basically imagine completely neural computers in a certain sense. You feed raw videos, like imagine a device that takes raw videos or audio into basically a neural net and uses diffusion to render a UI that is unique for that moment in a certain sense. I feel like in the early days of computing, people were a bit confused as to whether computers would look like calculators or neural nets. In the '50s and '60s, it was not really obvious which way would go. Of course, we went down the calculator path and ended up building classical computing, and neural nets are currently running virtualized on existing computers. But you could imagine that a lot of this will flip and the neural net becomes the host process, and the CPUs become the co-processor. We saw the diagram that intelligence compute going to neural networks will take over and become the dominant spend of flops. So, you could imagine something really weird and foreign where neural nets are doing most of the heavy lifting, using tool use as just a historical appendage for some deterministic tasks. But what's really running the show is these neural nets that are networked in a certain way. So, you can imagine something extremely foreign as the extrapolation, but I think we'll probably get there piece by piece. That progression is TBD, I would say.

我想谈谈可验证性这个概念。AI 会更快、更容易地自动化那些输出可被验证的领域。如果这个框架是对的，什么工作会以远超人们想象的速度推进？又有哪些职业人们以为很安全，但实际上高度可验证？

I'd love to talk a bit about this concept of verifiability. The fact that AI will automate faster and more easily domains where the output can be verified. If that framework is right, what work is about to move much faster than people realize? And what professions do we have that people actually think are safe, but they're actually highly verifiable?

是的，我花了一些时间写关于可验证性的文章。基本上，传统计算机可以轻松自动化那些你能用代码指定的东西。而最新一轮的 LLM 可以轻松自动化那些在某种意义上你能验证的东西。因为其工作方式是，前沿实验室在训练这些 LLM 时，它们处于巨大的强化学习环境中。它们会得到验证奖励。由于这些模型的训练方式，它们最终会进步并创造出这些锯齿状的实体，在数学、代码等可验证领域能力达到顶峰，而在其他领域则停滞不前、边缘粗糙。所以我写可验证性的原因是我试图理解为什么这些东西如此参差不齐。部分原因与实验室训练模型的方式有关，但我觉得也与实验室的焦点以及他们碰巧放入数据分布的内容有关。因为有些东西在经济上更有价值，最终创造了更多环境，因为实验室希望在这些场景中工作。所以我认为代码是一个很好的例子。可能有很多可验证的环境他们本可以考虑，但因为没有那么有用而没有被纳入。但对我来说，最大的谜团是，之前流行的例子是「strawberry」里有多少个字母？模型会著名地答错，这是锯齿状的一个例子。现在模型已经修补了这个问题，但新的问题是：我想去洗车，距离 50 米，我应该开车还是走路？当前最先进的模型会告诉你走路，因为太近了。怎么可能最先进的 Opus 4.7 同时能重构 10 万行代码库或发现零日漏洞，却告诉我走路去洗车？这太疯狂了。无论这些模型在多大程度上保持锯齿状，都表明要么第一，可能有些地方不太对劲；要么第二，你需要实际参与其中，把它们当作工具，并且必须关注它们在做什么。

Yes, I spent some time writing about verifiability. Basically, traditional computers can easily automate what you can specify in code. And this latest round of LLMs can easily automate what you can verify in a certain sense. Because the way this works is that when frontier labs are training these LLMs, these are giant reinforcement learning environments. They are given verification rewards. And because of the way these models are trained, they end up progressing and creating these jagged entities that really peak in capability in verifiable domains like math and code and adjacent. And they stagnate and are rougher on the edges when things are not in that space. So, I think the reason I wrote about verifiability is I'm trying to understand why these things are so jagged. Some of it has to do with how the labs train the models, but I think some of it also has to do with the focus of the labs and what they happen to put into the data distribution. Because some things are significantly more valuable in the economy and end up creating more environments because the labs wanted to work in those settings. So, I think code is a good example. There are probably lots of verifiable environments they could think about that happen not to make it into the mix because they're just not that useful to have the capability around. But to me, the big mystery is the favorite example for a while was how many letters are in a strawberry? And the models would famously get this wrong, an example of jaggedness. The models now patch this, I think, but the new one is: I want to go to a car wash to wash my car, and it's 50 meters away, should I drive or should I walk? And state-of-the-art models today will tell you to walk because it's so close. How is it possible that state-of-the-art Opus 4.7 will simultaneously refactor a 100,000-line code base or find zero-day vulnerabilities and yet tells me to walk to this car wash? This is insane. To whatever extent these models remain jagged, it's an indication that number one, maybe something is slightly off. Or number two, you need to actually be in the loop a little bit and treat them as tools, and you do have to stay in touch with what they're doing.

所以，长话短说，我关于可验证性的所有写作，都是在试图理解为什么这些能力是参差不齐的，是否有某种模式？我认为这是可验证性与实验室关注度的某种结合。也许还有一个有启发性的轶事：从 GPT-3.5 到 GPT-4，人们注意到国际象棋能力提升了很多，很多人以为这只是能力的自然进步。但实际上，这是公开信息，我在网上看到过。大量国际象棋数据被加入了预训练集。仅仅因为它在数据分布中，模型就比默认情况下提升得多得多。所以 OpenAI 的某个人决定加入这些数据，结果这项能力就突飞猛进。这就是为什么我强调这个维度：我们有点受制于实验室在做什么，他们往混合数据里放了什么，你必须去探索他们给你的这个东西，它没有说明书，在某些场景下有效，但在其他场景下可能无效，你需要去探索。如果你处于 RL 涉及的回路中，你就如鱼得水；如果你处于数据分布之外的回路，你就会挣扎，你必须弄清楚你的应用处于哪个回路。如果你不在那些回路中，你就得认真考虑微调，自己做些工作，因为 LLM 不一定开箱即用。

And so I think all of my writing, long story short, about verifiability is just trying to understand why these things are jagged, is there any pattern to it? And I think it's some kind of combination of verifiable plus labs care. Maybe one more anecdote that is instructive is from GPT-3.5 to GPT-4, people noticed that chess improved a lot and I think a lot of people thought, oh well, it's just a progression of the capabilities. But actually it's more that I think this is public information, I think I saw it on the internet. A huge amount of data of chess made it into the pre-training set. And just because it's in the data distribution, basically the model improved a lot more than it would just by default. So someone at OpenAI decided to add this data and now you have a capability that just peaked a lot more. And so that's why I think I'm stressing this dimension of it as we are slightly at the mercy of whatever the labs are doing, whatever they happen to put into the mix and you have to actually explore this thing that they give you that has no manual and it works in certain settings but maybe not in some settings and you have to kind of explore it a little bit and if you're in the circuits that were part of the RL, you fly and if you're in the circuits that are out of the data distribution, you're going to struggle and you have to kind of figure out which circuits you're in in your application. And if you're not in the circuits, then you have to really look at fine-tuning and doing some of your own work because it's not going to necessarily come out of the LLM out of the box.

我想稍后再回到「参差不齐的智能」这个概念。如果你今天是一位创始人，正在考虑创办一家公司，你想解决一个你认为可行的问题，一个可验证的领域，但你环顾四周，心想：「天哪，实验室真的已经开始达到逃逸速度了，最明显的领域是数学、编程等等。」你会给在座的创始人什么建议？

I'd love to come back to the concept of jagged intelligence in a little bit. If you were a founder today and thinking about building a company, you are trying to solve a problem that you think is tractable, something that is a domain that is verifiable, but you look around and you think, "Oh my gosh, well the labs have really really started getting to escape velocity and the ones that seem most obvious, math, coding, and others." What would your advice be to the founders in the audience?

所以，我认为这可能回到了之前的问题：我确实认为可验证性，因为……让我想想。可验证性在当前范式下让事情变得可行，因为你可以投入大量 RL。所以，也许可以这样看：即使实验室没有直接关注，这一点仍然成立。所以，如果你处于一个可验证的环境中，可以创建这些 RL 环境或示例，那么这实际上为你提供了自己进行微调的可能性，你可能会从中受益。但这本质上是一种行之有效的技术。你可以拉动杠杆。如果你有大量多样化的 RL 环境数据集等，你可以使用你喜欢的微调框架，拉动杠杆，得到效果不错的结果。所以，我不知道具体例子是什么。但我确实认为有一些非常有价值的强化学习环境是人们可以想到的，它们不属于……是的，我不想透露答案，但有一个领域我认为非常……哦，好吧。抱歉，我不是故意在台上含糊其辞，但确实有一些这样的例子。

So, I think maybe that comes to the previous question of I do think that verifiability because it... Let me think. So, verifiability makes something tractable in the current paradigm because you can throw huge amount of RL at it. So, maybe one way to see it is that that remains true even if the labs are not focusing on it directly. So, if you are in a verifiable setting where you could create these RL environments or examples, then that actually sets you up to potentially do your own fine-tuning and you might benefit from that. But, that is fundamentally technology that just works. You can pull a lever. If you have huge amount of diverse data sets of RL environments, etc., you can use your favorite fine-tuning framework and pull the lever and get something that actually works pretty well. So, I don't know what the examples of this might be. But I do think there are some very valuable reinforcement learning environments that people could think of that I think are not part of the... Yeah, I don't want to give away the answer, but there is one domain that I think is very... Oh, okay. Sorry. I don't mean to vague post on the stage, but there are some examples of this.

另一方面，你认为哪些事情仍然只是看起来可自动化？

On the flip side, what do you think still feels automatable only from a distance?

我确实认为，最终几乎所有事情都可以在一定程度上变得可验证，有些更容易，有些更难。因为即使是写作之类的事情，你可以想象有一个 LLM 评审委员会，通过这种方法可能得到合理的结果。所以，这更多是关于什么容易、什么困难。所以，我确实认为最终……是的，我认为一切都可以自动化。

I do think that ultimately almost everything can be made verifiable to some extent, some things easier than others. Because even for things like writing or so on, you can imagine having a council of LLM judges and probably get something reasonable out of this kind of an approach. So, it's more about what's easy or hard. So, I do think that ultimately... Yeah, I think everything.

一切都可以自动化。太棒了。好的。那么，去年你创造了「氛围编码」这个词，今天我们处于一个感觉更严肃、更智能体式工程的世界。你认为两者之间的区别是什么？你实际上会如何称呼我们今天所处的阶段？

Everything is automatable. Amazing. Okay. So, last year you coined the term vibe coding and today we're in a world that feels a little bit more serious, more agentic engineering. What do you think is the difference between the two and what would you actually call what we're in today?

是的，我会说氛围编码是关于提升每个人在软件方面的能力下限。所以下限提高了，每个人都可以氛围编码任何东西，这很了不起，难以置信。但我要说，智能体式工程是关于保持专业软件之前存在的质量门槛。所以，你不能因为氛围编码而引入漏洞。你仍然像以前一样对你的软件负责，但你能更快吗？剧透：你可以，但如何正确地做到这一点？所以，对我来说，智能体式工程，我这么称呼它，是因为我认为它有点像一门工程学科。你拥有这些智能体，它们是参差不齐的实体，有点容易出错，有点随机，但非常强大。问题是如何协调它们，在不牺牲质量门槛的情况下更快？做好并做对，这就是智能体式工程的领域。所以，我认为它们是不同的。一个关于提升下限，另一个关于拓展上限。我观察到的是，智能体工程能力的天花板非常高。你知道，以前人们谈论 10 倍工程师。我认为这被放大了很多。10 倍并不是你获得的速度提升。在我看来，现在非常擅长这个的人，其峰值远不止 10 倍。

Yeah, so I would say vibe coding is about raising the floor for everyone in terms of what they can do in software. So, the floor rises, everyone can vibe code anything, and that's amazing, incredible. But then I would say agentic engineering is about preserving the quality bar of what existed before in professional software. So, you're not allowed to introduce vulnerabilities due to vibe coding. You are still responsible for your software just as before, but can you go faster? And spoiler is you can, but how do you do that properly? And so, to me agentic engineering when I call it that because I do think it's kind of like an engineering discipline. You have these agents which are these spiky entities, they're a bit fallible, a little bit stochastic, but they are extremely powerful. And it's how do you coordinate them to go faster without sacrificing your quality bar? And doing that well and correctly is the realm of agentic engineering. So, I kind of see them as different. Like one is about raising the floor, and the other is about extrapolating. And what I'm seeing I think is there is a very high ceiling on agent engineering capability. And you know, people used to talk about the 10x engineer previously. I think that this is magnified a lot more. 10x is not the speed up you gain. And I think it does seem to me that people who are very good at this peak a lot more than 10x from my perspective right now.

我非常喜欢这个框架。去年 Sam Altman 来 AI sent 时，他说过一句令人难忘的话：不同世代的人使用 ChatGPT 的方式不同。所以，如果你三十多岁，你把它当作 Google 搜索的替代品；但如果你是十几岁，ChatGPT 是你通往互联网的门户。在今天的编程中，有什么类似之处？如果我们观察两个人使用 open claw、Claude Code、codex 编程，一个你认为水平一般，另一个你认为完全是 AI 原生的，你会如何描述这种差异？

I really like that framing. One thing that when Sam Altman came to AI sent last year, one memorable thing he said was that people of different generations use ChatGPT differently. So, if you're in your 30s, you use it as a Google search replacement, but if you're in your teens, ChatGPT is your gateway to the internet. What is the parallel here in coding today? If we were to watch two people code using open claw, Claude Code, codex, one you'd consider mediocre at it and one you would consider fully AI native, how would you describe the difference?

我的意思是，我认为这只是尽力利用可用的工具，利用它们的所有功能，投入时间打造自己的设置。就像以前，所有工程师都习惯于充分利用他们使用的工具，无论是 Vim 还是 VS Code，现在则是 Claude Code 或 codex 等等。所以，就是投入时间打造你的设置，利用许多可用的工具。我认为看起来就是这样。我确实认为，也许相关的想法是，很多人可能正在为此招聘，对吧？因为他们想雇佣强大的智能体式工程师。

I mean, I think it's just trying to get the most out of the tools that are available, utilizing all of their features, investing into your own kind of setup. So, just like previously, all the engineers are used to basically getting the most out of the tools you use, either it's Vim or VS Code or now it's Claude Code or codex or so on. So, just investing into your setup and utilizing a lot of the tools that are available to you. And I think it just kind of looks like that. I do think that maybe related thought is a lot of people are maybe hiring for this, right? Because they want to hire strong agentic engineers.

我确实认为，我所看到的是，大多数人仍然没有调整他们的招聘流程来适应智能体式工程能力。如果你还在出谜题让人解，那还是旧范式。我认为招聘应该像这样：给我一个大项目，看一个人如何实现这个大项目。比如，为智能体写一个 Twitter 克隆，让它非常好、非常安全，然后让一些智能体在这个 Twitter 上模拟活动。接着我用 codex 5.4 x high 试图攻破你部署的网站，他们应该攻不破。所以可能就是这样。观察人们在那种环境中构建更大的项目并利用工具，可能是我主要看重的。

I do think that what I'm seeing is that most people are still not refactored their hiring process for agentic engineer capability. If you're giving out puzzles to solve, then this is still the old paradigm. I would say that hiring has to look like: give me a really big project and see someone implement that big project. Let's write a Twitter clone for agents and make it really good, make it really secure, and then have some agents simulate some activity on this Twitter. Then I'm going to use codex 5.4 x high to try to break your website that you deployed and they're going to try to break it and they should not be able to break it. So maybe it looks like that. Watching people in that setting and building some bigger projects and utilizing the tooling is maybe what I would look at for the most part.

随着智能体做得更多，你认为哪种人类技能变得更有价值，而不是更少？

And as agents do more, what human skill do you think becomes more valuable, not less?

好问题。目前答案是，智能体在编目这些内部实体。值得注意的是，你基本上仍然要负责审美、判断、品味和一点监督。我最喜欢的智能体怪异例子之一是关于 menu gen：你用 Google 账户注册，但用 Stripe 账户购买积分，两者都有电子邮件地址。我的智能体实际上会尝试在购买积分时，用 Stripe 的电子邮件地址分配给 Google 电子邮件地址。没有持久的用户 ID。它试图匹配电子邮件地址，但你可以为 Stripe 和 Google 使用不同的电子邮件，这样资金就不会关联。这就是智能体仍然会犯错的地方。为什么要用电子邮件地址来交叉关联资金？它们可以是任意的。你可以用不同的电子邮件。所以我认为人们必须负责这个规格、这个计划。我甚至不喜欢计划模式。显然它很有用，但我认为这里有更普遍的东西：你必须与你的智能体合作设计一个非常详细的规格，可能基本上是文档，然后让智能体去写。你负责监督和顶层分类，但智能体做很多底层工作。所以你不关心一些细节。例如，在神经网络的数组或张量中，PyTorch、NumPy、pandas 等有大量 API 细节。我已经忘记了 keepdims 与 keepdim，或者 dim 与 axis，reshape 与 permute 与 transpose。我不再记得这些了，因为你不需要。这些细节由实习生处理，因为他们有很好的记忆力。但你仍然需要知道，例如，有底层张量、底层视图，你可以有同一存储的视图，也可以有不同的存储，后者效率较低。我们仍然需要理解这些东西在做什么以及一些基础知识，这样你就不会不必要地复制内存。但 API 的细节现在被移交了。你负责品味、工程、设计，确保它合理，你要求的是正确的东西，你说这些必须是唯一的用户 ID，我们将所有东西绑定到它。你做一部分设计和开发，工程师做填空。这就是我们目前的状态，我认为每个人现在都看到了这一点。

Yeah, it's a good question. Right now the answer is that the agents are catalog these internal entities. It's remarkable you basically still have to be in charge of the aesthetics, the judgment, the taste, and a little bit of oversight. One of my favorite examples of the weirdness of agents is for menu gen, you sign up with a Google account, but you purchase credits using a Stripe account and both of them have email addresses. My agent actually tries to, when you purchase credits, assign it using the email address from Stripe to the Google email address. There wasn't a persistent user ID for people. It was trying to match up the email addresses, but you could use different email addresses for your Stripe and your Google and it would not associate the funds. This is the kind of thing that these agents still will make mistakes about. Why would you use email addresses to try to cross-correlate the funds? They can be arbitrary. You can use different emails. So I think people have to be in charge of this spec, this plan. I don't even like the plan mode. Obviously it's very useful, but I think there's something more general here where you have to work with your agent to design a spec that is very detailed, maybe basically the docs, and then get the agents to write them. You're in charge of the oversight and the top-level categories, but the agents are doing a lot of the under the hood. So you're not caring about some of the details. As an example, with arrays or tensors in neural networks, there's a ton of details between PyTorch and NumPy and pandas and so on for all the different API details. I already forgot about the keepdims versus keepdim or whether it's dim or axis or reshape or permute or transpose. I don't remember this stuff anymore because you don't have to. This is the kind of details that are handled by the intern because they have very good recall. But you still have to know, for example, that there's an underlying tensor, there's an underlying view and you can have a view of the same storage or you can have different storage which will be less efficient. We still have to have an understanding of what this stuff is doing and some of the fundamentals so that you're not copying memory around unnecessarily. But the details of the APIs are now handed off. You're in charge of the taste, the engineering, the design, and that it makes sense and that you're asking for the right things and that you're saying that these have to be unique user IDs that we're going to tie everything to. You're doing some of the design and development and the engineers are doing the fill in the blanks. That's currently where we are and I think that's what everyone is seeing right now.

你认为随着时间的推移，这种品味和判断力会变得不那么重要，还是天花板会不断上升？

Do you think there's a chance that this taste and judgment matters less over time or will the ceiling just keep rising?

好问题。我希望它会改进。我认为现在没有改进的原因可能是它不属于强化学习的一部分。可能没有美学成本或奖励，或者不够好。我确实认为，当你实际看代码时，有时我会有点心脏病发作，因为它不总是超级棒的代码，非常臃肿，有很多复制粘贴，有脆弱的尴尬抽象，它能用但真的很糟糕。我确实希望未来的模型能改进这一点。一个很好的例子是 micro GPT 项目，我试图将 LLM 训练简化到尽可能简单。模型讨厌这个。它们做不到。我不断提示 LLM 简化再简化，但它就是做不到。你感觉你处于强化学习回路之外。感觉就像拔牙。不是光速。所以我认为人们仍然负责这个，但我认为没有根本性的障碍。只是实验室还没有做到。

Yeah, it's a good question. I'm hoping that it improves. I think probably the reason it doesn't improve right now is again it's not part of the RL. There's probably no aesthetics cost or reward or it's not good enough. I do think that when you actually look at the code, sometimes I get a little bit of a heart attack because it's not super amazing code necessarily all the time and it's very bloated and there's a lot of copy-paste and there's awkward abstractions that are brittle and it works but it's just really gross. I do hope that this can improve in future models. A good example is the micro GPT project where I was trying to simplify LLM training to be as simple as possible. The models hate this. They can't do it. I kept trying to prompt an LLM to simplify more, simplify more, and it just can't. You feel like you're outside of the RL circuits. It feels like you're pulling teeth. It's not like light speed. So I think people still remain in charge of this, but I do think that there's nothing fundamental preventing it. It's just the labs haven't done it yet.

我想回到这个关于锯齿状智能形式的概念。你在一篇关于动物与鬼魂的非常发人深省的文章中写过这个。这个想法是，我们不是在建造动物。我们是在召唤鬼魂。这些是锯齿状的智能形式，由数据和奖励函数塑造，而不是由内在动机、乐趣、好奇心或赋权塑造——这些是通过进化产生的东西。为什么这个框架很重要？它实际上如何改变你构建、部署、评估甚至信任它们的方式？

I'd love to come back to this idea of jagged forms of intelligence. You wrote a little bit about this with a very thought-provoking piece around animals versus ghosts. The idea is that we're not building animals. We are summoning ghosts. These are jagged forms of intelligence that are shaped by data and reward functions, but not by intrinsic motivation or fun or curiosity or empowerment, things that came about via evolution. Why does that framing matter? And what does it actually change about how you build and deploy and evaluate or even trust them?

是的，我写这个的原因是我想理解这些东西是什么。如果你对它们是什么或不是什么有一个好的模型，那么你使用它们时会更有能力。我不知道它是否有真正的力量。我认为这有点哲学化。但我确实认为这只是接受一个事实：这些东西不是动物智能。如果你对它们大喊大叫，它们不会工作得更好或更差，没有任何影响。它们只是这些统计模拟回路，其基础是预训练，所以是统计学。

Yes, I think the reason I wrote about this is I'm trying to wrap my head around what these things are. If you have a good model of what they are or are not, then you're going to be more competent at using them. I don't know if it has real power. I think it's a little bit of philosophizing. But I do think it's just coming to terms with the fact that these things are not animal intelligences. If you yell at them, they're not going to work better or worse or it doesn't have any impact. It's all just these statistical simulation circuits where the substrate is pre-training, so statistics.

好的，你深入研究的智能体不仅仅是聊天。它们拥有真实权限、本地联系人，实际上能代表你采取行动。当我们都开始生活在那个世界里时，世界会是什么样子？

Okay, so you are so deep in working with agents that don't just chat. They have real permissions. They have local contacts. They actually take action on your behalf. What does the world look like when we all start to live in that world?

是的，我想在座很多人对智能体式、原生的智能体环境的样子感到兴奋，一切都需要重写。一切仍然从根本上是为人类设计的，需要调整。我大部分时间使用不同的框架或库时，它们的文档仍然是为人写的。这是我最喜欢吐槽的点。为什么人们还在告诉我该做什么？我什么都不想做。我应该复制粘贴什么给我的智能体？所以每次有人告诉我，去这个 URL 之类的，我就觉得烦。所以我认为大家都兴奋于如何将需要完成的工作负载分解为世界上的传感器和执行器。如何让它成为智能体原生？基本上先向智能体描述。然后我在数据结构上做了很多自动化，这些数据结构对 LLM 非常易读。所以我希望有很多智能体优先的基础设施。比如 MenuGen，当我写那篇博客文章时，很多麻烦甚至不是写 MenuGen 的代码，而是部署在 Vercel 上，因为我必须处理各种不同的服务，把它们串起来，去设置菜单，配置 DNS，非常烦人。所以这是一个很好的例子，我希望我能给 LLM 一个提示，构建 MenuGen，然后我什么都不用碰，它就能以同样的方式部署在互联网上。我认为这是检验我们的基础设施是否越来越智能体原生的好测试。最终，我认为我们正走向一个世界，人和组织都有智能体代表，我的智能体会和你的智能体交谈，安排会议细节等。所以我认为大致方向如此，在座各位应该都很兴奋。

Yeah, I think a lot of people probably here are excited about what this agentic, you know, native agentic environment looks like and everything has to be rewritten. Everything is still fundamentally written for humans and has to be moved around. I still use most of the time when I use different frameworks or libraries or things like that. They still have docs that are fundamentally written for humans. This is my favorite pet peeve. Like I don't, why are people still telling me what to do? Like I don't want to do anything. What is the thing I should copy paste to my agent? So it's just every time I'm told, you know, go to this URL or something like that. It's just like ah. So everyone is I think excited about how do we decompose the workloads that need to happen into fundamentally sensors over the world, actuators over the world. How do we make it agent native? Basically describe it to agents first. And then I have a lot of automation around you know, the yeah, around data structures that are very legible to the LLMs. So I think yeah, I'm hoping that there's a lot of agent first infrastructure out there and that you know, for MenuGen famously when I wrote the not I'm not sure how famously, but when I wrote the blog post about MenuGen a lot of the work a lot of the trouble was not even writing the code for MenuGen. It was deploying it on Vercel because I had to work with all these different services and I just string them up and I just go to their settings and the menus, and you know, configure my DNS, and it was just so annoying. And so, that's a good example of I would hope that MenuGen that I could give a prompt to an LLM, build MenuGen, and then I didn't have to touch anything, and it's deployed in that same way on the internet. I think that would be a good kind of a test for whether or not a lot of our infrastructure is becoming more and more agent native. And then ultimately, I would say yeah, I do think we're going towards a world where there's agent representation for people and for organizations, and um you know, I'll have my agent talk to your agent to figure out some of the details of our meetings or things like that. So, I do think that that's roughly where things are going, but yeah, I think everyone here is excited about that.

我真的很喜欢传感器和执行器的视觉类比。我之前没想到过，这非常有趣。

I really like the visual analogy of sensors and actuators. I actually hadn't thought of that. That's super interesting.

好的，我想我们得用一个关于教育的问题来结束，因为你可能是世界上最擅长将复杂技术概念简单化，并对如何设计教育有深刻思考的人之一。当我们进入 AI 的下一个时代，智能变得廉价时，还有什么值得深入学习？

Okay, I think we have to end on a question about education, because you are probably one of the very best in the world at making complex technical concepts simple and deeply thoughtful about how we design education around it. What still remains worth learning deeply when intelligence gets cheap as we move into the next era of AI?

是的。最近有一条推文让我震惊，我几乎每天都会想起它。大意是：你可以外包思考，但不能外包理解。我觉得说得非常好。因为我仍然是系统的一部分，信息仍然需要进入我的大脑，我感觉自己成了瓶颈，甚至不知道我们在构建什么、为什么值得做、如何指导我的智能体等等。所以我仍然认为最终必须有东西来指导思考和处理，而这在根本上仍然受限于理解。这也是我对知识库非常兴奋的原因之一，因为我觉得那是我处理信息的一种方式。每当我看到信息的不同投影，我总是觉得获得了洞见。所以这其实只是我针对固定数据进行合成数据生成的大量提示。我非常享受每次读文章时，我的维基百科从这些文章中构建起来。我喜欢提问，我认为这些工具在某种程度上是增强理解的手段。这仍然是一个瓶颈，因为如果你不理解，你就无法很好地指导，因为 LLM 当然不擅长理解。你仍然独特地负责理解。所以，我认为这方面的工具非常有趣和令人兴奋。我很期待几年后回到这里，看看我们是否已经完全自动化，它们是否也负责理解。非常感谢你加入我们，Andre。我们真的很感激。

Yeah. There was a tweet that blew my mind recently, and I keep thinking about it like every other day. It was something along the lines of you can outsource your thinking, but you can't outsource your understanding. And I think that's really nicely put. Because I still I'm still part of the system, and I still have to somehow information still has to make it into my brain, and I feel like I'm becoming a bottleneck of just even knowing what we're trying to build, why is it worth doing, how do I direct my agents, and so on. So, I do still think that ultimately something has to direct the thinking and the processing, and so on. And that's still kind of fundamentally constrained somehow by understanding. And this is one reason I also was very excited about all the knowledge bases because I feel like that's a way for me to process information. And anytime I see a different projection onto information, I always feel like I gain insight. So, it's really just a lot of prompts for me to do synthetic data generation kind of over some fixed data. So, I really enjoy whenever I read an article, I have my wiki that's being built up from these articles. And I love asking questions about things and I think that ultimately these are tools to enhance understanding in a certain way. And this is still kind of like a bit of a bottleneck because then you can't direct the you can't be a good director if you still because the LLMs certainly don't excel at understanding. You still are uniquely in charge of that. So, yeah, I think tools to that effect I think are incredibly interesting and exciting. I'm excited to be back here in a couple years and to see if we've been fully automated out of the loop and they actually take care of understanding as well. Thank you so much for joining us, Andre. We really appreciate it.