Andrej Karpathy: Software Is Changing (Again)

频道: Y Combinator
视频: https://www.youtube.com/watch?v=LCEmiRjPEtQ
原文语言: en
统计: 共 63 轮

[0:01]

Please welcome former director of AI Tesla Andre Carpathy. [Music] Hello. [Music] Wow, a lot of people here. Hello. Um, okay. Yeah. So I'm excited to be here today to talk to you about software in the era of AI. And I'm told that many of you are students like bachelors, masters, PhD and so on. And you're about to enter the industry. And I think it's actually like an extremely unique and very interesting time to enter the industry right now. And I think fundamentally the reason for that is that um software is changing uh again.

有请前 Tesla AI 总监 Andrej Karpathy。（音乐）大家好。（音乐）哇，今天来了好多人。大家好。嗯，好的。是这样，我今天非常高兴能来这里，跟大家聊聊 AI 时代下的软件。我听说你们当中很多人都还是学生——本科、硕士、博士之类的。你们正准备进入这个行业。我觉得现在其实是个特别特殊、特别有意思的入行时机。说到底，原因在于：软件，又一次在改变了。

[0:47]

And I say again because I actually gave this talk already. Um but the problem is that software keeps changing. So I actually have a lot of material to create new talks and I think it's changing quite fundamentally. I think roughly speaking software has not changed much on such a fundamental level for 70 years. And then it's changed I think about twice quite rapidly in the last few years. And so there's just a huge amount of work to do a huge amount of software to write and rewrite. So let's take a look at maybe the realm of software. So if we kind of think of this as like the map of software this is a really cool tool called map of GitHub.

我说「又一次」，是因为我其实之前就讲过这个题目了。但问题是，软件一直在变。所以我手上一直有新素材去做新的演讲，而且我觉得这次的变化相当根本。粗略地说，软件在这么底层的层面上，已经七十年没怎么变过了。然后在过去这几年里，它差不多以非常快的速度变了两次。所以现在有海量的活要干——海量的软件要写、要重写。那我们先来看看软件的版图吧。如果我们把这想象成一张软件地图，这是个特别酷的工具，叫 map of GitHub。

[1:20]

Um this is kind of like all the software that's written. Uh these are instructions to the computer for carrying out tasks in the digital space. So if you zoom in here, these are all different kinds of repositories and this is all the code that has been written. And a few years ago I kind of observed that um software was kind of changing and there was kind of like a new type of software around and I called this software 2.0 at the time and the idea here was that software 1.0 is the code you write for the computer. Software 2.0 know are basically neural networks and in particular the weights of a neural network and you're not writing this code directly you are most you are more kind of like tuning the data sets and then

嗯，这基本上就是所有写出来的软件。这些都是给计算机的指令，让它在数字世界里去完成各种任务。你放大来看，这些是各种各样的代码仓库，是人们写过的所有代码。几年前我就注意到，软件好像在发生变化，出现了一种新类型的软件，我当时把它叫做 Software 2.0。这个想法是：Software 1.0 是你为计算机写的代码；而 Software 2.0 基本上就是神经网络，尤其是神经网络的权重——你不是直接去写这些代码，更多的是在调数据集，

[1:56]

you're running an optimizer to create to create the parameters of this neural net and I think like at the time neural nets were kind of seen as like just a different kind of classifier like a decision tree or something like that and so I think it was kind of like um I think this framing was a lot more appropriate and now actually what we have is kind of like an equivalent of GitHub in the realm of software 2.0 And I think the hugging face is basically equivalent of GitHub in software 2.0.

然后跑一个优化器，去生成这个神经网络的参数。我觉得在当时，神经网络多少还被看作只是另一种分类器，跟决策树之类的东西差不多。所以我觉得，当时这个框架其实更贴切。而现在，在 Software 2.0 这个领域里，我们其实已经有了一个相当于 GitHub 的东西。我觉得 Hugging Face 在 Software 2.0 里基本上就等价于 GitHub。

[2:20]

And there's also model atlas and you can visualize all the code written there. In case you're curious, by the way, the giant circle, the point in the middle, uh these are the parameters of flux, the image generator. And so anytime someone tunes a on top of a flux model, you basically create a git commit uh in this space and uh you create a different kind of a image generator. So basically what we have is software 1.0 is the computer code that programs a computer. Software 2.0 are the weights which program neural networks. Uh and here's an example of Alexet image recognizer neural network.

还有一个叫 model atlas 的东西，你可以把那里写的所有「代码」都可视化出来。顺便说一句，如果你好奇的话，中间那个巨大的圆圈、那个点，是 flux 的参数——也就是那个图像生成器。所以每当有人在 flux 模型之上做微调，你基本上就在这个空间里产生了一次 git commit，造出了一种不一样的图像生成器。所以归根结底，Software 1.0 是给计算机编程的计算机代码，Software 2.0 是给神经网络编程的权重。这里就有个例子，AlexNet 这个图像识别神经网络。

[2:53]

Now so far all of the neural networks that we've been familiar with until recently where kind of like fixed function computers image to categories or something like that. And I think what's changed and I think is a quite fundamental change is that neural networks became programmable with large language models. And so I I see this as quite new, unique. It's a new kind of a computer and uh so in my mind it's uh worth giving it a new designation of software 3.0. And basically your prompts are now programs that program the LLM.

到目前为止，直到最近我们所熟悉的所有神经网络，基本上都像是固定功能的计算机——从图像到类别之类的。而我觉得已经发生改变的、而且是相当根本性的改变，是神经网络变得可编程了，靠的就是大语言模型。所以在我看来这是相当新、相当独特的——这是一种新型的计算机。所以在我心里，它值得有一个新的称呼：Software 3.0。本质上，你的 prompt 现在就是程序，是用来给 LLM 编程的程序。

[3:25]

And uh remarkably uh these uh prompts are written in English. So it's kind of a very interesting programming language. Um so maybe uh to summarize the difference if you're doing sentiment classification for example you can imagine writing some uh amount of Python to to basically do sentiment classification or you can train a neural net or you can prompt a large language model. Uh so here this is a few short prompt and you can imagine changing it and programming the computer in a slightly different way. So basically we have software 1.0 software 2.0 and I think we're seeing maybe you've seen a lot of GitHub code is not just like code anymore. there's a bunch of like English interspersed with code and so I think

而且很了不起的一点是，这些 prompt 是用英语写的。所以它是一种非常有意思的编程语言。嗯，也许我可以这样总结这几者的区别：比如你要做情感分类，你可以想象写一段 Python 来做情感分类，也可以训练一个神经网络，或者去 prompt 一个大语言模型。这里就是一个 few-shot 的 prompt，你可以想象改一改它，用一种稍微不同的方式去给计算机编程。所以基本上我们有了 Software 1.0、Software 2.0，而我觉得我们正在看到——也许你们也已经看到——很多 GitHub 上的代码已经不再只是代码了，里面夹杂着一堆英语和代码混在一起，所以我觉得

[4:05]

kind of there's a growing category of new kind of code. So not only is it a new programming paradigm, it's also remarkable to me that it's in our native language of English. And so when this blew my mind a few uh I guess years ago now I tweeted this and um I think it captured the attention of a lot of people and this is my currently pinned tweet uh is that remarkably we're now programming computers in English. Now, when I was at uh Tesla, um we were working on the uh autopilot and uh we were trying to get the car to drive and I sort of showed this slide at the time where you can imagine that the inputs to the car are on the bottom and they're going through a software stack to produce the steering and acceleration

正在冒出一类新的代码。所以这不仅仅是一种新的编程范式，让我觉得很了不起的是，它还是用我们的母语——英语来写的。所以几年前，当这件事让我大开眼界的时候，我发了这么一条推特，结果好像吸引了很多人的注意，这也是我现在的置顶推文：很了不起，我们现在是用英语在给计算机编程。话说回来，我在 Tesla 的时候，我们当时在做 Autopilot，想让车自己开起来。我当时展示过这样一张幻灯片：你可以想象，车的输入在最底下，它们经过一整套软件栈，最后产出转向和加速。

[4:47]

and I made the observation at the time that there was a ton of C++ code around in the autopilot which was the software 1.0 code and then there was some neural nets in there doing image recognition and uh I kind of observed that over time as we made the autopilot better basically the neural network grew in capability and size and in addition to that all the C++ code was being deleted and kind of like was um and a lot of the kind of capabilities and functionality that was originally written in 1.0 was migrated to 2.0. So as an example, a lot of the stitching up of information across images from the different cameras and across time was done by a neural network and we were able to delete a lot

