Andrej Karpathy: From Vibe Coding to Agentic Engineering
频道: Sequoia Capital
视频: https://www.youtube.com/watch?v=96jN2OCOfLs
原文语言: en
统计: 共 22 轮
[0:02]
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. Um can you help us unpack that? Was that feeling exhilarating or unsettling? Uh yeah, mixture of both for sure. Uh well, first of all, um I guess like as many of you I've been using agentic tools like Alpha code adjacent things uh for a while, maybe over the last year as it came out. And it was very good at, you know, 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 uh clear point where for me uh I was on a break, so I had a bit more time. I think many other people were similar. And uh I just start to notice that with the latest models uh 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 was I just uh you know, trusted the system more and more. And then I was vibe coding.
我们非常激动地迎来第一位特邀嘉宾。他参与构建了现代 AI，又向世人解释了现代 AI，偶尔还顺手给现代 AI 重新命名。他当年就在这间办公室里参与联合创办了 OpenAI，也是真正让 Tesla autopilot 跑起来的那个人。他有一种难得的天赋，能把最复杂的技术变革讲得既通俗易懂、又仿佛是历史的必然。大家都知道他去年创造了 vibe coding 这个词，但就在最近这几个月，他说了一件更让人吃惊的事——他说自己作为程序员，从来没有像现在这样感觉如此落后。我们今天就从这里聊起。Andrej，谢谢你来。嗯，大家好。我很高兴来到这里，那我们就开始吧。好的，就在几个月前你说，作为程序员你从来没有像现在这样感觉落后。从你这样的人嘴里听到这话挺让人意外的。嗯，能帮我们拆解一下这个感受吗？这种感觉是让人兴奋，还是让人不安？呃，是的，肯定是两种都有。嗯，首先呢，我想跟在座很多人一样，过去一段时间我一直在用各种 agentic 工具，类似 Alpha code 那一类的东西，差不多是过去这一年它们陆续出来之后开始用的。它在生成一段段代码这件事上已经做得很好了。有时候它会出错，你得自己去改，但总体上还是挺有帮助的。然后我想说，对我来说，去年十二月是一个明确的转折点——当时我在休假，所以有多一点时间。我想很多人也都是类似的情况。我开始注意到，用最新的这些模型，生成出来的那一段段代码就是没问题。然后我接着让它生成更多，结果还是没问题。然后我想不起来上一次去纠正它是什么时候了。再然后，我就越来越信任这套系统。然后我就开始 vibe coding 了。
[1:38]
[laughter]
[笑声]
[1:39]
And uh so it was kind of a I do think that it was a very stark transition. I think that a lot of people actually I tried to I tried to stress this on uh Twitter and or X because I think a lot of people experienced AI uh last year as ChatGPT adjacent thing, uh but you really had to look again, and you had to look as of December uh because things have changed fundamentally and uh especially on this like agentic coherent workflow that really started to actually work. Um and so I would say that um yeah, it was just that realization that really uh had me um go down the whole rabbit hole of just, you know, infinity side project. Uh my side projects folder is like extremely full with lots of random things and uh just I've been coding all the time. Uh so uh yeah, that kind of happened in December, I would say. And I was looking at the repercussions of that since. Um you've talked a lot about this idea of LLMs as a new computer. Um that it isn't just better software, it's a whole new computing paradigm. And um software 1.0 was explicit rules, software 2.0 was learned weights, software 3.0 is this. Um if that's actually true, what does a team build differently the day they actually believe this? Right. So uh yeah, exactly. So software 1.0 I'm writing code, software 2.0 I'm actually programming by creating data sets and training uh training neural networks. So the programming is kind of like arranging data sets 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 implicit basically implicitly because by training on the internet you have to multitask all the things that are in the data set. Uh these actually become kind of like a programmable computer in a certain sense. So software 3.0 is kind of about uh you know, 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 uh performing computation in the digital digital information space. So I guess um yeah, that's kind of the transition and I think there's a few examples of that really drove it home for me and maybe that might be instructive. Uh so for example, when you when Open Claw came out when you want to install Open Claw, you would expect that normally this is a bash bash script like a shell script. So, run the shell script to run uh to install OpenClaw. Um but the thing is that in order to target lots of different platforms and lots of different types of computers you might run an OpenClaw, uh this 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 is a copy-paste of a bunch of text that you're supposed to give to your agent. Uh so, basically it's it's a little skill of uh you know, 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 uh spell out, you know, all the individual details of that setup. The agent has its own intelligence that it packages up and then it kind of like follows the instructions and it looks at your environment, your computer, and it kind of like 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 like 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 uh example that comes to mind that is even more extreme than that is when I was building um MenuGen. So, MenuGen is this idea where you um 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. Uh usually I like 30% of the things I don't 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 I built coded this app that basically lets you upload a photo and it does all this stuff and it runs on Vercel and uh it basically re-renders the menu and it gives you like all the items and it gives you a picture that it uses an image um you know, generator uh for to basically OCR all the different titles, uh 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 is which blew my mind, which is literally just take your photo, give it to Gemini, and say use Nano Banana to overlay the the things onto the menu." Uh Uh and Nana 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 menu gen is spurious. It's working in the old paradigm that app shouldn't exist. Uh and uh yeah, the software 3.0 paradigm is a lot more kind of raw. It just um your neural network is 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 of the app in between. Um so, I think that people have to kind of like reframe, you know, not to work in the existing paradigm of what things existed and just think about it as a speed up of what exists. It's actually like new things are available now. And going back to your programming question, it's not even I think that's also an example of working in the in the old mindset because it's not just about programming and programming becoming faster. This is more general information processing that is automatable now. So, um it's not just even about code. So, previous code worked over a kind of like structured data, right? And uh you write code over structured data. But like for example with my LLM knowledge bases project, um uh basically you get LLMs to create wikis for your organization or for you in person, etc. This is not even a program. This is not something that could exist before because there was no 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 uh basically uh recompile them in a different way, and uh reorder them, and create something that is uh new and interesting uh as a reframing of the data. And so, these are new things that weren't possible. Uh and so, I think this is uh something that I keep trying to get back to as to not only what can we do that existed that is faster now, but I think there's new opportunities of just things that couldn't be possible before. And I almost think that that's more exciting. I love the menu gen progression and dichotomy that you laid out, and I think even I'm sure 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? Um
所以呢，我确实觉得这是一个非常明显的转变。我觉得其实很多人——我在 Twitter 上，或者说 X 上，努力想强调这一点——因为我觉得很多人在去年体验到的 AI，更多是像 ChatGPT 那一类的东西，但你真的需要再重新看一眼，而且你得是从十二月这个时间点去看，因为情况已经发生了根本性的变化，尤其是在这种 agentic 的、连贯的工作流上，它真的开始能跑通了。所以我想说，对，正是这种意识让我一头扎进了无穷无尽的副项目这个兔子洞里。我的副项目文件夹现在塞得满满的，里面全是各种乱七八糟的东西，我就是一直在写代码。所以呢，那个转变大概就是在十二月发生的，我会这么说。从那以后我一直在观察它带来的连锁反应。你谈过很多关于「把 LLM 当作一种新型计算机」的想法。它不只是更好的软件，而是一整套全新的计算范式。软件 1.0 是显式的规则，软件 2.0 是学习到的权重，软件 3.0 就是现在这个。如果这真的成立，那一个团队在真正相信这一点的那天，他们会有哪些不同的做法？对，没错。所以软件 1.0 是我在写代码，软件 2.0 是我其实通过创建数据集、训练神经网络来「编程」。所以编程某种程度上变成了在组织安排数据集，可能再加上一些优化目标和神经网络架构。然后接下来发生的事情是，基本上，如果你在一组足够庞大的任务上训练这些 GPT 模型或者 LLM——本质上是隐式地训练，因为你在整个互联网上训练，就不得不同时处理数据集里所有的那些任务——这些模型在某种意义上其实就变成了一种可编程的计算机。所以软件 3.0 大致就是说，你的编程现在变成了写 prompt，而 context window 里的内容就是你操纵那个「解释器」的杠杆，这个解释器就是 LLM，它某种程度上在解释你的 context，并在数字信息空间里执行计算。所以我想，对，这大致就是这个转变。我觉得有几个例子真正让我对此有了切身的体会，也许讲出来会有启发。比如说，当 Open Claw 出来的时候，你想安装 Open Claw，按常理你会以为这是一个 bash 脚本，一个 shell 脚本。所以你运行这个 shell 脚本来安装 Open Claw。但问题是，为了能适配很多不同的平台、很多不同类型的电脑——你可能在各种环境下运行 Open Claw——这些 shell 脚本通常会越来越臃肿，变得极其复杂。但关键是，你仍然困在软件 1.0 的世界里，还想着要去写代码。而实际上 Open Claw 的安装方式，是把一大段文本复制粘贴出来，交给你的 agent。所以本质上它是一个小小的 skill——你知道的，把这段文本复制粘贴下来交给你的 agent，它就会帮你装好 Open Claw。这之所以强大得多，是因为你现在工作在软件 3.0 的范式里，你不必精确地把那套安装流程的每一个细节都一一写清楚。agent 有它自己的智能，它把这种智能打包起来，然后照着指令去做，它会去看你的环境、你的电脑，然后执行一系列智能的操作让事情跑起来，并在循环中自己调试问题。这就是强大得多，对吧？所以我觉得这是一种非常不同的思考方式。它就变成了：要复制粘贴给你 agent 的那段文本是什么？这才是现在的编程范式。我想再举一个例子，这个例子甚至比刚才那个更极端，那就是我在做 MenuGen 的时候。MenuGen 的想法是这样的：你去一家餐厅，他们给你一份菜单，通常上面没有图片，所以那些菜我根本不知道是什么。一般来说大概有 30% 的菜我完全不知道是什么，甚至 50%。所以我想给餐厅菜单拍张照片，然后大致看看这些东西可能长什么样。于是我就编写了这个 app，它基本上能让你上传一张照片，然后它做完所有这些处理，跑在 Vercel 上，它基本上会把菜单重新渲染一遍，给你列出所有菜品，并配上图片——它用一个图像生成器来做这件事，先把所有不同的菜名 OCR 出来，再用图像生成器生成对应的图片，然后展示给你看。然后我看到了这件事的软件 3.0 版本，它彻底震撼到我了：就是字面意义上的，拍下你的照片，把它交给 Gemini，然后说「用 Nano Banana 把这些东西叠加到菜单上」。然后 Nano Banana 基本上就返回了一张图，正好就是我拍的那张菜单的照片，但它真的把不同的菜品渲染进了像素里。这彻底震撼到我了，因为实际上我整个 MenuGen 都是多余的。它是在用旧范式工作，那个 app 根本就不该存在。对，软件 3.0 的范式要原始得多。它就是——你的神经网络承担越来越多的工作，你的 prompt 或者 context 就只是那张图片，输出也是一张图片，中间根本不需要有任何 app。所以我觉得，人们必须重新构建思路——不要老在「现有的东西」这个旧范式里工作，不要只把它当成对已有东西的加速。实际上，现在有了一些全新的可能。回到你刚才那个关于编程的问题，我觉得——它甚至不只是——我觉得那也是一个用旧思维方式工作的例子，因为这不只是编程、不只是编程变快了。这是一种更普遍的信息处理，现在变得可以自动化了。所以这甚至不只是关于代码。以前的代码是在某种结构化数据之上运作的，对吧？你在结构化数据之上写代码。但比如说，拿我那个 LLM 知识库项目来说，基本上你让 LLM 为你的组织、或者为你个人等等创建 wiki。这甚至不是一个程序。这是以前根本不可能存在的东西，因为以前根本没有那种「基于一堆事实去创建一个知识库」的代码。但现在你可以直接拿这些文档，把它们用另一种方式重新「编译」，重新排序，创造出一种全新的、有意思的东西，作为对这些数据的重新组织。所以这些是以前不可能实现的全新事物。所以我觉得这是我一直试图回到的点：不只是「现有的东西现在能做得更快了」，我觉得还有一些全新的机会，是一些以前根本不可能的东西。我甚至觉得那些更让人兴奋。我很喜欢你刚才描绘的 MenuGen 的演进过程和那种对比，我相信在座很多人也都关注过你自己从去年十月到今年一月、二月在编程上的演进。如果你把这条线再往后外推，2026 年的「相当物」会是什么——就像九十年代做网站、2010 年代做移动 app、上一个云时代做 SaaS 那样？有什么东西在事后看来会显得完全理所当然，但今天却基本还没人去做？嗯——
[8:09]
[clears throat]
[清嗓子]
[8:09]
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. Um I do think that the extrapolation looks very weird because you could basically imagine I don't think I Yeah, so you could imagine completely neural computers in a certain sense. Uh you feed a raw videos like imagine a device that takes raw videos or audio into basically what's a neural net and uses diffusion to render a UI that is kind of like, you know, unique for that moment in a certain sense. And um I kind of feel like in the early days of computing actually, people were a little bit confused as to whether computers would look like calculators or computers would look like neural nets. And in '50s and '60s, it was not really obvious which way would go. And of course, we went down the calculator path and ended up building classical computing and then neural nets are currently running virtualized on existing computers. But you could imagine I think that a lot of this will flip and that the neural net becomes kind of like the host process. And the CPUs become kind of like the co-processor. So, we saw the diagram of, you know, intelligence compute is going to neural networks is going to take over and become the dominant spend of flops. So, you could imagine something really weird and foreign when where neural nets are doing most of the heavy lifting, they're using tool use as just like, you know, historical appendage for some kinds of like deterministic tasks. But what's really running the show is these neural nets that are networked in a certain way. Um so, you can imagine something extremely foreign as the extrapolation, but I think we're going to probably get there sort of piece by piece. And I don't Yeah, I don't that that progression is TBD, I would say.
好吧，我想就还是顺着 MenuGen 这个例子来说。所以很多这样的代码本就不该存在，大部分活儿就是神经网络在干。我确实觉得这条外推线看起来非常奇怪，因为你基本上可以想象——我觉得我不——对，你可以想象某种意义上完全由神经的计算机。你给它喂原始视频之类的东西，想象有这么一个设备，它把原始视频或者音频输入到基本上是一个神经网络的东西里，然后用 diffusion 来渲染出一个 UI，这个 UI 某种意义上是为那个特定时刻而独一无二定制的。我有点觉得，其实在计算的早期，人们对于「计算机会长得像计算器、还是会长得像神经网络」是有些困惑的。在五十年代和六十年代，到底走哪条路并不真的那么明显。当然，最后我们走上了计算器那条路，最终构建出了经典计算，然后神经网络现在是虚拟化地跑在现有的计算机之上的。但你可以想象——我觉得这其中很多东西会反转过来，神经网络某种程度上变成了「宿主进程」，而 CPU 变成了某种「协处理器」。所以我们看到那张图——智能计算正在向神经网络转移，将会成为占主导地位的算力支出。所以你可以想象一种非常奇怪、非常陌生的东西：神经网络承担了大部分繁重的工作，它们把工具调用当作一种历史遗留的附属物，只用来处理某些确定性的任务。而真正在掌控全局的，是这些以某种方式互联起来的神经网络。所以你可以想象，作为外推的终点，是一种极其陌生的东西，但我觉得我们大概会一点一点地走到那里。我——对，我觉得那个演进过程还有待观察，我会这么说。
[9:40]
[snorts]
[轻笑]
[9:41]
I'd love to talk a little bit about um, uh, this concept of verifiability. The fact that AI will automate faster and more easily domains where the output can be verified. Um, 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? Uh, yes, so I I spent uh, some time writing about verifiability and um, basically like traditional computers can easily automate what you can specify in code. And uh, kind of this latest round of LLMs can easily automate what you can uh, verify in a certain in a certain sense. Uh, because the way this works is that when frontier labs are training these LLMs, these are giant reinforcement learning environments. So, they are given a verification rewards. And then because of the way that these models are trained, they end up basically uh, progressing and creating these like jagged entities that really peak in capability in kind of like verifiable domains like math and code and adjacent. And kind of like stagnate and are a little bit um, you know, rougher on the edges when uh, things are not kind of like in that in that space. So, I think the reason I wrote about verifiability is I'm trying to understand why these things are so jagged. Um, and some of it has to do with how the labs train the models, but I think some of it also has to do with um, the focus of the labs and what they happen to put into the data distribution. Uh, because some things basically are significantly more valuable in economy and end up creating more environments because the labs wanted to work in those settings. So, I think code is a good example of that. There's 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. Um, but I think to me the big um, I guess like the big mystery is uh, the favorite example for a while was that how many letters are are in a strawberry? And the models would famously get this wrong and it's an example of jaggedness. Uh, 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 m 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 like
我很想稍微聊一聊「可验证性」这个概念。也就是说，AI 会更快、更轻松地自动化那些「输出可以被验证」的领域。如果这个框架是对的，那么有哪些工作即将以人们没意识到的速度大大加快？又有哪些职业，大家其实以为是安全的，但实际上是高度可验证、因而很容易被自动化的？嗯，是的，我花了一些时间写关于可验证性的东西。基本上，传统的计算机可以轻松自动化那些你能用代码来明确指定的东西。而最近这一轮的 LLM，某种意义上可以轻松自动化那些你能去验证的东西。因为它的运作机制是这样的：当前沿实验室在训练这些 LLM 时，这些是巨大的强化学习环境。所以模型会得到一个验证型的奖励。然后因为这些模型被训练的方式，它们最终基本上会演化、形成这种参差不齐的「实体」，它们在那些可验证的领域——比如数学、代码以及相邻领域——能力会达到峰值，而在不属于那个空间的领域，能力就会停滞不前，边缘地带会显得比较粗糙、毛糙。所以我之所以写关于可验证性的文章，是因为我想搞明白，为什么这些东西如此参差不齐。其中一部分跟实验室如何训练模型有关，但我觉得也有一部分跟实验室的关注点、跟他们恰好往数据分布里放了什么有关。因为有些东西在经济上的价值明显高得多，最后就被构建出更多的训练环境，因为实验室想让模型在那些场景下能干活。我觉得代码就是一个很好的例子。可能还有大量可验证的环境是他们能想到的，但恰好没被纳入这个组合，因为让模型具备那些能力其实没那么有用。但我觉得对我来说，最大的——我想说是最大的谜团是——有一阵子大家最爱举的例子是：strawberry 这个词里有几个字母？模型曾经在这个问题上出尽洋相、答错，这就是参差不齐的一个例子。我想模型现在已经把这个补上了，但新的例子是：我想去洗车店洗车，洗车店在 50 米外，我应该开车去还是走路去？今天最先进的模型会告诉你走路去，因为太近了。怎么可能最先进的 Opus 4.7 一边能重构一个十万行级别的——
[11:47]
[laughter]
[笑声]
[11:47]
code base a line code base or find zero-day vulnerabilities and yet tells me to walk to this car wash? This is insane. And to whatever extent these models are remain jagged, it's an indication that number one, maybe something slightly off. Or number two, you need to actually be in the loop a little bit and you need to treat them as tools and you do have to kind of stay in touch with what they're doing. And so I think all of my writing, long story short, about verifiability is just trying to understand um why these things are jagged, is there any pattern to it? And I think it's a 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 it's more that I think this is public information, I think I saw it on the internet. Um a huge amount of like 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 which circuits you're in in your application. And if you 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. Um 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 uh is a domain that is verifiable, but you look around and you think, "Oh my gosh, well the labs have really really started uh got getting to escape velocity and the ones that seem most obvious, math, coding, and others." What would your advice be to to the founders in the audience? Um So, I think maybe that comes to the previous question of I do think that verifiability because it um Let me think. So, verifiability makes something tractable in the current paradigm because you can throw huge amount of RL at it. Um So, maybe one way to see it is that uh that remains true even if the labs are not focusing on it directly. So, if you are in a 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., uh you can use your favorite fine-tuning framework and um and uh pull the lever and get something that actually uh works pretty well. So, um I don't know what the examples of this might be. Um but I do think there are some very valuable uh 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 uh Oh, okay. Sorry. I don't mean to vague post on on the stage, but uh there are some examples of this. On the flip side, what do you think still feels automatable only from a distance? I do think that ultimately almost everything can be made uh verifiable to some extent, some things easier than others. Um because even for like things that are like writing or so on, you can imagine having a council of LLM judges and probably get get to some get something reasonable out of the from from this kind of an approach. So, it's more about what's easy or hard. Um So, I I do think that ultimately um Uh yeah, I think uh Everything.
——一个十万行的代码库，或者找出 zero-day 漏洞，结果却告诉我走路去这家洗车店？这太离谱了。而无论这些模型在多大程度上仍然参差不齐，这都是一个信号：第一，也许有什么地方稍微不太对劲；或者第二，你确实需要稍微留在循环里，你需要把它们当作工具来对待，你确实得跟它们正在做的事情保持联系。所以我觉得我所有关于可验证性的写作，长话短说，就是想搞明白为什么这些东西参差不齐，这背后有没有什么规律。我觉得它是某种组合——既要可验证，又要实验室在意。也许再讲一个有启发性的小故事：从 GPT-3.5 到 GPT-4，人们注意到下棋能力提升了很多，我想很多人会想，哦，这不过是能力整体进步的一部分。但实际上，更多是因为——我觉得这是公开信息，我记得是在网上看到的——大量的国际象棋数据进入了预训练集。仅仅因为它在数据分布里，模型的提升幅度就比默认情况下大得多。所以 OpenAI 有个人决定加入这部分数据，于是你就得到了一项能力，它的峰值就被显著抬高了。所以这就是为什么我一直强调这个维度——我们某种程度上是受实验室所做之事的摆布的，受他们恰好放进这个组合里的东西的摆布。你必须去探索他们给你的这个东西，它没有说明书，它在某些场景下能用，但也许在另一些场景下不行，你得自己稍微去摸索一下。如果你正好处在那些参与了 RL 训练的「电路」里，你就如鱼得水；如果你处在数据分布之外的电路里，你就会很吃力，你得搞清楚在你的应用里自己到底处在哪些电路上。如果你不在那些电路里，那你就真的得考虑做微调、做一些你自己的工作了，因为它不一定能开箱即用地从 LLM 里出来。我待会儿很想再回到「参差不齐的智能」这个概念。嗯，如果你今天是一位创业者，正在考虑创办一家公司，你想解决一个你认为是可解的问题，是一个属于可验证范畴的领域，但你环顾四周，你会想：「天哪，那些实验室已经真的、真的开始进入逃逸速度了，而它们看起来最显而易见的那些方向——数学、编程之类的。」你会给在座的创业者什么建议？嗯，我觉得这也许要回到刚才那个问题：我确实觉得，可验证性——因为它——让我想想。所以，可验证性在当前范式下让一件事变得可解，因为你可以朝它砸进海量的 RL。所以也许换个角度看，即便实验室没有直接关注它，这一点依然成立。所以如果你处在一个可验证的场景里，你能创建出这些 RL 环境或者样例，那这其实就为你自己做微调打下了基础，你可能会从中受益。但这从根本上说是一种「就是管用」的技术。你可以拉动一个杠杆。如果你有海量的、多样化的 RL 环境数据集等等，你就可以用你最喜欢的微调框架，拉动那个杠杆，得到一个其实效果相当不错的东西。所以，嗯，我不知道这方面具体的例子会是什么。但我确实觉得，有一些非常有价值的强化学习环境是人们可以想到的，我觉得它们还不属于——对，我不想直接把答案说出来，但有一个领域我觉得非常——哦，好吧，抱歉。我不是故意在台上说一些含含糊糊的话，但这方面确实是有一些例子的。反过来说，你觉得有什么东西仍然只是「远看像是可自动化」？我确实觉得，归根结底，几乎所有东西在某种程度上都可以被做成可验证的，只是有些比另一些容易。因为即便是像写作之类的东西，你也可以想象搞一个「LLM 评审委员会」，大概也能从这种方法里得到一些还算合理的结果。所以更多是关于「容易还是难」的问题。所以我确实觉得，归根结底——呃，对，我觉得——一切。
[15:42]
[laughter]
[笑声]
[15:43]
Everything is automatable. Amazing. Okay. Um 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? Uh 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 uh vulnerabilities due to vibe coding. Um you are um you're still responsible for your software just as before, but can you go faster? And spoiler is you can, but how do you how do you do that properly? And so, to me agentic engineering when I I call it that because I do think it's kind of like an engineering discipline. You have these agents which are these like spiky entities, they're a bit fallible, a little bit stochastic, but they are extremely powerful. And it's how do you how do you coordinate them to go faster without sacrificing your quality bar? And doing that well and correctly um is the the realm of agentic engineering. Um so, I kind of see them as as different. Like one is about maybe raising the raising the floor, and the other is about um you know, extrapolating. And what I'm seeing I think is there is a very high ceiling on agent engineer uh capability. And you know, people used to talk about the 10x engineer previously. I think that this is uh magnified a lot more. Uh 10x is uh is not uh the speed up you gain. Um and I think uh it does seem to me like people who are very good at this um peak a lot more than 10x uh from from my perspective right now. I really like that framing. Um 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, cloud code, codex, one you'd consider mediocre at it and one you would consider fully AI native, how would you describe the difference? I [clears throat] 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 you know, cloud code or codex or so on. So, um just investing into your setup and utilizing a lot of the, you know, tools that are available to you. Um and I think it just kind of looks like that. I do think that maybe related thought is um a lot of people are maybe hiring for this, right? Because they want to hire strong agentic engineers. I do think that what I'm seeing is that the, you know, most people are still not refactored their their hiring process for agentic engineer capability, right? Like if you're giving out puzzles to solve, then this is still the old paradigm. I would say that hiring have to has to look like give me a really big project and see someone implement that big project. Like let's write, say a Twitter clone for agents and then make it really good, make it really secure, and then have some agents simulate some activity on this Twitter. And then I'm going to use 10 codex 5.4 x high to try to break your break your this website that you deployed and they're going to try to basically break it and they should not be able to break it. And so maybe it looks like that, right? And so yeah, watching people in that that setting and building some bigger projects and utilize 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? Also, yeah, it's a good question. I think um Well, right now the answer is that the agents are catalog these internal entities, right? So it's remarkable um you basically still have to be in charge of the aesthetics, the the judgment, the taste, and a little bit of oversight. And maybe one one of my favorite examples of like the the weirdness of agents is um for menu gen, you sign up with a Google Google account, but you purchase credits using a Stripe account and both of them have email addresses. And my agent actually tries to basically um like when you purchase credits, it assigned it using the email address from Stripe to the Google email address. Like there wasn't a persistent user ID that that for people. It was trying to match up the email addresses, but you could use different email address for your Stripe and your Google and basically would not associate the funds. And so this is the kind of thing that these agents still will make mistakes about. It's like why would you use email addresses to try to cross-correlate the funds? They can be arbitrary. You can use different emails, etc. Like this is such a weird thing to do. So I think people have to be in charge of this spec, this plan, and actually don't even like the plan mode. I would I mean, 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 and maybe it's a maybe basically the docs and then get the agents to write them. And you're in charge of the oversight and the top-level categories, but the agents are doing a lot of the under the hood. And so I think you're not caring about some of the details. So as an example also with um, a race or tensors in neural networks, um, there's a ton of details between PyTorch and NumPy and all the different like pandas and so on for all the different little API details. And I'll I already forgot about the keep dims versus keep dim or whether it's dim or axis or reshape or permute or transpose. I don't remember this stuff anymore, right? Because you don't have to. This is the kind of details that are handled by the intern because they have very good recall. And but you still have to know for example that um, you know, there's underlying tensor, there's an underlying view and then you can view of the same storage or you can have different storage which will be less efficient. As we still have to have an understanding of what this stuff is doing and some of the fundamentals um, so that you're not copying memory around unnecessarily and so on. But uh, the details of the APIs are now handed off. So it um, you're in charge of the taste, the engineering, the design uh, and that it makes sense and that you're asking for the right things and that you're saying that okay, that these have to be unique user IDs that we're going to tie everything to. Um, and so you're doing some of the design and development and the engineers are doing the fill in the blanks. And that's currently kind of like where we are and I think that's what everyone of course is seeing I think right now. Do you think there's a chance that this um, taste and judgment matters less over time or will the ceiling just keep rising? Um, yeah, it's a good question. I would say um, I mean I'm hoping that the 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 or something like that. Um, 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 like 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 like it works but it's just really gross. Um, and I do I do hope that this can improve in future models. Um, a good example also is this uh, you know, the micro GPT project uh, which where I was trying to simplify uh LLM training to be as simple as possible. The models hate this. They can't do it. I tried to I keep 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 it you're obviously, you know, you're pulling teeth. It's not like light speed. So, I think um I do think that people are still remain in charge of this, but I do think that there's nothing fundamental again that's preventing it. It's just the labs haven't done it yet almost. Yeah. So, I'd love to come back to this idea of uh jagged forms of intelligence. You wrote a little bit about this with uh very thought-provoking piece around animals versus ghosts. Um and the idea is that we're not building animals. We are summoning ghosts. Um and 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, uh things that kind of came about via evolution. Um why does that framing matter? And what does it actually change about how you build and deploy and evaluate or even trust them? Uh yes, so Yeah, I think the reason I wrote about this is because I'm trying to wrap my head around what these things are, right? Because if you have a good model of what they are or are not, then you're going to be more competent at uh using them. Um and I do think that um I don't know if it has I'm not sure if it actually has like real power.
一切都是可自动化的。太精彩了。好的。嗯，去年你创造了 vibe coding 这个词，而今天我们身处的世界感觉稍微更严肃了一些，更偏向 agentic engineering（智能体工程）。你觉得这两者之间的区别是什么，你又会怎么称呼我们今天所处的阶段？呃，对，我会说，vibe coding 是关于为每个人抬高「下限」——抬高他们在软件上能做到的事情。所以下限抬升了，每个人都能 vibe code 出任何东西，这很了不起、很不可思议。但接下来我会说，agentic engineering 是关于守住「质量标准」——守住此前专业软件所具备的那个质量底线。所以你不能因为 vibe coding 就引入漏洞。你仍然要像以前一样对你的软件负责，但你能不能做得更快？剧透一下：你能，但你要怎么正确地做到这一点？所以对我来说，我之所以把它叫做 agentic engineering，是因为我确实觉得它有点像一门工程学科。你有这些 agent，它们是这种参差不齐、带尖刺的实体，它们有点容易犯错、有点随机，但它们极其强大。问题就是：你要怎么协调它们，让你跑得更快，同时不牺牲你的质量标准？把这件事做好、做对，就是 agentic engineering 的领域。所以我多少把它们看作不同的两件事。一个也许是关于抬高下限，另一个是关于——你知道的——向上外推。而我看到的是，我觉得 agentic engineering 的能力上限非常高。你知道，人们以前常说「10 倍工程师」。我觉得现在这个倍数被放大了很多。10 倍并不是你能获得的加速幅度。我觉得，在我现在看来，那些非常擅长这件事的人，他们达到的峰值要远远超过 10 倍。我很喜欢这个说法。嗯，有一件事——去年 Sam Altman 来 AI Ascent 的时候，他说过一句让人印象深刻的话：不同代际的人使用 ChatGPT 的方式不一样。如果你三十多岁，你会把它当成 Google 搜索的替代品；但如果你是青少年，ChatGPT 就是你通往互联网的入口。那么在今天的编程领域，对应的情况是什么？如果我们看两个人用 Open Claw、Claude Code、Codex 来写代码，一个你会觉得他用得比较平庸，另一个你会觉得他是完全的「AI 原生」，你会怎么描述这两者的区别？我——[清嗓子]——我觉得，无非就是努力把手头可用的工具用到极致，把它们的所有功能都利用起来，并且在自己的那套环境配置上投入精力。所以，就跟以前一样，所有工程师都习惯于把自己用的工具用到极致，不管它是 Vim 还是 VS Code，还是现在的 Claude Code、Codex 之类的。所以，嗯，就是在自己的配置上投入精力，并大量利用你手头可用的那些工具。我觉得它大概就是那个样子。我觉得，也许一个相关的想法是，现在很多人在为这个招人，对吧？因为他们想招到强大的 agentic engineer。我确实觉得，我看到的情况是，大多数人其实还没有为「agentic engineer 能力」重构他们的招聘流程，对吧？比如你还在出谜题让人解，那这还是旧范式。我会说，招聘得变成这样：给我一个非常大的项目，看一个人怎么去实现这个大项目。比如我们来写一个「给 agent 用的 Twitter 克隆」，然后把它做得非常好、非常安全，再让一些 agent 在这个 Twitter 上模拟一些活动。然后我会用 10 个 Codex 5.4 x high 去尝试攻破你部署的这个网站，它们会试图把它攻破，而它们应该攻不破。所以也许它看起来就是那个样子，对吧？所以对，看人在那种场景下、构建一些更大的项目、并把工具用起来，这大概就是我大部分情况下会去看的东西。随着 agent 做的事情越来越多，你觉得有哪种人类技能会变得更有价值，而不是更没价值？嗯，对，这是个好问题。我觉得——嗯，现在的答案是，agent 是那种「目录式」的内部实体，对吧？所以很了不起的是，你基本上仍然得负责审美、判断、品味，再加上一点监督。也许我最喜欢的、能体现 agent 古怪之处的例子之一就是：在 MenuGen 里，你用 Google 账号注册，但你用 Stripe 账号购买额度，这两个账号都有邮箱地址。我的 agent 实际上会试图——比如当你购买额度时，它会用 Stripe 那边的邮箱地址去把这笔额度关联到 Google 邮箱上。也就是说，并没有一个持久的用户 ID 来标识用户。它试图用邮箱地址去做匹配，但你的 Stripe 和 Google 完全可以用不同的邮箱，于是它基本上就没法把这笔钱关联上。所以这就是这类 agent 仍然会犯错的那种事。就是——你为什么要用邮箱地址去交叉关联资金呢？邮箱可以是任意的。你可以用不同的邮箱等等。这种做法太奇怪了。所以我觉得，人必须负责掌控这个 spec、这个计划——其实我甚至不太喜欢 plan mode。我是说，它显然很有用，但我觉得这里有一个更普遍的东西：你必须和你的 agent 一起协作，去设计一份非常详细的 spec，也许它基本上就是文档，然后让 agent 去把它实现出来。你负责监督和那些顶层的分类，而 agent 在底层做大量的活。所以我觉得，你不再去操心其中一些细节。再举个例子，比如神经网络里的张量之类的，PyTorch 和 NumPy、还有各种各样的 pandas 等等之间有海量的细节，所有那些不同的小小 API 细节。我已经忘了到底是 keep dims 还是 keep dim，到底是 dim 还是 axis，是 reshape 还是 permute 还是 transpose。我已经不记得这些东西了，对吧？因为你不需要记了。这种细节是交给「实习生」去处理的，因为它们的记忆力非常好。但你仍然需要知道，比如说，底层有一个张量、有一个底层的视图，你可以创建同一块存储的不同视图，也可以让它们用不同的存储——而那样会效率更低。我们仍然需要理解这些东西在做什么，理解一些基本原理，这样你才不会不必要地把内存搬来搬去之类的。但 API 的那些细节现在可以交出去了。所以，嗯，你负责的是品味、工程、设计——确保它说得通，确保你提出的是正确的要求，确保你说清楚「好，这些必须是唯一的用户 ID，我们要把所有东西都绑在它上面」。所以你做的是一部分设计和开发，而工程师们做的是「填空」。这大致就是我们现在所处的位置，我觉得这也是现在每个人当然都在看到的情况。你觉得有没有可能，随着时间推移，这种品味和判断会变得没那么重要，还是说上限会一直不断抬高？嗯，对，这是个好问题。我会说——嗯，我是希望它会变好的。我觉得它现在之所以没变好，原因还是同一个：它不是 RL 的一部分。大概没有什么「审美」的代价或者奖励，或者说还不够好，或者类似这样的原因。我确实觉得，当你真正去看那些代码的时候，有时候我会有点心脏病发作的感觉，因为它并不总是那种超级惊艳的代码，它非常臃肿，有大量的复制粘贴，还有一些笨拙、脆弱的抽象，它能用，但就是真的很难看。我确实希望这一点能在未来的模型里得到改善。一个很好的例子也是那个 micro GPT 项目，在那个项目里我想把 LLM 训练简化到尽可能简单。模型很讨厌这件事。它们做不到。我试着——我一直、一直试图 prompt 一个 LLM 让它再简化一点、再简化一点，它就是做不到。你会感觉自己处在 RL 的电路之外。那种感觉就是——很明显，你知道的，你是在「拔牙」。它不像光速那样顺畅。所以我觉得，我确实认为人现在仍然掌控着这件事，但我也确实觉得，同样地，没有什么根本性的东西在阻止它变好。几乎就是实验室还没去做这件事而已。对。所以我很想回到这个关于「参差不齐形态的智能」的想法。你写过一点关于这个的东西，在那篇很发人深省的文章里，关于「动物 vs 幽灵」。这个想法是说，我们不是在构建动物。我们是在召唤幽灵。这些是参差不齐形态的智能，它们是由数据和奖励函数塑造的，而不是由内在动机、乐趣、好奇心或者掌控感所塑造——而后面这些东西某种程度上是通过进化产生的。为什么这个框架很重要？它实际上会改变你构建、部署、评估、甚至信任它们的方式吗？呃，是的，所以——对，我觉得我之所以写这个，是因为我想搞清楚这些东西到底是什么，对吧？因为如果你对它们「是什么、不是什么」有一个好的模型，那你在使用它们的时候就会更有胜任力。我确实觉得，嗯，我不知道它是不是有——我不确定它实际上是不是真的有什么实在的「威力」。
[24:27]
[laughter]
[笑声]
[24:28]
I think it's a little bit of philosophizing. But I do think that um I think it's just um coming to terms with the fact that these things are not, you know, animal intelligences. Like if you yell at them, they're not going to work better or or worse or it doesn't have any impact. Um and uh it's all just kind of like these statistical simulation circuits where the the substrate is pre-training, so like statistics. And then but then there's RL bolting on top, so it kind of like increases the disadvantages and um maybe it's just kind of like a mindset of what I'm coming into or what's likely to work or not likely to work or how to modify it, but I don't actually I don't know that I have like here are the five obvious outcomes of how to make your system better. It's more just being suspicious of it and um figuring out over time. That's where it starts. 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 your behalf. What does the world look like when we all start to live in that world? Yeah, I think 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?
我觉得这里面有点哲学思辨的味道。但我确实认为，这其实就是要接受一个事实：这些东西不是动物智能。比如你冲它们吼，它们不会因此干得更好，也不会更差，根本没有任何影响。它们其实就是一堆统计性的模拟电路，底层是预训练，也就是统计；然后在这之上又栓上了 RL，这某种程度上放大了一些劣势。也许这只是我进入这件事时的一种心态，或者说我对什么大概率管用、什么大概率不管用、该怎么去调整它的一种判断。但其实我并没有一份现成的清单，说『这是让你的系统变好的五个明显办法』。更多的是对它保持一种警惕，然后随着时间慢慢摸索出来。一切就是从这里开始的。好，那么你已经深入到和智能体打交道的程度了——这些智能体不只是聊天，它们有真实的权限，有本地的上下文，它们真的会代表你去采取行动。当我们都开始生活在那样一个世界里时，世界会变成什么样子？是的，我想在座的很多人大概都对这种 agent native（智能体原生）的环境长什么样感到兴奋——所有东西都得重写。如今一切东西从根本上还是为人类写的，都得被重新折腾一遍。我大多数时候用各种框架、库之类的东西，它们的文档从根本上还是写给人类看的。这是我最受不了的一点。我老想说：为什么人们还在告诉我该怎么做？我什么都不想做。我该把哪段东西复制粘贴给我的智能体？
[26:00]
[laughter]
[笑声]
[26:01]
So it's just every time I'm told, you know, go to this URL or something like that. It's just like ah.
所以每次有人跟我说『去访问这个 URL』之类的，我都只想叹气：唉。
[26:06]
[laughter]
[笑声]
[26:07]
You know.
你懂的。
[26:08]
[snorts]
[轻笑]
[26:08]
So um 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. Um 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 [laughter] 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 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,
所以我觉得，每个人都对这件事感到兴奋：我们该怎么把那些需要完成的工作负载，从根本上拆解成对世界的传感器、对世界的执行器。我们怎么让它变成 agent native（智能体原生）？基本上就是先把它描述给智能体听。然后我自己也搭了很多自动化，围绕那些对 LLM 来说非常易读的数据结构。所以我真的希望外面能有大量 agent first（智能体优先）的基础设施。就拿 MenuGen 来说——很有名地……其实我不确定有多有名——但当我写那篇关于 MenuGen 的博客文章时 [笑声]，大量的工作、大量的麻烦，甚至都不是给 MenuGen 写代码本身。麻烦的是把它部署到 Vercel 上，因为我得跟一堆不同的服务打交道，我得把它们一个个串起来，进它们的设置页面，进那些菜单，配置我的 DNS，整个过程实在太烦人了。所以这是个很好的例子：我希望对于 MenuGen，我能给一个 LLM 一句 prompt，让它构建 MenuGen，然后我什么都不用碰，它就以同样的方式部署到互联网上了。我觉得这会是一个很好的测试，用来检验我们的基础设施是不是正变得越来越 agent native（智能体原生）。而最终，我确实认为我们正走向这样一个世界：人和组织都会有自己的智能体代表。你懂的，我会让我的智能体去和你的智能体对接，去敲定我们会面的一些细节之类的事情。所以，
[27:31]
[laughter]
[笑声]
[27:32]
um I do think that that's roughly where things are going, but um 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.
我确实觉得事情大致就是朝这个方向发展的。不过，是的，我想在座的每个人都对此感到兴奋。我真的很喜欢传感器与执行器这个形象的类比。我之前其实还真没想到过这个比喻，这太有意思了。
[27:42]
Right. Um okay, I think we have to end on a question about education, um 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. Um what still remains worth learning deeply when intelligence gets cheap as we move into the next era of AI? Yeah. Uh 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 um you can outsource your thinking, but you can't outsource your understanding. And um I think that's really nicely put. I so yeah, because I still I'm still part of the system, and I still 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, uh how do I direct you know, how do I direct my 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 um that's still kind of fundamentally constrained somehow by understanding. And this is one reason I also was very excited about all the all the knowledge bases because I feel like that's that's a way for me to process information. And anytime I see a different projection onto information, I always like feel like I gain insight. So, it's really just a lot of prompts for me to do synthetic data generation kind of over over some fixed data. Uh so, I I really enjoy uh whenever I read an article, I have my uh you know, my wiki that's being built up from these articles. And I love asking questions about things or um and I 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 uh you you can't be a good director if you still uh cuz the LLMs certainly don't excel at understanding. You still are uniquely in charge of that. So, uh yeah, I think uh 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. Uh thank you so much for joining us, Andre. We really appreciate it. [applause]
好。嗯，好，我想我们得以一个关于教育的问题来收尾，因为你大概是这个世界上最擅长把复杂的技术概念讲简单的人之一，而且你对我们该如何围绕它来设计教育有很深的思考。当我们进入 AI 的下一个时代、智能变得很廉价时，还有什么东西仍然值得我们去深入学习？是的。最近有一条推文让我大为震撼，我几乎每隔一天就会想起它。大意是这样的：你可以把你的思考外包出去，但你没法把你的理解外包出去。我觉得这话说得真好。是的，因为我仍然是这个系统的一部分，我仍然得让信息以某种方式进到我的大脑里。我感觉自己正在变成一个瓶颈——光是搞清楚我们到底想构建什么、为什么这事值得做、我该怎么去引导我的智能体等等，我就成了瓶颈。所以我确实仍然认为，归根结底总得有什么东西来引导这个思考和处理的过程。而这个东西从根本上某种程度上还是受限于『理解』。这也是我对所有这些知识库感到非常兴奋的一个原因，因为我觉得那是我处理信息的一种方式。每当我看到信息被投射出一个不同的视角时，我总会觉得自己获得了某种洞见。所以对我来说，这其实就是用大量的 prompt，针对一些固定的数据去做合成数据生成。每当我读一篇文章，我都会用上我自己的那个 wiki——它就是从这些文章里一点点搭建起来的。我很喜欢就某些东西提问。我觉得归根结底，这些都是用某种方式来增强『理解』的工具。而这一点仍然算是个瓶颈，因为如果你做不到理解，你就没法去引导，你就当不好一个『导演』——毕竟 LLM 在『理解』这件事上肯定不擅长。所以你仍然是这件事上独一无二的负责人。所以，是的，我觉得朝这个方向努力的工具非常有意思、非常令人兴奋。我很期待过几年再回到这里，看看我们是不是已经被彻底自动化、踢出了这个环路，而它们真的连『理解』也一并搞定了。非常感谢你来和我们对话，Andrej，我们真的非常感激。[掌声]