我当时观察到，Autopilot 里有海量的 C++ 代码，那就是 Software 1.0 的代码；然后里面有一些神经网络在做图像识别。我注意到，随着时间推移，我们把 Autopilot 做得越来越好，基本上神经网络的能力和体量在不断增长，与此同时，那些 C++ 代码在被一点点删掉。很多原本用 1.0 写的能力和功能，逐渐迁移到了 2.0。举个例子，把不同摄像头之间、以及跨时间的图像信息「缝合」起来这件事，很多就交给了神经网络去做，于是我们得以删掉大量

[5:26]

of code and so the software 2.0 stack quite literally ate through the software stack of the autopilot. So I thought this was really remarkable at the time and I think we're seeing the same thing again where uh basically we have a new kind of software and it's eating through the stack. We have three completely different programming paradigms and I think if you're entering the industry it's a very good idea to be fluent in all of them because they all have slight pros and cons and you may want to program some functionality in 1.0 or 2.0 or 3.0. Are you going to train neurallet? Are you going to just prompt an LLM? Should this be a piece of code that's explicit etc. So we all have to make these decisions and actually

代码。所以 Software 2.0 这套栈，可以说是真真切切地把 Autopilot 的整个软件栈「吃」掉了。我当时觉得这件事特别了不起，而我觉得现在我们正在再一次见证同样的事情发生——我们有了一种新的软件，它正在一路吃穿整个软件栈。我们现在有三种完全不同的编程范式，我觉得如果你正要进入这个行业，最好对这三种都游刃有余，因为它们各有各的小优缺点。某个功能你可能想用 1.0 写，也可能用 2.0 或 3.0。你是要训练一个神经网络？还是直接 prompt 一个 LLM？这块该不该是一段显式写出来的代码？诸如此类。所以这些决策我们都得自己拿，而且实际上

[6:00]

potentially uh fluidly trans transition between these paradigms. So what I wanted to get into now is first I want to in the first part talk about LLMs and how to kind of like think of this new paradigm and the ecosystem and what that looks like. Uh like what are what is this new computer? What does it look like and what does the ecosystem look like? Um I was struck by this quote from Anduring actually uh many years ago now I think and I think Andrew is going to be speaking right after me. Uh but he said at the time AI is the new electricity and I do think that it um kind of captures something very interesting in that LLMs certainly feel like they have properties of utilities right now. So um LLM labs like OpenAI, Gemini,

我们还可能需要在这几种范式之间流畅地来回切换。那么接下来我想先讲的是——第一部分我想谈谈 LLM，谈谈该怎么去理解这个新范式、这个生态，以及它到底长什么样。这个新的计算机是什么？它是什么样子的？围绕它的生态又是什么样子的？我曾被 Andrew 的一句话打动——其实是很多年前了——我想 Andrew 待会儿就紧接着我上台。他当时说：AI 是新的电力（AI is the new electricity）。我确实觉得这句话抓住了某种非常有意思的东西，因为 LLM 现在确实给人一种公用事业（utility）的感觉。所以那些 LLM 实验室，像 OpenAI、Gemini、

[6:44]

Enthropic etc. They spend capex to train the LLMs and this is kind of equivalent to building out a grid and then there's opex to serve that intelligence over APIs to all of us and this is done through metered access where we pay per million tokens or something like that and we have a lot of demands that are very utility- like demands out of this API we demand low latency high uptime consistent quality etc. In electricity, you would have a transfer switch. So you can transfer your electricity source from like grid and solar or battery or generator. In LLM, we have maybe open router and easily switch between the different types of LLMs that exist.

Anthropic 等等，他们花大量的资本开支（capex）去训练 LLM，这就好比在搭建一张电网；然后还有运营开支（opex），通过 API 把这种智能输送给我们所有人，这是按计量收费的方式来做的——我们按每百万 token 之类的来付费。我们对这个 API 有很多非常「公用事业式」的诉求：我们要求低延迟、高可用、稳定的质量等等。在用电的场景里，你会有一个转换开关（transfer switch），让你能在电网、太阳能、电池、发电机之间切换电源。在 LLM 这边，我们大概有 OpenRouter 这样的东西，让你能在现有的各种 LLM 之间轻松切换。

[7:20]

Because the LLM are software, they don't compete for physical space. So it's okay to have basically like six electricity providers and you can switch between them, right? Because they don't compete in such a direct way. And I think what's also a little fascinating and we saw this in the last few days actually a lot of the LLMs went down and people were kind of like stuck and unable to work. And uh I think it's kind of fascinating to me that when the state-of-the-art LLMs go down, it's actually kind of like an intelligence brownout in the world.

因为 LLM 是软件，它们不争抢物理空间。所以基本上你完全可以有六家「供电商」，随时在它们之间切换，对吧？因为它们不会以那么直接的方式相互竞争。我觉得还有一点也挺耐人寻味的——其实就在过去这几天我们就见识到了——很多 LLM 都宕机了，大家一下子就卡住了，没法干活。我觉得很有意思的是，当那些最先进的 LLM 宕机时，那其实就像是全世界经历了一次「智能限电」（intelligence brownout）。

[7:47]

It's kind of like when the voltage is unreliable in the grid and uh the planet just gets dumber the more reliance we have on these models, which already is like really dramatic and I think will continue to grow. But LLM's don't only have properties of utilities. I think it's also fair to say that they have some properties of fabs. And the reason for this is that the capex required for building LLM is actually quite large. Uh it's not just like building some uh power station or something like that, right? You're investing a huge amount of money and I think the tech tree and uh for the technology is growing quite rapidly. So we're in a world where we have sort of deep tech trees, research and development secrets that are

就好比电网里的电压不稳，于是我们对这些模型越是依赖，整个地球就越是变笨——而这种依赖现在已经相当夸张了，我觉得还会继续加深。但 LLM 不只有公用事业的属性。我觉得也可以公允地说，它们还带有一些晶圆厂（fab）的属性。原因在于，建一个 LLM 所需要的资本开支其实相当庞大。这可不像是建个发电站之类的，对吧？你要砸进去巨额的资金，而且我觉得这项技术的「科技树」还在飞快地往上长。所以我们身处这样一个世界：有着相当深的科技树，研发的秘密都在

[8:28]

centralizing inside the LLM labs. Um and but I think the analogy muddies a little bit also because as I mentioned this is software and software is a bit less defensible because it is so malleable. And so um I think it's just an interesting kind of thing to think about potentially. There's many analogy analogies you can make like a 4 nanometer process node maybe is something like a cluster with certain max flops. You can think about when you're use when you're using Nvidia GPUs and you're only doing the software and you're not doing the hardware. That's kind of like the fabless model. But if you're actually also building your own hardware and you're training on TPUs if you're Google, that's kind of like the

向那些 LLM 实验室内部集中。不过我觉得这个类比也有点站不住脚的地方，因为正如我刚才说的，这是软件，而软件的护城河要弱一些——它太容易被改写、太有可塑性了。所以嗯，我觉得这只是个值得拿来琢磨一下的有意思的话题。你能做出很多类比，比如说 4 纳米的制程节点，也许就对应着某个有特定算力上限的集群。你可以这么想：当你在用 Nvidia 的 GPU、只做软件而不碰硬件时，那有点像无晶圆厂（fabless）的模式。但如果你连自己的硬件也一起造、像 Google 那样在 TPU 上训练，那就有点像

[9:03]

Intel model where you own your fab. So I think there's some analogies here that make sense. But actually I think the analogy that makes the most sense perhaps is that in my mind LLM have very strong kind of analogies to operating systems. Uh in that this is not just electricity or water. It's not something that comes out of the tap as a commodity. uh this is these are now increasingly complex software ecosystems right so uh they're not just like simple commodities like electricity and it's kind of interesting to me that the ecosystem is shaping in a very similar kind of way where you have a few closed source providers like Windows or Mac OS and then you have an open source alternative like Linux and I think for u

Intel 那种模式——你拥有自己的晶圆厂。所以我觉得这里有些类比是说得通的。但其实在我看来，最说得通的类比也许是：LLM 跟操作系统有非常强的相似性。也就是说，这不只是电、不只是水，不是那种从水龙头里流出来的大宗商品。这些东西现在越来越像是复杂的软件生态系统，对吧？所以它们不是电力那种简单的大宗商品。而让我觉得有意思的是，这个生态正在以一种非常相似的方式成形：你有几家闭源的提供方，就像 Windows 或 macOS；然后你有一个开源的替代品，就像 Linux。我觉得对于嗯

[9:42]

neural for LLMs as well we have a kind of a few competing closed source providers and then maybe the llama ecosystem is currently like maybe a close approximation to something that may grow into something like Linux. Again, I think it's still very early because these are just simple LLMs, but we're starting to see that these are going to get a lot more complicated. It's not just about the LLM itself. It's about all the tool use and the multiodalities and how all of that works. And so when I sort of had this realization a while back, I tried to sketch it out and it kind of seemed to me like LLMs are kind of like a new operating system, right? So the LLM is a new kind of a computer. It's sitting

对 LLM 来说也类似，我们现在有几家相互竞争的闭源提供商，然后 llama 这套生态大概是目前最接近、有可能成长为某种 Linux 那样东西的候选。不过我还是觉得现在非常早期，因为这些都还只是简单的 LLM，但我们已经开始看到它们会变得复杂得多。重点不只是 LLM 本身，还有所有的 tool use、多模态，以及这一切是怎么协同工作的。所以当我之前有了这个领悟之后，我试着把它画出来，在我看来 LLM 有点像是一种新型的 operating system，对吧？所以 LLM 是一种新型的计算机。它坐在那里——

[10:17]

it's kind of like the CPU equivalent. uh the context windows are kind of like the memory and then the LLM is orchestrating memory and compute uh for problem solving um using all of these uh capabilities here and so definitely if you look at it looks very much like operating system from that perspective. Um, a few more analogies. For example, if you want to download an app, say I go to VS Code and I go to download, you can download VS Code and you can run it on Windows, Linux or or Mac in the same way as you can take an LLM app like cursor and you can run it on GPT or cloud or Gemini series, right? It's just a drop down. So, it's kind of like similar in that way as well.

它有点像是 CPU 的对应物。context window 有点像内存，然后 LLM 负责调度内存和算力来解决问题，用的就是这里这些能力。所以从这个角度看，它确实非常像一个 operating system。再举几个类比。比如说，如果你想下载一个 app，假设我去 VS Code 那里点下载，你可以下载 VS Code，然后在 Windows、Linux 或 Mac 上运行它；同样的道理，你可以拿一个 LLM app，比如 cursor，让它跑在 GPT、Claude 或 Gemini 系列上，对吧？就是一个下拉菜单的事。所以在这一点上也挺相似的。

[11:00]

uh more analogies that I think strike me is that we're kind of like in this 1960sish era where LLM compute is still very expensive for this new kind of a computer and that forces the LLMs to be centralized in the cloud and we're all just uh sort of thing clients that interact with it over the network and none of us have full utilization of these computers and therefore it makes sense to use time sharing where we're all just you know a dimension of the batch when they're running the computer in the cloud. And this is very much what computers used to look like at during this time. The operating systems were in the cloud. Everything was streamed around and there was batching. And so the p the personal computing revolution

还有一个让我印象很深的类比是，我们现在有点处在 1960 年代那种时期：对这种新型计算机来说，LLM 的算力还非常昂贵，这就迫使 LLM 必须集中部署在云端，而我们所有人都只是某种瘦客户端，通过网络去跟它交互，没有任何一个人能独占这些计算机的全部算力。因此采用分时（time sharing）就很合理——当它们在云端运行时，我们每个人只是这一批（batch）里的一个维度而已。这其实和那个年代的计算机非常像。operating system 都在云端，所有东西都是流式传输的，而且有 batching。所以个人计算革命——

[11:41]

hasn't happened yet because it's just not economical. It doesn't make sense. But I think some people are trying. And it turns out that Mac minis, for example, are a very good fit for some of the LLMs because it's all if you're doing batch one inference, this is all super memory bound. So this actually works. And uh I think these are some early indications maybe of personal computing. Uh but this hasn't really happened yet. It's not clear what this looks like. Maybe some of you get to invent what what this is or how it works or uh what this should what this should be. Maybe one more analogy that I'll mention is whenever I talk to Chach or some LLM directly in text, I feel like I'm talking to an operating system through

——还没有发生，因为它就是不划算，没有道理。不过我觉得有些人正在尝试。事实证明，比如 Mac mini，就非常适合跑某些 LLM，因为如果你做的是 batch size 为 1 的推理，那基本全是受内存带宽限制的。所以这其实是可行的。我觉得这也许是个人计算的一些早期迹象。但这还没有真正发生，也不清楚它究竟会长成什么样。也许你们当中有人就能发明出这是什么、它怎么运作，或者它应该是什么样子。也许我再提一个类比：每当我直接用文字跟 ChatGPT 或某个 LLM 对话时，我感觉自己像是在透过终端（terminal）跟一个 operating system 打交道——

[12:18]

the terminal. Like it's just it's it's text. It's direct access to the operating system. And I think a guey hasn't yet really been invented in like a general way like should chatt have a guey like different than just a tech bubbles. Uh certainly some of the apps that we're going to go into in a bit have guey but there's no like guey across all the tasks if that makes sense. Um there are some ways in which LLMs are different from kind of operating systems in some fairly unique way and from early computing. And I wrote about uh this one particular property that strikes me as very different uh this time around. It's that LLMs like flip they flip the direction of technology diffusion uh that is

——就是终端那种感觉。它就是文字，是对 operating system 的直接访问。我觉得目前还没有真正以一种通用的方式发明出 GUI，比如 ChatGPT 是不是该有个 GUI，而不只是一个个文字气泡？当然，我们待会儿要讲到的某些 app 是有 GUI 的，但还没有那种横跨所有任务的 GUI，如果你懂我意思的话。LLM 在某些相当独特的地方，跟传统 operating system、跟早期计算机是不一样的。我之前写过其中一个让我觉得这一次格外不同的特性，那就是 LLM 翻转了——它们翻转了技术扩散的方向，那种通常存在于技术里的——

[13:02]

usually uh present in technology. So for example with electricity, cryptography, computing, flight, internet, GPS, lots of new transformative technologies that have not been around. Typically it is the government and corporations that are the first users because it's new and expensive etc. and it only later diffuses to consumer. Uh, but I feel like LLMs are kind of like flipped around. So maybe with early computers, it was all about ballistics and military use, but with LLMs, it's all about how do you boil an egg or something like that. This is certainly like a lot of my use. And so it's really fascinating to me that we have a new magical computer and it's like helping me boil an egg.

——方向。比如说，电力、密码学、计算、飞行、互联网、GPS，许多前所未有的变革性技术，通常最先使用它们的都是政府和大公司，因为它又新又贵等等，要到后来才扩散给普通消费者。但我觉得 LLM 有点反过来了。也许早期计算机全是关于弹道学和军事用途，但 LLM 全是关于怎么煮个鸡蛋之类的事。这肯定是我自己很大一部分用途。所以让我觉得特别有意思的是，我们手里有一台全新的、魔法般的计算机，而它在帮我煮鸡蛋。

[13:37]

It's not helping the government do something really crazy like some military ballistics or some special technology. Indeed, corporations are governments are lagging behind the adoption of all of us, of all of these technologies. So, it's just backwards and I think it informs maybe some of the uses of how we want to use this technology or like where are some of the first apps and so on. So, in summary so far, LLM labs LLMs. I think it's accurate language to use, but LLMs are complicated operating systems.

它不是在帮政府做什么疯狂的事，比如军事弹道或者什么特殊技术。事实上，在采用所有这些技术上，企业和政府反而落在我们所有人后面。所以它就是反过来的，我觉得这也许能给我们一些启发：我们想怎么用这项技术、最早的一批 app 会出现在哪里，诸如此类。所以到目前为止做个小结：LLM 实验室——LLM。我觉得用这个说法是准确的，但 LLM 是复杂的 operating system。

[14:06]

They're circa 1960s in computing and we're redoing computing all over again. and they're currently available via time sharing and distributed like a utility. What is new and unprecedented is that they're not in the hands of a few governments and corporations. They're in the hands of all of us because we all have a computer and it's all just software and Chaship was beamed down to our computers like billions of people like instantly and overnight and this is insane. Uh and it's kind of insane to me that this is the case and now it is our time to enter the industry and program these computers. This is crazy. So I think this is quite remarkable. Before we program LLMs, we have to kind of like spend some time to think about what

它们处在大约 1960 年代的计算阶段，我们正在把计算这件事重新做一遍。而且它们目前是通过分时方式提供、像公用事业（utility）一样分布式供给的。真正新鲜、前所未有的是，它们不掌握在少数政府和大公司手里，而是掌握在我们所有人手里，因为我们每个人都有一台计算机，它全都只是软件，ChatGPT 几乎是一夜之间、瞬间就被广播到了我们的计算机上，覆盖了几十亿人，这太疯狂了。这种局面在我看来简直离谱，而现在轮到我们进入这个行业、去给这些计算机编程。这太不可思议了。所以我觉得这相当了不起。在我们给 LLM 编程之前，我们得花点时间想想这些东西到底——

[14:43]

these things are. And I especially like to kind of talk about their psychology. So the way I like to think about LLMs is that they're kind of like people spirits. Um they are stoastic simulations of people. Um and the simulator in this case happens to be an auto reggressive transformer. So transformer is a neural net. Uh it's and it just kind of like is goes on the level of tokens. It goes chunk chunk chunk chunk chunk. And there's an almost equal amount of compute for every single chunk. Um and um this simulator of course is is just is basically there's some weights involved and we fit it to all of text that we have on the internet and so on. And you end up with this kind of a simulator and because it is trained

——是什么。我尤其喜欢聊聊它们的心理学（psychology）。我喜欢这样理解 LLM：它们有点像人的精魂（people spirits）。它们是对人类的随机性（stochastic）模拟。而这里的模拟器恰好是一个自回归（autoregressive）transformer。transformer 是一个神经网络，它就是在 token 这个层级上运作的。它一块一块一块地往下走，每一块（chunk）所花的算力几乎是相等的。这个模拟器当然就是涉及一堆权重，我们把它拟合到我们能拿到的整个互联网上的所有文本等等。于是你最后就得到这样一个模拟器，而因为它是在——

[15:24]

on humans, it's got this emergent psychology that is humanlike. So the first thing you'll notice is of course uh LLM have encyclopedic knowledge and memory. uh and they can remember lots of things, a lot more than any single individual human can because they read so many things. It's it actually kind of reminds me of this movie Rainman, which I actually really recommend people watch. It's an amazing movie. I love this movie. Um and Dustin Hoffman here is an autistic savant who has almost perfect memory. So, he can read a he can read like a phone book and remember all of the names and phone numbers. And I kind of feel like LM are kind of like very similar. They can remember Shaw hashes and lots of different kinds of

——人类数据上训练出来的，它就有了这种涌现出来的、类似人类的心理。所以你首先会注意到的当然是，LLM 拥有百科全书式的知识和记忆。它们能记住大量的东西，比任何单个人类能记住的都多得多，因为它们读过太多东西了。这其实让我想起《雨人》（Rain Man）这部电影，我真心推荐大家去看，是部很棒的电影，我很喜欢。Dustin Hoffman 在里面演一个自闭症的天才（autistic savant），有近乎完美的记忆力。他可以读一本电话簿，然后把里面所有的名字和电话号码都记下来。我感觉 LLM 跟这有点很像。它们可以记住 SHA 哈希值之类各种各样的——

[16:00]

things very very easily. So they certainly have superpowers in some set in some respects. But they also have a bunch of I would say cognitive deficits. So they hallucinate quite a bit. Um and they kind of make up stuff and don't have a very good uh sort of internal model of self-nowledge, not sufficient at least. And this has gotten better but not perfect. They display jagged intelligence. So they're going to be superhuman in some problems solving domains. And then they're going to make mistakes that basically no human will make. like you know they will insist that 9.11 is greater than 9.9 or that there are two Rs in strawberry these are some famous examples but basically there are rough edges that you can trip on so

——东西，非常非常轻松。所以它们在某些方面确实有超能力。但它们同时也有一堆我会称之为认知缺陷的东西。比如说它们会 hallucinate（幻觉）得相当频繁，会编造东西，对自我也没有一个很好的内在认知模型，至少是不够。这一点有所改善，但还不完美。它们表现出 jagged intelligence（锯齿状智能）。所以它们在某些问题求解领域会是超人级的，然后却会犯一些基本上没有任何人类会犯的错误。比如它们会坚持说 9.11 比 9.9 大，或者说 strawberry 里有两个 R——这些都是著名的例子，但基本上就是有一些粗糙的边角，你会在上面绊倒。所以——

[16:38]

that's kind of I think also kind of unique um they also kind of suffer from entrograde amnesia um so uh and I think I'm alluding to the fact that if you have a co-orker who joins your organization this co-orker will over time learn your organization and uh they will understand and gain like a huge amount of context on the organization and they go home and they sleep and they consolidate knowledge and they develop expertise over time. LLMs don't natively do this and this is not something that has really been solved in the R&D of LLM. I think um and so context windows are really kind of like working memory and you have to sort of program the working memory quite directly because they don't just kind of like get smarter

——我觉得这也算挺独特的。它们还有点患有顺行性遗忘（anterograde amnesia，记不住新发生的事）。我这么说的意思是：如果有个新同事加入你的组织，这个同事会随着时间慢慢了解你的组织，理解并积累起对组织海量的上下文（context）；他们回家睡觉，就把知识巩固下来，慢慢地发展出专长。LLM 天生不会这么做，而这在 LLM 的研发里也还没有真正被解决。所以 context window 其实更像是工作记忆，你得相当直接地去给这块工作记忆编程，因为它们不会默认就自动变聪明——

[17:15]

by uh by default and I think a lot of people get tripped up by the analogies uh in this way. Uh in popular culture I recommend people watch these two movies uh Momento and 51st dates. In both of these movies, the protagonists, their weights are fixed and their context windows gets wiped every single morning and it's really problematic to go to work or have relationships when this happens and this happens to all the time. I guess one more thing I would point to is security kind of related limitations of the use of LLM. So for example, LLMs are quite gullible. Uh they are susceptible to prompt injection risks. They might leak your data etc.

——它们不会默认就自己变聪明。我觉得很多人就是在这种类比上栽了跟头。在流行文化里，我推荐大家看这两部电影：《记忆碎片》（Memento）和《初恋50次》（50 First Dates）。在这两部电影里，主角的权重是固定的，而他们的 context window 每天早上都会被清空，发生这种事的时候要去上班、要谈恋爱真的非常麻烦，而这种情况一直在发生。我想再指出一点，就是和安全相关的、对 LLM 使用的一些限制。比如说，LLM 相当容易上当。它们很容易受到 prompt injection 风险的影响。它们可能会泄露你的数据，等等。

[17:50]

And so um and there's many other considerations uh security related. So, so basically long story short, you have to load your you have to load your you have to simultaneously think through this superhuman thing that has a bunch of cognitive deficits and issues. How do we and yet they are extremely like useful and so how do we program them and how do we work around their deficits and enjoy their superhuman powers. So what I want to switch to now is talk about the opportunities of how do we use these models and what are some of the biggest opportunities. This is not a comprehensive list just some of the things that I thought were interesting for this talk. The first thing I'm kind of excited about is what I would call

还有很多其他和安全相关的考量。所以，长话短说，你必须同时把这件事想透：这是一个超人级的东西，同时又带着一堆认知缺陷和问题。我们要怎么——而它们偏偏又极其有用，所以我们要怎么给它们编程、怎么绕开它们的缺陷、同时享受它们的超人能力。所以现在我想切换到讲讲机会：我们怎么使用这些模型，以及其中一些最大的机会是什么。这不是一份详尽的清单，只是我觉得对这次演讲来说比较有意思的一些点。我比较兴奋的第一件事，是我会称之为——

[18:29]

partial autonomy apps. So for example, let's work with the example of coding. You can certainly go to chacht directly and you can start copy pasting code around and copyping bug reports and stuff around and getting code and copy pasting everything around. Why would you why would you do that? Why would you go directly to the operating system? It makes a lot more sense to have an app dedicated for this. And so I think many of you uh use uh cursor. I do as well. And uh cursor is kind of like the thing you want instead. You don't want to just directly go to the chash apt. And I think cursor is a very good example of an early LLM app that has a bunch of properties that I think are um useful across all the LLM apps. So in

——部分自主（partial autonomy）app。比如说，我们就拿写代码这个例子来讲。你当然可以直接去 ChatGPT，开始来回复制粘贴代码、复制粘贴 bug 报告之类的东西，拿到代码再把所有东西复制粘贴回去。你为什么要这么干呢？你为什么要直接去面对 operating system 呢？为此专门做一个 app 显然更合理得多。所以我想你们当中很多人用 cursor，我也用。cursor 就是那种你真正想要的东西，你不会想直接去用 ChatGPT。我觉得 cursor 是一个非常好的早期 LLM app 的例子，它具备一堆我觉得在所有 LLM app 里都通用的特性。所以——

[19:08]

particular, you will notice that we have a traditional interface that allows a human to go in and do all the work manually just as before. But in addition to that, we now have this LLM integration that allows us to go in bigger chunks. And so some of the properties of LLM apps that I think are shared and useful to point out. Number one, the LLMs basically do a ton of the context management. Um, number two, they orchestrate multiple calls to LLMs, right? So in the case of cursor, there's under the hood embedding models for all your files, the actual chat models, models that apply diffs to the code, and this is all orchestrated for you. A really big one that uh I think also maybe not fully appreciated always is

——具体来说，你会注意到我们有一个传统界面，允许人类进去、像以前一样手动完成所有工作。但除此之外，我们现在还有了这个 LLM 集成，让我们能以更大的步子（chunk）推进。所以这里有几个我觉得是所有 LLM app 共有、值得指出来的特性。第一，LLM 基本上承担了大量的 context 管理工作。第二，它们会编排对 LLM 的多次调用，对吧？所以拿 cursor 来说，底层有给你所有文件做嵌入（embedding）的模型、真正用来聊天的模型、把 diff 应用到代码上的模型，而这一切都帮你编排好了。还有一个我觉得也许并不总是被充分认识到的、很重要的点是——

[19:48]

application specific uh GUI and the importance of it. Um because you don't just want to talk to the operating system directly in text. Text is very hard to read, interpret, understand and also like you don't want to take some of these actions natively in text. So it's much better to just see a diff as like red and green change and you can see what's being added is subtracted. It's much easier to just do command Y to accept or command N to reject. I shouldn't have to type it in text, right? So, a guey allows a human to audit the work of these fallible systems and to go faster. I'm going to come back to this point a little bit uh later as well. And the last kind of feature I want to point out is that there's what I

为某个应用专门做的 GUI，以及它的重要性。因为你并不想直接用纯文本去跟操作系统对话。文本很难读、难解读、难理解，而且你也不想用纯文本原生地去执行其中一些操作。所以更好的方式是，直接看一个 diff——红色和绿色的改动一目了然，你能看到哪些是新增的、哪些是删掉的。直接按 command Y 接受、command N 拒绝，要轻松得多。我不该还得用文本一个字一个字敲出来，对吧？所以 GUI 让人类能够审查这些会犯错的系统的工作成果，而且能让你跑得更快。这个点我稍后还会再回来讲。我想指出的最后一类特性是——我把它

[20:25]

call the autonomy slider. So, for example, in cursor, you can just do tap completion. You're mostly in charge. You can select a chunk of code and command K to change just that chunk of code. You can do command L to change the entire file. Or you can do command I which just you know let it rip do whatever you want in the entire repo and that's the sort of full autonomy agent agentic version and so you are in charge of the autonomy slider and depending on the complexity of the task at hand you can uh tune the amount of autonomy that you're willing to give up uh for that task maybe to show one more example of a fairly successful LLM app uh perplexity um it also has very similar features to what

叫做 autonomy slider（自治滑杆）。比如说在 Cursor 里，你可以只用 tab 补全，这时主要是你在掌控。你可以选中一段代码、按 command K 只改这一段。你可以按 command L 改整个文件。或者你可以按 command I，直接放手让它在整个仓库里随便折腾，那就是完全自治的 agent、agentic 的版本。所以你掌握着这个 autonomy slider，根据手头任务的复杂程度，你可以调节自己愿意为这个任务交出多少自治权。我再举一个相当成功的 LLM 应用的例子吧——Perplexity，它也有很多跟

[21:04]

I've just pointed out to in cursor uh it packages up a lot of the information. It orchestrates multiple LLMs. It's got a GUI that allows you to audit some of its work. So, for example, it will site sources and you can imagine inspecting them. And it's got an autonomy slider. You can either just do a quick search or you can do research or you can do deep research and come back 10 minutes later. So, this is all just varying levels of autonomy that you give up to the tool. So, I guess my question is I feel like a lot of software will become partially autonomous. I'm trying to think through like what does that look like? And for many of you who maintain products and services, how are you going to make your

我刚在 Cursor 里指出的那些非常相似的特性。它把大量信息打包整合起来，它编排调度多个 LLM，它有一个 GUI 让你可以审查它的部分工作。比如说它会标注来源，你可以想象去逐一检查这些来源。它也有一个 autonomy slider：你可以只做一次快速搜索，也可以做 research，或者做 deep research、然后 10 分钟后再回来看结果。所以这些其实就是你交给这个工具的不同程度的自治权。所以我想我的问题是——我觉得很多软件都会变成部分自治的。我在试着想清楚：那会是什么样子？而对在座很多维护着产品和服务的人来说，你们要怎么把你们的

[21:38]

products and services partially autonomous? Can an LLM see everything that a human can see? Can an LLM act in all the ways that a human could act? And can humans supervise and stay in the loop of this activity? Because again, these are fallible systems that aren't yet perfect. And what does a diff look like in Photoshop or something like that? You know, and also a lot of the traditional software right now, it has all these switches and all this kind of stuff that's all designed for human. All of this has to change and become accessible to LLMs.

产品和服务做成部分自治的？LLM 能不能看到人类能看到的一切？LLM 能不能用人类能用的所有方式去行动？以及人类能不能监督、并且一直留在这个活动的回路里？因为再说一遍，这些都是还不完美、会犯错的系统。那么在 Photoshop 或者类似的东西里，一个 diff 又长什么样？还有，现在很多传统软件都有这一大堆开关、这一大堆专为人类设计的东西。所有这些都得改变，得变得对 LLM 也可访问、可使用。

[22:07]

So, one thing I want to stress with a lot of these LLM apps that I'm not sure gets as much attention as it should is um we we're now kind of like cooperating with AIS and usually they are doing the generation and we as humans are doing the verification. It is in our interest to make this loop go as fast as possible. So, we're getting a lot of work done. There are two major ways that I think uh this can be done. Number one, you can speed up verification a lot. Um, and I think guies, for example, are extremely important to this because a guey utilizes your computer vision GPU in all of our head. Reading text is effortful and it's not fun, but looking at stuff is fun and it's it's just a kind of like a highway to your brain.

所以，关于这一大批 LLM 应用，有一点我想强调，我觉得它得到的关注还不够多——我们现在某种程度上是在跟 AI 协作，通常是它们负责生成（generation），而我们人类负责验证（verification）。让这个循环转得越快越好，是符合我们自身利益的，这样我们才能完成大量工作。我认为有两个主要的办法可以做到这一点。第一，你可以大大加快验证速度。我觉得 GUI 在这方面就极其重要，因为 GUI 调用的是我们脑子里都有的那块计算机视觉 GPU。读文本是费劲的、也不好玩，但看东西很好玩，它就像是一条直通你大脑的高速公路。

[22:47]

So, I think guies are very useful for auditing systems and visual representations in general. And number two, I would say is we have to keep the AI on the leash. We I think a lot of people are getting way over excited with AI agents and uh it's not useful to me to get a diff of 10,000 lines of code to my repo. Like I have to I'm still the bottleneck, right? Even though that 10,00 lines come out instantly, I have to make sure that this thing is not introducing bugs. It's just like and that it's doing the correct thing, right? And that there's no security issues and so on. So um I think that um yeah basically you we have to sort of like it's in our interest to make the the flow of these two go very very fast

所以我觉得 GUI 对于审查系统、以及一般意义上的可视化呈现都非常有用。第二点我想说的是，我们必须把 AI 拴住别放飞。我觉得很多人对 AI agent 兴奋过头了。给我的仓库丢来一个改了一万行代码的 diff，对我并没有用。我还是那个瓶颈，对吧？哪怕这一万行瞬间就生成出来，我还是得确保这玩意儿没引入 bug，得确保它做的事情是对的，对吧？还得确保没有安全问题等等。所以我觉得——对，基本上我们得让这两者（生成和验证）的流转变得非常非常快，这符合我们的利益，

[23:30]

and we have to somehow keep the AI on the leash because it gets way too overreactive. It's uh it's kind of like this. This is how I feel when I do AI assisted coding. If I'm just bite coding everything is nice and great but if I'm actually trying to get work done it's not so great to have an overreactive uh agent doing all this kind of stuff. So this slide is not very good. I'm sorry, but I guess I'm trying to develop like many of you some ways of utilizing these agents in my coding workflow and to do AI assisted coding. And in my own work, I'm always scared to get way too big diffs. I always go in small incremental chunks. I want to make sure that everything is good. I want to spin this loop very very fast and um I sort of

同时我们还得想办法把 AI 拴住别放飞，因为它太容易反应过度了。其实就有点像这样。这就是我做 AI 辅助编程时的感受。如果我只是在 vibe coding（凭感觉随便写），那一切都美好得很；但如果我是真的想干出活来，那就没那么美好了——你身边有个反应过度的 agent 到处瞎折腾，这可不行。这张幻灯片做得不太好，抱歉，不过我想说的是，我跟你们很多人一样，正在摸索一些把这些 agent 用进自己编码工作流、做 AI 辅助编程的方法。在我自己的工作里，我总是很怕拿到太大的 diff。我总是一小步一小步、增量式地推进。我想确保每一步都没问题。我想让这个循环转得非常非常快，而且我大致是

[24:09]

work on small chunks of single concrete thing. Uh and so I think many of you probably are developing similar ways of working with the with LLMs. Um, I also saw a number of blog posts that try to develop these best practices for working with LLMs. And here's one that I read recently and I thought was quite good. And it kind of discussed some techniques and some of them have to do with how you keep the AI on the leash. And so, as an example, if you are prompting, if your prompt is vague, then uh the AI might not do exactly what you wanted and in that case, verification will fail. You're going to ask for something else. If a verification fails, then you're going to start spinning. So it makes a lot more sense to spend a bit

围绕一件具体的小事、一小块一小块地干。所以我觉得你们很多人大概也在摸索出类似的、跟 LLM 协作的方式。我也看到不少博客文章在试图总结这些跟 LLM 协作的最佳实践。这里有一篇我最近读到的、我觉得相当不错。它讨论了一些技巧，其中有些就跟怎么把 AI 拴住有关。举个例子，如果你在写 prompt，而你的 prompt 很含糊，那 AI 可能就不会完全照你想要的去做，这种情况下验证就会失败。你就得再去要别的东西。一旦验证失败，你就会开始原地空转。所以，更划算的做法是花多一点

[24:45]

more time to be more concrete in your prompts which increases the probability of successful verification and you can move forward. And so I think a lot of us are going to end up finding um kind of techniques like this. I think in my own work as well I'm currently interested in uh what education looks like in um together with kind of like now that we have AI uh and LLMs what does education look like? And I think a a large amount of thought for me goes into how we keep AI on the leash. I don't think it just works to go to chat and be like, "Hey, teach me physics." I don't think this works because the AI is like gets lost in the woods. And so for me, this is actually two separate apps. For example,

时间，把你的 prompt 写得更具体，这样能提高一次验证成功的概率，你就能往前推进了。所以我觉得我们很多人最后都会摸索出类似这样的技巧。说到我自己的工作，我现在也对——既然我们有了 AI 和 LLM——教育会变成什么样子很感兴趣。在我看来，有很大一部分思考都花在怎么把 AI 拴住上。我不认为你直接去 chat 里说一句「嘿，教我物理」就管用。我不觉得这行得通，因为 AI 会在林子里迷路（gets lost in the woods）。所以对我来说，这其实是两个独立的应用。比如说，

[25:20]

there's an app for a teacher that creates courses and then there's an app that takes courses and serves them to students. And in both cases, we now have this intermediate artifact of a course that is auditable and we can make sure it's good. We can make sure it's consistent. and the AI is kept on the leash with respect to a certain syllabus, a certain like um progression of projects and so on. And so this is one way of keeping the AI on leash and I think has a much higher likelihood of working and the AI is not getting lost in the woods.

有一个给老师用的应用，负责生成课程；然后有另一个应用，把这些课程拿过来、提供给学生。在这两种情况下，我们现在都有了「课程」这么一个中间产物，它是可审查的，我们可以确保它是好的、是一致的。而且 AI 是被拴在某一份特定教学大纲、某一套特定的项目推进顺序等等之上的。所以这就是把 AI 拴住的一种方式，我觉得它成功的概率要高得多，AI 也不会在林子里迷路。

[25:49]

One more kind of analogy I wanted to sort of allude to is I'm not I'm no stranger to partial autonomy and I kind of worked on this I think for five years at Tesla and this is also a partial autonomy product and shares a lot of the features like for example right there in the instrument panel is the GUI of the autopilot so it's showing me what the what the neural network sees and so on and we have the autonomy slider where over the course of my tenure there we did more and more autonomous tasks for the user and maybe the story that I wanted to tell very briefly is uh actually the first time I drove a self-driving vehicle was in 2013 and I had a friend who worked at Whimo and uh he offered to give me a drive around

我还想顺带提一个类比——我对部分自治并不陌生，我在 Tesla 干这个干了大概五年，那也是一个部分自治的产品，它有很多相同的特性。比如说，仪表盘上那块就是 autopilot 的 GUI，它会显示出神经网络看到了什么之类的。我们也有 autonomy slider——在我任职的那几年里，我们替用户做了越来越多的自治任务。也许我想很简短地讲一个小故事：其实我第一次坐自动驾驶汽车是在 2013 年，我有个在 Waymo 工作的朋友，他提出带我在

[26:29]

Palo Alto. I took this picture using Google Glass at the time and many of you are so young that you might not even know what that is. Uh but uh yeah, this was like all the rage at the time. And we got into this car and we went for about a 30-minute drive around Palo Alto highways uh streets and so on. And this drive was perfect. There was zero interventions and this was 2013 which is now 12 years ago. And it kind of struck me because at the time when I had this perfect drive, this perfect demo, I felt like, wow, self-driving is imminent because this just worked. This is incredible. Um, but here we are 12 years later and we are still working on autonomy. Um, we are still working on driving agents and even now we haven't

Palo Alto 兜一圈。我当时用 Google Glass 拍了这张照片，在座很多人太年轻了，可能都不知道那是什么东西。不过是的，那玩意儿当年可火了。我们上了这辆车，在 Palo Alto 的高速、街道之类的地方开了大概 30 分钟。这趟车开得堪称完美。零干预（zero interventions），而这是 2013 年——到现在已经是 12 年前了。这件事当时挺触动我的，因为在我经历了这趟完美的车程、这次完美的演示之后，我感觉，哇，自动驾驶马上就要实现了，因为它就这么成了，太不可思议了。但如今 12 年过去，我们还在攻关自治这件事。我们还在攻关驾驶 agent，而且即便到了现在，我们也还没

[27:09]

actually like really solved the problem. like you may see Whimos going around and they look driverless but you know there's still a lot of teleoperation and a lot of human in the loop of a lot of this driving so we still haven't even like declared success but I think it's definitely like going to succeed at this point but it just took a long time and so I think like like this is software is really tricky I think in the same way that driving is tricky and so when I see things like oh 2025 is the year of agents I get very concerned and I kind of feel like you know this is the decade of agents and this is going to be quite some time. We need humans in the loop.

真正算是把这个问题解决掉。比如你可能看到 Waymo 的车到处跑，看起来像是无人驾驶，但你知道，背后其实还有大量的远程操控（teleoperation）、大量的 human in the loop（人在回路）支撑着这些驾驶。所以我们甚至都还没法宣布成功。不过我觉得到这个阶段它肯定是会成功的，只是花了非常长的时间。所以我觉得，软件真的很棘手，我觉得它棘手的方式跟驾驶很像。所以当我看到诸如「2025 是 agent 元年」这种说法时，我会非常担忧，我倒觉得，这是属于 agent 的十年，这会持续相当长一段时间。我们需要 human in the loop（人在回路）。

[27:45]

We need to do this carefully. This is software. Let's be serious here. One more kind of analogy that I always think through is the Iron Man suit. Uh I think this is I always love Iron Man. I think it's like so um correct in a bunch of ways with respect to technology and how it will play out. And what I love about the Iron Man suit is that it's both an augmentation and Tony Stark can drive it and it's also an agent. And in some of the movies, the Iron Man suit is quite autonomous and can fly around and find Tony and all this kind of stuff. And so this is the autonomy slider is we can be we can build augmentations or we can build agents and we kind of want to do a bit of both. But at this stage I would

我们得小心地来做这件事。这是软件，咱们认真点儿。我常会想到的另一个类比是 Iron Man 战衣。我一直特别喜欢 Iron Man，我觉得它在科技、以及科技会怎么演变这些方面，在很多点上都「对」得不行。我喜欢 Iron Man 战衣的地方在于，它既是一种增强（augmentation）——Tony Stark 可以亲自驾驶它，它同时也是一个 agent。在某些电影里，Iron Man 战衣相当自治，能自己飞来飞去、去找到 Tony 之类的。所以这就是 autonomy slider：我们既可以构建增强（augmentation），也可以构建 agent，而我们多少是两者都想要一点。但在现阶段，我会

[28:23]

say working with fallible LLMs and so on. I would say you know it's less Iron Man robots and more Iron Man suits that you want to build. It's less like building flashy demos of autonomous agents and more building partial autonomy products. And these products have custom gueies and UIUX. And we're trying to um and this is done so that the generation verification loop of the human is very very fast. But we are not losing the sight of the fact that it is in principle possible to automate this work. And there should be an autonomy slider in your product. And you should be thinking about how you can slide that autonomy slider and make your product uh sort of um more autonomous over time.

说，考虑到我们打交道的是会犯错的 LLM 等等，我会说，你想构建的东西，应该少一点 Iron Man 机器人、多一点 Iron Man 战衣。少去做那些花哨的自治 agent 演示，多去构建部分自治（partial autonomy）的产品。而这些产品有定制的 GUI 和 UI/UX。我们的目标是——这么做是为了让人类的 generation-verification loop（生成-验证循环）转得非常非常快。但我们同时也没有忘记一个事实：原则上，把这份工作自动化是有可能的。你的产品里应该有一个 autonomy slider，你应该去思考：要怎么去拨动这个 autonomy slider、让你的产品随着时间推移变得越来越自治。

[29:01]

But this is kind of how I think there's lots of opportunities in these kinds of products. I want to now switch gears a little bit and talk about one other dimension that I think is very unique. Not only is there a new type of programming language that allows for autonomy in software but also as I mentioned it's programmed in English which is this natural interface and suddenly everyone is a programmer because everyone speaks natural language like English. So this is extremely bullish and very interesting to me and also completely unprecedented. I would say it it used to be the case that you need to spend five to 10 years studying something to be able to do something in software. this is not the case anymore.

总之这大致就是我的想法——在这类产品里有大量的机会。现在我想稍微换个话题，来聊另一个我觉得非常独特的维度。这里不仅出现了一种新型的、能让软件实现自治的编程语言，而且就像我之前提到的，它是用英语来编程的，这是一种自然的接口，于是突然之间人人都成了程序员，因为人人都会说英语这样的自然语言。所以这对我来说是极度看涨、非常有意思，也完全是前所未有的。我想说，以前的情况是，你得花五到十年去钻研某样东西，才能在软件领域做出点什么来。现在不再是这样了。

[29:35]

So, I don't know if by any chance anyone has heard of vibe coding. Uh, this this is the tweet that kind of like introduced this, but I'm told that this is now like a major meme. Um, fun story about this is that I've been on Twitter for like 15 years or something like that at this point and I still have no clue which tweet will become viral and which tweet like fizzles and no one cares. And I thought that this tweet was going to be the latter. I don't know. It was just like a shower of thoughts. But this became like a total meme and I really just can't tell. But I guess like it struck a chord and it gave a name to something that everyone was feeling but couldn't quite say in words. So now there's a Wikipedia page and everything.

我不知道在座有没有人碰巧听说过 vibe coding。呃，就是这条推文最早算是把它引出来的，不过我听说现在这已经变成一个大热梗了。关于这个有个有意思的事：我在 Twitter 上混了大概 15 年了吧，到现在我还是完全摸不准哪条推文会爆、哪条会石沉大海没人理。我本来以为这条推文属于后者。我也说不清，它就是随手发的一串念头。结果它彻底变成了一个梗，我是真没法预测。但我猜它大概是戳中了某根弦，给一种大家都隐约感觉到、却又说不上来的东西起了个名字。所以现在它都有维基百科词条了。

[30:17]

This is like [Applause] yeah this is like a major contribution now or something like that. So, um, so Tom Wolf from HuggingFace shared this beautiful video that I really love. Um, these are kids vibe coding. And I find that this is such a wholesome video. Like, I love this video. Like, how can you look at this video and feel bad about the future? The future is great. I think this will end up being like a gateway drug to software development. Um, I'm not a doomer about the future of the generation and I think yeah, I love this video. So, I tried by coding a little bit uh as well because it's so fun. Uh, so bike coding is so great when you want to build something super duper custom that doesn't appear to exist and

这就像是……[掌声] 是啊，这现在算是个重大贡献什么的了。所以呢，HuggingFace 的 Tom Wolf 分享了这段我特别喜欢的好视频。视频里是一群小孩在 vibe coding。我觉得这视频太治愈了。我太爱这个视频了。你怎么可能看着这视频还对未来感到悲观？未来一片光明。我觉得这最后会成为通向软件开发的入门毒品。我对这一代人的未来不悲观，是的，我太爱这个视频了。所以我自己也试着 vibe coding 了一下，因为它实在太好玩了。vibe coding 在你想做一个超级超级定制、市面上又不存在的东西时特别棒，

[31:12]

you just want to wing it because it's a Saturday or something like that. So, I built this uh iOS app and I don't I can't actually program in Swift, but I was really shocked that I was able to build like a super basic app and I'm not going to explain it. It's really uh dumb, but uh I kind of like this was just like a day of work and this was running on my phone like later that day and I was like, "Wow, this is amazing." I didn't have to like read through Swift for like five days or something like that to like get started. I also vipcoded this app called Menu Genen. And this is live. You can try it in menu.app. And I basically had this problem where I show up at a restaurant, I read through the menu, and I have no

你就想随便冲一把，因为今天是周六之类的。所以我做了一个 iOS app，我其实根本不会写 Swift，但我真的特别震惊，居然能做出一个超基础的 app。我就不解释它是干嘛的了，它其实挺蠢的，但这就花了我一天时间，当天晚些时候它就跑在我手机上了，我当时想：哇，这太神奇了。我不用先啃五天 Swift 才能上手。我还 vibe code 了一个叫 MenuGen 的 app。它现在是上线的，你可以在 menu.app 上试。我基本上是有这么个问题：我到一家餐厅，看着菜单，完全

[31:46]

idea what any of the things are. And I need pictures. So this doesn't exist. So I was like, "Hey, I'm going to bite code it." So, um, this is what it looks like. You go to menu.app, um, and, uh, you take a picture of a of a menu and then menu generates the images and everyone gets $5 in credits for free when you sign up. And therefore, this is a major cost center in my life. So, this is a negative negative uh, revenue app for me right now. I've lost a huge amount of money on menu.

不知道上面那些东西到底是什么。我需要图片。这种东西不存在。所以我就想：嘿，我来 vibe code 一个。呃，它长这样。你打开 menu.app，拍一张菜单的照片，然后 MenuGen 就会生成那些图片，每个人注册时还免费送 5 美元额度。因此这成了我生活里的一个大成本中心。所以现在这对我来说是个负收益的 app。我在 menu 上亏了一大笔钱。

[32:21]

Okay. But the fascinating thing about menu genen for me is that the code of the v the vite coding part the code was actually the easy part of v of v coding menu and most of it actually was when I tried to make it real so that you can actually have authentication and payments and the domain name and averal deployment. This was really hard and all of this was not code. All of this devops stuff was in me in the browser clicking stuff and this was extreme slo and took another week. So it was really fascinating that I had the menu genen um basically demo working on my laptop in a few hours and then it took me a week because I was trying to make it real and the reason for this is this was just really annoying. Um, so for example, if

好。但 MenuGen 让我着迷的地方在于，vibe coding 那部分的代码其实是 vibe coding MenuGen 里最简单的部分，大部分工作其实是在我试图把它变成真东西的时候——也就是让它真的能有身份认证、支付、域名、还有 Vercel 部署。这部分真的特别难，而且这些全都不是写代码。所有这些 devops 的活儿都是我在浏览器里点来点去，这部分极其极其慢，又多花了我一周。所以特别有意思的是，我几个小时就在笔记本上把 MenuGen 的 demo 跑通了，然后又花了我一周，因为我想把它变成真东西，而原因就是这事儿实在太烦人了。比如说，如果

[33:05]

you try to add Google login to your web page, I know this is very small, but just a huge amount of instructions of this clerk library telling me how to integrate this. And this is crazy. Like it's telling me go to this URL, click on this dropdown, choose this, go to this, and click on that. And it's like telling me what to do. Like a computer is telling me the actions I should be taking. Like you do it. Why am I doing this? What the hell? I had to follow all these instructions.

你想给你的网页加个 Google 登录，我知道这个字很小，但就是这个 clerk 库给我的一大堆操作说明，告诉我怎么集成它。这太离谱了。它跟我说：去这个 URL，点这个下拉菜单，选这个，再去那个，点那个。它就这么一步步告诉我该干什么。一台计算机在告诉我该做哪些操作。你自己做啊，凭什么是我来做？搞什么鬼？我得照着这一大堆说明一条条做。

[33:33]

This was crazy. So I think the last part of my talk therefore focuses on can we just build for agents? I don't want to do this work. Can agents do this? Thank you. Okay. So roughly speaking, I think there's a new category of consumer and manipulator of digital information. It used to be just humans through GUIs or computers through APIs. And now we have a completely new thing and agents are they're computers but they are humanlike kind of right they're people spirits there's people spirits on the internet and they need to interact with our software infrastructure like can we build for them it's a new thing so as an example you can have robots.txt on your domain and you can instruct uh or like

这太疯狂了。所以我演讲的最后一部分就聚焦在：我们能不能干脆为 agent 而构建？我不想干这种活。agent 能不能来干？谢谢。好，那么大致来说，我认为出现了一类全新的数字信息消费者和操纵者。过去要么是通过 GUI 的人类，要么是通过 API 的计算机。而现在我们有了一个全新的东西，agent——它们是计算机，但又有点像人，对吧，它们是「人的精灵」（people spirits）；互联网上出现了一群人的精灵，它们需要跟我们的软件基础设施打交道。我们能不能为它们而构建？这是个新东西。举个例子，你可以在你的域名上放 robots.txt，你可以指示，或者说

[34:15]

advise I suppose um uh web crawlers on how to behave on your website in the same way you can have maybe lm.txt txt file which is just a simple markdown that's telling LLMs what this domain is about and this is very readable to a to an LLM. If it had to instead get the HTML of your web page and try to parse it, this is very errorprone and difficult and will screw it up and it's not going to work. So we can just directly speak to the LLM. It's worth it. Um a huge amount of documentation is currently written for people. So you will see things like lists and bold and pictures and this is not directly accessible by an LLM. So I see some of the services now are transitioning a lot of the their docs to be specifically for

建议吧，告诉网络爬虫该怎么在你的网站上行事。同样地，你也许可以放一个 llms.txt 文件，它就是一个简单的 markdown，告诉 LLM 这个域名是关于什么的，这对 LLM 来说非常好读。要是它只能去抓你网页的 HTML 然后试图解析，那就非常容易出错、非常困难，会搞砸，根本行不通。所以我们干脆可以直接对 LLM 说话。这是值得的。现在有海量的文档是写给人看的。所以你会看到列表啊、加粗啊、图片啊，这些 LLM 没法直接获取。所以我看到现在有些服务正在把它们大量的文档转成专门给

[34:54]

LLMs. So Versell and Stripe as an example are early movers here but there are a few more that I've seen already and they offer their documentation in markdown. Markdown is super easy for LMS to understand. This is great. Um maybe one simple example from from uh my experience as well. Maybe some of you know three blue one brown. He makes beautiful animation videos on YouTube. [Applause] Yeah, I love this library. So that he wrote uh Manon and I wanted to make my own and uh there's extensive documentations on how to use manon and so I didn't want to actually read through it. So I copy pasted the whole thing to an LLM and I described what I wanted and it just worked out of the box like LLM just bcoded me an animation

LLM 看的。比如 Vercel 和 Stripe 就是这方面的早期行动者，不过我还看到了另外几家，它们用 markdown 提供文档。markdown 对 LLM 来说超级好理解。这太棒了。也许再举一个来自我自己经历的小例子。也许你们有些人知道 3Blue1Brown，他在 YouTube 上做精美的动画视频。[掌声] 是的，我太爱这个库了。他写了一个叫 Manim 的库，我想做自己的动画，关于怎么用 Manim 有非常详尽的文档，但我其实不想去通读它。所以我把整份文档复制粘贴给一个 LLM，描述了我想要什么，然后它就开箱即用地成了，LLM 直接给我 vibe code 出了一段动画，

[35:41]

exactly what I wanted and I was like wow this is amazing. So if we can make docs legible to LLMs, it's going to unlock a huge amount of um kind of use and um I think this is wonderful and should should happen more. The other thing I wanted to point out is that you do unfortunately have to it's not just about taking your docs and making them appear in markdown. That's the easy part. We actually have to change the docs because anytime your docs say click this is bad. An LLM will not be able to natively take this action right now. So, Verscell, for example, is replacing every occurrence of click with an equivalent curl command that your LM agent could take on your behalf. Um, and so I think this is very interesting. And

正是我想要的，我当时想：哇，这太神奇了。所以如果我们能让文档对 LLM 可读，那将释放出海量的用途，我觉得这太美妙了，应该更多地这么干。我还想指出的另一点是，很遗憾，这不只是把你的文档拿过来变成 markdown 那么简单——那是最容易的部分。我们其实得去改文档本身，因为只要你的文档里写「点击」，那就不行。LLM 现在还没法原生地执行这个动作，对吧。所以比如 Vercel 就在把每一处「点击」替换成一条等效的 curl 命令，让你的 LLM agent 能替你执行。我觉得这非常有意思。然后

[36:19]

then, of course, there's a model context protocol from Enthropic. And this is also another way, it's a protocol of speaking directly to agents as this new consumer and manipulator of digital information. So, I'm very bullish on these ideas. The other thing I really like is a number of little tools here and there that are helping ingest data that in like very LLM friendly formats. So for example, when I go to a GitHub repo like my nanoGPT repo, I can't feed this to an LLM and ask questions about it uh because it's you know this is a human interface on GitHub. So when you just change the URL from GitHub to get ingest then uh this will actually concatenate all the files into a single giant text and it will create a

当然还有来自 Anthropic 的 model context protocol（MCP）。这也是另一种方式，是一种直接跟 agent——也就是这类新的数字信息消费者和操纵者——对话的协议。所以我对这些想法非常看好。我还特别喜欢的是这里那里冒出来的一堆小工具，它们帮你把数据以非常对 LLM 友好的格式喂进去。比如说，当我打开一个 GitHub 仓库，像我的 nanoGPT 仓库，我没法把它喂给 LLM 去问关于它的问题，因为你知道，GitHub 上这是个给人看的界面。但当你把 URL 里的 GitHub 改成 gitingest，它就会真的把所有文件拼接成一个巨大的文本，还会生成一个

[36:55]

directory structure etc. And this is ready to be copy pasted into your favorite LLM and you can do stuff. Maybe even more dramatic example of this is deep wiki where it's not just the raw content of these files. uh this is from Devon but also like they have Devon basically do analysis of the GitHub repo and Devon basically builds up a whole docs uh pages just for your repo and you can imagine that this is even more helpful to copy paste into your LLM. So I love all the little tools that basically where you just change the URL and it makes something accessible to an LLM. So this is all well and great and u I think there should be a lot more of it. One more note I wanted to make is that it is absolutely possible that in

目录结构等等。这就可以直接复制粘贴进你喜欢的 LLM，然后你就能干活了。也许更夸张的一个例子是 DeepWiki，它不只是这些文件的原始内容，呃这是 Devon（Devin）做的，他们基本上是让 Devin 对这个 GitHub 仓库做分析，然后 Devin 会为你的仓库搭起一整套文档页面，你可以想象，这复制粘贴进你的 LLM 就更有用了。所以我爱所有这些小工具，基本上就是你改一下 URL，它就把某个东西变得对 LLM 可访问。所以这一切都很好很棒，我觉得这类东西应该多得多。我还想提一点：完全有可能在

[37:35]

the future LLMs will be able to this is not even future this is today they'll be able to go around and they'll be able to click stuff and so on but I still think it's very worth u basically meeting LLM halfway LLM's halfway and making it easier for them to access all this information uh because this is still fairly expensive I would say to use and uh a lot more difficult and so I do think that lots of software there will be a long tail where it won't like adapt apps because these are not like live player sort of repositories or digital infrastructure and we will need these tools. Uh but I think for everyone else I think it's very worth kind of like meeting in some middle point. So I'm bullish on both if that makes sense.

未来，LLM 能够——其实都不用说未来，今天就能——它们能到处跑、能点击东西等等，但我仍然觉得很值得去基本上跟 LLM 各走一半路、迎上去，让它们更容易获取所有这些信息，因为这么用我得说目前还相当贵，也困难得多。所以我确实认为，会有很大一批长尾软件不会去适配 app，因为它们不是那种「活跃玩家」式的仓库或数字基础设施，那时候我们就会需要这些工具。但对于其他所有情况，我觉得很值得去找个中间点会合一下。所以我对两边都看好，如果这说得通的话。

[38:14]

So in summary, what an amazing time to get into the industry. We need to rewrite a ton of code. A ton of code will be written by professionals and by coders. These LLMs are kind of like utilities, kind of like fabs, but they're kind of especially like operating systems. But it's so early. It's like 1960s of operating systems and uh and I think a lot of the analogies cross over. Um and these LMS are kind of like these fallible uh you know people spirits that we have to learn to work with. And in order to do that properly, we need to adjust our infrastructure towards it. So when you're building these LLM apps, I describe some of the ways of working effectively with these LLMs and some of the tools that make

所以总结一下，这是个多么了不起的入行时代啊。我们需要重写一大堆代码。会有一大堆代码由专业人士和 coder 来写。这些 LLM 有点像公共事业设施，有点像晶圆厂（fab），但它们尤其像操作系统。可现在还太早了，就像是操作系统的 1960 年代，我觉得很多类比都能套得上。这些 LLM 有点像这些会犯错的、你知道的「人的精灵」，我们得学着跟它们协作。而要想把这事儿做好，我们需要调整我们的基础设施来适应它们。所以当你在构建这些 LLM app 时，我讲了一些跟这些 LLM 高效协作的方法，以及一些让

[38:54]

that uh kind of possible and how you can spin this loop very very quickly and basically create partial tunneling products and then um yeah, a lot of code has to also be written for the agents more directly. But in any case, going back to the Iron Man suit analogy, I think what we'll see over the next decade roughly is we're going to take the slider from left to right. And I'm very interesting. It's going to be very interesting to see what that looks like. And I can't wait to build it with all of you. Thank you.

这一切成为可能的工具，还有你怎么能非常非常快地把这个循环转起来，基本上做出部分自治的产品（partial autonomy products）。然后，是的，还有很多代码也得更直接地为 agent 来写。但不管怎样，回到钢铁侠战衣的比喻，我觉得在接下来大约十年里我们会看到的，是我们把那个滑杆从左往右推。我很感兴趣，看看那会是什么样子会非常有意思。我已经迫不及待要和你们所有人一起去构建它了。谢谢。