# Andrej Karpathy, 'Software Is Changing (Again)' (Y Combinator AI Startup School, 17 June 2025)

- Speaker: Andrej Karpathy
- Event: Y Combinator AI Startup School, San Francisco
- Date: June 2025 (video published 19 June 2025)
- Length: 39 min 31 s
- Video URL: https://www.youtube.com/watch?v=LCEmiRjPEtQ ; slides: https://drive.google.com/file/d/1a0h1mkwfmV2PlekxDN8isMrDA5evc4wW/view ; text: https://www.ycombinator.com/library/MW-andrej-karpathy-software-is-changing-again
- Slides: Many (roughly 60). Hand-drawn diagrams and screenshots, one idea per slide; he talks over each for 20 to 60 seconds.
- Transcript source: Whisper (faster-whisper, model medium) on the archive.org mirror of the YC video; cross-checked against the Y Combinator and Singju Post published transcripts. Timestamps match the YouTube upload.
- Corrections: Correction applied: the speaker's name as announced.
- Format: `[mm:ss]` is the time the line starts in the source recording. Machine transcript: expect small word errors; quotes used in the analysis were checked against the published text where one exists.

---

[00:00] Please welcome former Director of AI, Tesla, Andrej Karpathy.
[00:06] Hello, hello.
[00:13] Wow, a lot of people here. Hello.
[00:22] Okay, yeah, so I'm excited to be here today to talk to you about software in the era of AI.
[00:28] And I'm told that many of you are students, like bachelors, masters, PhD, and so on,
[00:34] and you're about to enter the industry.
[00:36] And I think it's actually like an extremely unique and very interesting time to enter the industry right now.
[00:40] And I think fundamentally the reason for that
[00:42] is that software is changing, again.
[00:47] And I say again because I actually gave this talk already,
[00:51] but the problem is that software keeps changing,
[00:53] so I actually have a lot of material to create new talks.
[00:56] And I think it's changing quite fundamentally.
[00:57] I think, roughly speaking, software has not changed much
[01:00] on such a fundamental level for 70 years,
[01:03] and then it's changed, I think, about twice,
[01:05] quite rapidly in the last few years.
[01:07] And so there's just a huge amount of work to do,
[01:09] a huge amount of software to write and rewrite.
[01:12] So let's take a look at maybe the realm of software.
[01:14] So if we kind of think of this as like the map of software,
[01:17] this is a really cool tool called Map of GitHub.
[01:20] This is kind of like all the software that's written.
[01:22] These are instructions to the computer
[01:24] for carrying out tasks in the digital space.
[01:26] So if you zoom in here,
[01:27] these are all different kinds of repositories,
[01:29] and this is all the code that has been written.
[01:31] And a few years ago,
[01:32] I kind of observed that software was kind of changing,
[01:35] and there was kind of like a new type of software
[01:38] around, and I called this software 2.0 at the time.
[01:41] And the idea here was that software 1.0 is the code
[01:44] you write for the computer.
[01:46] Software 2.0 are basically neural networks,
[01:48] and in particular, the weights of a neural network.
[01:51] And you're not writing this code directly.
[01:53] You are more kind of like tuning the data sets,
[01:56] and then you're running an optimizer
[01:57] to create the parameters of this neural net.
[02:00] And I think like at the time,
[02:02] neural nets were kind of seen as like
[02:03] just a different kind of classifier,
[02:04] like a decision tree or something like that,
[02:06] And so I think it was kind of like,
[02:08] I think this framing was a lot more appropriate.
[02:11] And now actually what we have is kind of like
[02:12] an equivalent of GitHub in the realm of software 2.0.
[02:15] And I think the hugging face
[02:17] is basically equivalent of GitHub in software 2.0.
[02:20] And there's also model Atlas
[02:22] and you can visualize all the code written there.
[02:24] In case you're curious, by the way,
[02:25] the giant circle, the point in the middle,
[02:28] these are the parameters of Flux, the image generator.
[02:31] And so anytime someone tunes a LoRa
[02:33] on top of a Flux model,
[02:34] You basically create a git commit in this space,
[02:37] and you create a different kind of image generator.
[02:40] So basically what we have is software 1.0
[02:43] is the computer code that programs a computer.
[02:45] Software 2.0 are the weights
[02:47] which program neural networks.
[02:49] And here's an example of AlexNet image recognizer
[02:52] neural network.
[02:53] Now so far, all of the neural networks
[02:55] that we've been familiar with until recently
[02:57] were kind of like fixed function computers.
[02:59] Image two categories or something like that.
[03:02] And I think what's changed,
[03:04] and I think is a quite fundamental change,
[03:06] is that neural networks became programmable
[03:08] with large language models.
[03:10] And so I see this as quite new, unique,
[03:13] it's a new kind of a computer.
[03:15] And so in my mind, it's worth giving it a new designation
[03:19] of software 3.0, and basically your prompts
[03:22] are now programs that program the LLM.
[03:25] And remarkably, these prompts are written in English.
[03:29] So it's kind of a very interesting programming language.
[03:32] So maybe to summarize the difference,
[03:37] if you're doing sentiment classification, for example,
[03:39] you can imagine writing some amount of Python
[03:42] to basically do sentiment classification,
[03:44] or you can train a neural net,
[03:46] or you can prompt a large language model.
[03:48] So here, this is a few-shot prompt,
[03:50] and you can imagine changing it
[03:51] and programming the computer in a slightly different way.
[03:53] So basically we have software 1.0, software 2.0,
[03:57] and I think we're seeing,
[03:58] maybe you've seen a lot of GitHub code
[04:00] is not just like code anymore,
[04:02] there's a bunch of like English interspersed with code.
[04:04] And so I think kind of there's a growing category
[04:07] of new kind of code.
[04:08] So not only is it a new programming paradigm,
[04:10] it's also remarkable to me
[04:11] that it's in our native language of English.
[04:13] And so when this blew my mind,
[04:16] a few I guess years ago now,
[04:18] I tweeted this and I think it captured
[04:21] the attention of a lot of people
[04:22] and this is my currently pinned tweet
[04:24] is that remarkably we're now programming computers
[04:26] in English.
[04:27] Now, when I was at Tesla,
[04:29] we were working on the Autopilot,
[04:34] and we were trying to get the car to drive.
[04:37] And I sort of showed the slide at the time
[04:40] where you can imagine that the inputs
[04:41] to the car are on the bottom,
[04:42] and they're going through a software stack
[04:44] to produce the steering and acceleration.
[04:47] And I made the observation at the time
[04:48] that there was a ton of C++ code around
[04:51] in the Autopilot, which was the software 1.0 code,
[04:53] and then there was some neural nets
[04:54] in there doing image recognition.
[04:56] And I kind of observed that over time
[04:58] as we made the autopilot better,
[05:00] basically the neural network grew in capability and size
[05:04] and in addition to that,
[05:06] all the C++ code was being deleted
[05:08] and a lot of the capabilities and functionality
[05:14] that was originally written in 1.0 was migrated to 2.0.
[05:17] So as an example,
[05:18] a lot of the stitching up of information across images
[05:21] from the different cameras and across time
[05:23] was done by a neural network
[05:25] and we were able to delete a lot of code.
[05:27] And so the software 2.0 stack quite literally ate through
[05:31] the software stack of the autopilot.
[05:33] So I thought this was really remarkable at the time.
[05:35] And I think we're seeing the same thing again,
[05:37] where basically we have a new kind of software
[05:40] and it's eating through the stack.
[05:41] We have three completely different programming paradigms.
[05:44] And I think if you're entering the industry,
[05:45] it's a very good idea to be fluent in all of them
[05:48] because they all have slight pros and cons
[05:50] and you may want to program some functionality
[05:51] in 1.0 or 2.0 or 3.0.
[05:53] Are you gonna train and enroll it?
[05:54] Are you gonna just prompt an LLM?
[05:56] should this be a piece of code that's explicit, et cetera.
[05:58] So we all have to make these decisions
[06:00] and actually potentially fluidly transition
[06:03] between these paradigms.
[06:05] So what I wanted to get into now is,
[06:09] first I want to, in the first part, talk about LLMs
[06:11] and how to kind of like think of this new paradigm
[06:13] and the ecosystem and what that looks like.
[06:16] Like what is this new computer?
[06:18] What does it look like?
[06:19] And what does the ecosystem look like?
[06:22] I was struck by this quote from Enduring actually
[06:25] many years ago now, I think,
[06:26] and I think Andrew is going to be speaking right after me,
[06:28] but he said at the time, AI is the new electricity.
[06:31] And I do think that it kind of captures
[06:34] something very interesting in that LLMs
[06:35] certainly feel like they have properties
[06:38] of utilities right now.
[06:39] So, LLM labs like OpenAI, Gemini, Entropy, et cetera,
[06:45] they spend CAPEX to train the LLMs,
[06:48] and this is kind of equivalent to building out a grid,
[06:50] and then there's OPEX to serve that intelligence
[06:52] over APIs to all of us.
[06:55] And this is done through metered access,
[06:57] where we pay per million tokens or something like that.
[07:00] And we have a lot of demands that are very utility-like
[07:03] demands out of this API.
[07:04] We demand low latency, high uptime, consistent quality,
[07:06] et cetera.
[07:08] In electricity, you would have a transfer switch.
[07:10] So you can transfer your electricity source
[07:12] from grid and solar or battery or generator.
[07:15] In LLMs, we have maybe open router
[07:17] and easily switch between the different types of LLMs
[07:19] that exist.
[07:20] Because the LLMs are software,
[07:22] they don't compete for physical space.
[07:24] So it's OK to have basically six electricity providers,
[07:27] and you can switch between them because they don't
[07:29] compete in such a direct way.
[07:31] And I think what's also really fascinating,
[07:33] and we saw this in the last few days,
[07:35] actually, a lot of the LLMs went down,
[07:38] and people were kind of stuck and unable to work.
[07:41] And I think it's kind of fascinating to me
[07:42] that when the state-of-the-art LLMs go
[07:44] down, it's actually kind of like an intelligence brownout
[07:46] in the world.
[07:47] It's kind of like when the voltage is
[07:49] unreliable in the grid, and the planet just gets dumber.
[07:53] the more reliance we have on these models, which already is
[07:56] like really dramatic and I think will continue to grow.
[07:59] But LLMs don't only have properties of utilities.
[08:01] I think it's also fair to say that they have some
[08:03] properties of fabs.
[08:05] And the reason for this is that the capex required for
[08:09] building LLMs is actually quite large.
[08:12] It's not just like building some power station or
[08:15] something like that, right?
[08:16] You're investing a huge amount of money.
[08:18] And I think the tech tree for the technology is growing
[08:22] quite rapidly.
[08:23] So we're in a world where we have sort of deep tech trees,
[08:26] research and development secrets
[08:28] that are centralizing inside the LLM labs.
[08:32] But I think the analogy muddies a little bit also
[08:34] because as I mentioned, this is software
[08:36] and software is a bit less defensible
[08:39] because it is so malleable.
[08:40] And so I think it's just an interesting kind of thing
[08:43] to think about potentially.
[08:45] There's many analogies you can make
[08:47] like a four nanometer process node
[08:49] maybe is something like a cluster with certain max flops.
[08:52] You can think about when you're using NVIDIA GPUs and you're
[08:54] only doing the software and you're not doing the hardware,
[08:56] that's kind of like the Fabless model.
[08:58] But if you're actually also building your own hardware
[09:00] and you're training on TPUs if you're Google,
[09:02] that's kind of like the Intel model where you own your Fab.
[09:05] So I think there's some analogies here that makes sense.
[09:07] But actually, I think the analogy that makes the most
[09:09] sense, perhaps, is that in my mind,
[09:11] LLMs have very strong analogies to operating systems.
[09:16] In that, this is not just electricity or water.
[09:18] It's not something that comes out of the tap as a commodity.
[09:21] These are now increasingly complex software ecosystems.
[09:26] So they're not just simple commodities like electricity.
[09:30] And it's kind of interesting to me
[09:31] that the ecosystem is shaping in a very similar kind of way
[09:34] where you have a few close source providers
[09:36] like Windows or Mac OS,
[09:38] and then you have an open source alternative like Linux.
[09:41] And I think for LLMs as well,
[09:44] we have kind of a few competing close source providers,
[09:48] and then maybe the Lama ecosystem
[09:49] is currently like maybe a close approximation
[09:52] to something that may grow into something like Linux.
[09:55] Again, I think it's still very early
[09:56] because these are just simple LLMs,
[09:57] but we're starting to see that
[09:59] these are going to get a lot more complicated.
[10:01] It's not just about the LLM itself.
[10:02] It's about all the tool use and the multi-modalities
[10:04] and how all of that works.
[10:06] And so when I sort of had this realization a while back,
[10:08] I tried to sketch it out
[10:10] and it kind of seemed to me like LLMs
[10:11] are kind of like a new operating system, right?
[10:14] So the LLM is a new kind of a computer.
[10:16] It's sitting, it's kind of like the CPU equivalent.
[10:19] The context windows are kind of like the memory.
[10:22] And then the LLM is orchestrating memory and compute
[10:26] for problem solving using all of these capabilities here.
[10:31] And so definitely, if you look at it,
[10:33] it looks very much like operating system
[10:35] from that perspective.
[10:37] A few more analogies, for example,
[10:38] if you want to download an app,
[10:40] say I go to VS code and I go to download,
[10:43] you can download VS code and you can run it
[10:45] on Windows, Linux, or Mac, in the same way
[10:50] as you can take an LLM app, like Cursor,
[10:53] and you can run it on GPT, or Cloud, or Gemini Series, right?
[10:56] It's just a drop down.
[10:57] So it's kind of similar in that way as well.
[11:00] More analogies that I think strike me
[11:02] is that we're kind of like in this 1960s-ish era,
[11:06] where LLM compute is still very expensive
[11:09] for this new kind of a computer.
[11:11] And that forces the LLMs to be centralized in the cloud.
[11:15] And we're all just sort of thin clients
[11:18] that interact with it over the network.
[11:20] And none of us have full utilization of these computers.
[11:23] And therefore, it makes sense to use time sharing,
[11:26] where we're all just a dimension of the batch
[11:28] when they're running the computer in the cloud.
[11:30] And this is very much what computers used to look like
[11:33] during this time.
[11:34] The operating systems were in the cloud.
[11:35] Everything was streamed around, and there was batching.
[11:39] And so the personal computing revolution
[11:41] hasn't happened yet, because it's just not economical.
[11:43] It doesn't make sense.
[11:44] But I think some people are trying, and it turns out that Mac minis, for example, are
[11:49] a very good fit for some of the LLMs, because it's all, if you're doing batch one inference,
[11:53] this is all super memory-bound, so this actually works.
[11:57] And I think these are some early indications, maybe, of personal computing, but this hasn't
[12:01] really happened yet.
[12:02] It's not clear what this looks like.
[12:03] Maybe some of you get to invent what this is or how it works or what it should be.
[12:10] Maybe one more analogy that I'll mention is whenever I talk to ChatGPT or some LLM
[12:14] in text, I feel like I'm talking to an operating system
[12:18] through the terminal.
[12:19] Like it's just, it's text, it's direct access
[12:22] to the operating system, and I think a GUI
[12:24] hasn't yet really been invented in like a general way.
[12:27] Like should ChachiPT have a GUI?
[12:30] Like different than just the tech bubbles?
[12:32] Certainly some of the apps that we're gonna go into
[12:34] in a bit have GUI, but there's no like GUI
[12:38] across all the tasks, if that makes sense.
[12:42] There are some ways in which LLMs are different
[12:44] from kind of operating systems in some fairly unique way
[12:47] and from early computing.
[12:49] And I wrote about this one particular property
[12:53] that strikes me as very different this time around.
[12:56] It's that LLMs like flip,
[12:58] they flip the direction of technology diffusion
[13:01] that is usually present in technology.
[13:05] So for example, with electricity, cryptography,
[13:06] computing, flight, internet, GPS,
[13:08] lots of new transformative technologies
[13:10] that have not been around,
[13:11] typically it is the government and corporations
[13:14] that are the first users,
[13:15] because it's new and expensive, et cetera,
[13:17] and it only later diffuses to consumer.
[13:20] But I feel like LLMs are kind of like flipped around.
[13:22] So maybe with early computers,
[13:24] it was all about ballistics and military use,
[13:26] but with LLMs, it's all about how do you boil an egg
[13:29] or something like that.
[13:30] This is certainly like a lot of my use.
[13:32] And so it's really fascinating to me
[13:33] that we have a new magical computer,
[13:35] and it's like helping me boil an egg.
[13:37] It's not helping the government do something really crazy
[13:39] like some military ballistics
[13:41] or some special technology.
[13:42] Indeed, corporations and governments are lagging behind
[13:44] the adoption of all of us, of all of these technologies.
[13:47] So it's just backwards, and I think it informs maybe
[13:50] some of the uses of how we want to use this technology,
[13:52] or like what are some of the first apps, and so on.
[13:56] So in summary so far, LLM Labs, BAB, LLMs,
[14:00] I think it's accurate language to use,
[14:03] but LLMs are complicated operating systems.
[14:06] They're circa 1960s in computing,
[14:08] and we're redoing computing all over again,
[14:10] and they're currently available via time sharing
[14:12] and distributed like a utility.
[14:13] What is new and unprecedented is that they're not
[14:16] in the hands of a few governments and corporations,
[14:18] they're in the hands of all of us
[14:19] because we all have a computer and it's all just software
[14:22] and ChachiPT was beamed down to our computers
[14:25] like to billions of people like instantly and overnight
[14:27] and this is insane.
[14:29] And it's kind of insane to me that this is the case
[14:32] and now it is our time to enter the industry
[14:34] and program these computers, this is crazy.
[14:36] So I think this is quite remarkable.
[14:39] Before we program LLMs, we have to kind of like
[14:42] spend some time to think about what these things are.
[14:44] And I especially like to kind of talk about their psychology.
[14:48] So the way I like to think about LLMs
[14:50] is that they're kind of like people spirits.
[14:53] They are stochastic simulations of people.
[14:56] And the simulator in this case
[14:57] happens to be an autoregressive transformer.
[14:59] So a transformer is a neural net.
[15:01] It's, and it just kind of like,
[15:04] goes on the level of tokens,
[15:05] it goes chunk, chunk, chunk, chunk, chunk.
[15:07] And there's an almost equal amount of compute
[15:09] for every single chunk.
[15:10] And this simulator, of course, is just,
[15:16] is basically there's some weights involved
[15:17] and we fit it to all of texts that we have
[15:20] on the internet and so on.
[15:21] And you end up with this kind of a simulator
[15:22] and because it is trained on humans,
[15:24] it's got this emergent psychology that is human-like.
[15:28] So the first thing you'll notice is, of course,
[15:30] elements of encyclopedic knowledge and memory
[15:33] and they can remember lots of things,
[15:34] a lot more than any single individual human can
[15:36] because they've read so many things.
[15:38] It actually kind of reminds me of this movie
[15:40] Rain Man, which I actually really recommend people watch.
[15:43] It's an amazing movie.
[15:44] I love this movie.
[15:45] And Dustin Hoffman here is an autistic savant who has
[15:48] almost perfect memory.
[15:49] So he can read like a phone book and remember all of the
[15:53] names and phone numbers.
[15:55] And I kind of feel like LLMs are very similar.
[15:57] They can remember Shah hashes and lots of different
[16:00] kinds of things very, very easily.
[16:01] So they certainly have superpowers in some
[16:04] respects, but they also have a bunch of, I would say,
[16:06] cognitive deficits.
[16:08] So they hallucinate quite a bit, and they kind of make up
[16:12] stuff and don't have a very good sort of internal model of
[16:15] self-knowledge, not sufficient at least.
[16:18] And this has gotten better, but not perfect.
[16:20] They display jagged intelligence.
[16:22] So they're going to be superhuman in some
[16:23] problem-solving domains.
[16:25] And then they're going to make mistakes that basically
[16:27] no human will make.
[16:29] They will insist that 9.11 is greater than 9.9, or
[16:32] that there are two Rs in strawberry.
[16:33] These are some famous examples.
[16:35] But basically, there are rough edges that you can trip on.
[16:38] So that's kind of, I think, also kind of unique.
[16:42] They also kind of suffer from enterograde amnesia.
[16:45] So, and I think I'm alluding to the fact
[16:47] that if you have a coworker who chose your organization,
[16:50] this coworker will over time learn your organization
[16:53] and they will understand and gain
[16:55] like a huge amount of context on the organization
[16:57] and they go home and they sleep
[16:59] and they consolidate knowledge
[17:00] and they develop expertise over time.
[17:02] LLMs don't natively do this
[17:03] and this is not something that has really been solved
[17:05] and the R&D of LLMs, I think.
[17:08] And so context windows are really kind of like
[17:09] working memory, and you have to sort of
[17:11] program the working memory quite directly
[17:13] because they don't just kind of like
[17:14] get smarter by default.
[17:16] And I think a lot of people get tripped up
[17:17] by the analogies in this way.
[17:20] In popular culture, I recommend people
[17:22] watch these two movies, Memento and 51st Dates.
[17:25] In both of these movies, the protagonists,
[17:27] their weights are fixed, and their context windows
[17:30] gets wiped every single morning,
[17:32] and it's really problematic to go to work
[17:34] or have relationships when this happens,
[17:36] and this happens to LLMs all the time.
[17:38] I guess one more thing I would point to is
[17:40] security kind of related limitations of the use of LLMs.
[17:44] So for example, LLMs are quite gullible.
[17:46] They are susceptible to prompt injection risks.
[17:48] They might leak your data, et cetera.
[17:50] And so, and there's many other considerations,
[17:53] security related.
[17:54] So basically, long story short,
[17:57] you have to load your, you have to load your,
[17:59] you have to simultaneously think through
[18:01] this superhuman thing that has a bunch
[18:03] of cognitive deficits and issues.
[18:05] And yet, they are extremely useful.
[18:08] And so how do we program them?
[18:10] And how do we work around their deficits
[18:12] and enjoy their superhuman powers?
[18:15] So what I want to switch to now
[18:17] is talk about the opportunities of how do we use these models
[18:19] and what are some of the biggest opportunities?
[18:21] This is not a comprehensive list,
[18:23] just some of the things that I thought
[18:24] were interesting for this talk.
[18:26] The first thing I'm kind of excited about
[18:28] is what I would call partial autonomy apps.
[18:31] So for example, let's work with the example of coding.
[18:34] You can certainly go to ChatGPT directly,
[18:36] and you can start copy-pasting code around,
[18:38] and copy-pasting bug reports and stuff around,
[18:41] and getting code and copy-pasting everything around.
[18:43] Why would you do that?
[18:44] Why would you go directly to the operating system?
[18:46] It makes a lot more sense
[18:47] to have an app dedicated for this.
[18:49] And so I think many of you use Cursor, I do as well.
[18:53] And Cursor is kind of like the thing you want instead.
[18:57] You don't want to just directly go to the ChatGPT.
[18:59] And I think Cursor is a very good example
[19:01] of an early LLM app that has a bunch of properties
[19:04] that I think are useful across all the LLM apps.
[19:07] So in particular, you will notice
[19:09] that we have a traditional interface
[19:11] that allows a human to go in
[19:12] and do all the work manually, just as before.
[19:16] But in addition to that,
[19:16] we now have this LLM integration
[19:18] that allows us to go in bigger chunks.
[19:20] And so some of the properties of LLM apps
[19:23] that I think are shared and useful to point out.
[19:25] Number one, the LLMs basically do a ton
[19:27] of the context management.
[19:29] Number two, they orchestrate multiple calls to LLMs, right?
[19:33] So in the case of Cursor, there's under the hood
[19:35] embedding models for all your files,
[19:37] the actual chat models, models that apply diffs
[19:40] to the code, and this is all orchestrated for you.
[19:43] A really big one that I think also maybe
[19:46] not fully appreciated always is application-specific
[19:49] GUI and the importance of it.
[19:52] Because you don't just want to talk to the operating
[19:54] system directly in text.
[19:55] Text is very hard to read, interpret, understand,
[19:58] And also, you don't want to take some of these actions
[20:01] natively in text.
[20:02] So it's much better to just see a diff
[20:04] as like red and green change,
[20:06] and you can see what's being added or subtracted.
[20:08] It's much easier to just do command-Y to accept
[20:10] or command-N to reject.
[20:11] I shouldn't have to type it in text, right?
[20:13] So GUI allows a human to audit the work
[20:16] of these fallible systems and to go faster.
[20:19] I'm going to come back to this point
[20:20] a little bit later as well.
[20:22] And the last kind of feature I want to point out
[20:24] is that there's what I call the autonomy slider.
[20:27] So for example, in Cursor,
[20:28] You can just do tap completion.
[20:30] You're mostly in charge.
[20:31] You can select a chunk of code and Command-K
[20:33] to change just that chunk of code.
[20:35] You can do Command-L to change the entire file.
[20:38] Or you can do Command-I, which just, you know,
[20:40] let it rip, do whatever you want in the entire repo.
[20:43] And that's the sort of full autonomy agent
[20:45] genetic version.
[20:46] And so you are in charge of the autonomy slider.
[20:49] And depending on the complexity of the task at hand,
[20:51] you can tune the amount of autonomy
[20:53] that you're willing to give up for that task.
[20:56] Maybe to show one more example of a fairly successful LLM
[20:59] app, Perplexity, it also has very similar features
[21:04] to what I just pointed out in Cursor.
[21:06] It packages up a lot of the information.
[21:08] It orchestrates multiple LLMs.
[21:10] It's got a GUI that allows you to audit some of its work.
[21:13] So for example, it will cite sources,
[21:16] and you can imagine inspecting them.
[21:17] And it's got an autonomy slider.
[21:18] You can either just do a quick search,
[21:20] or you can do research, or you can do deep research
[21:22] and come back 10 minutes later.
[21:24] So this is all just varying levels of autonomy
[21:26] that you give up to the tool.
[21:27] So I guess my question is, I feel
[21:29] like a lot of software will become partially autonomous.
[21:32] And I'm trying to think through, what does that look like?
[21:34] And for many of you who maintain products and services,
[21:37] how are you going to make your products and services
[21:39] partially autonomous?
[21:41] Can an LLM see everything that a human can see?
[21:43] Can an LLM act in all the ways that a human could act?
[21:46] And can humans supervise and stay
[21:49] in the loop of this activity?
[21:50] Because again, these are fallible systems
[21:52] that aren't yet perfect.
[21:53] And what does a diff look like in Photoshop
[21:55] or something like that, you know?
[21:57] And also a lot of the traditional software right now,
[21:59] it has all these switches and all this kind of stuff.
[22:02] It's all designed for human.
[22:03] All of this has to change and become accessible to LLMs.
[22:07] So one thing I want to stress with a lot of these LLM apps
[22:10] that I'm not sure it gets as much attention as it should
[22:13] is we're now kind of like cooperating with AIs.
[22:17] And usually they are doing the generation,
[22:19] and we as humans are doing the verification.
[22:21] It is in our interest to make this loop go
[22:23] as fast as possible so we're getting a lot of work done.
[22:26] There are two major ways that I think this can be done.
[22:29] Number one, you can speed up verification a lot.
[22:32] And I think GUIs, for example, are extremely important to
[22:35] this, because a GUI utilizes your computer vision GPU in
[22:39] all of our head.
[22:40] Reading text is effortful, and it's not fun.
[22:42] But looking at stuff is fun, and it's just kind of
[22:46] like a highway to your brain.
[22:47] So I think GUIs are very useful for auditing systems
[22:50] and visual representations in general.
[22:53] And number two, I would say, is we have to keep the AI
[22:56] on the leash.
[22:58] I think a lot of people are getting way over-excited
[23:00] with AI agents.
[23:01] And it's not useful to me to get a diff of 1,000 lines
[23:05] of code to my repo.
[23:07] I'm still the bottleneck.
[23:08] Even though the 1,000 lines come out instantly, I have to
[23:11] make sure that this thing is not introducing bugs, and
[23:15] that it's doing the correct thing, and that there's no
[23:17] security issues, and so on.
[23:18] So I think that, yeah, basically we have to sort of like,
[23:26] it's in our interest to make the flow of these two
[23:29] go very, very fast, and we have to somehow
[23:31] keep the AI on the leash
[23:32] because it gets way too overactive.
[23:34] It's kind of like this.
[23:35] This is how I feel when I do AI-assisted coding.
[23:38] If I'm just byte coding, everything is nice and great,
[23:40] but if I'm actually trying to get work done,
[23:42] it's not so great to have an overactive agent
[23:45] doing all this kind of stuff.
[23:46] So this slide is not very good, I'm sorry,
[23:48] But I guess I'm trying to develop, like many of you,
[23:51] some ways of utilizing these agents in my coding workflow
[23:55] and to do AI-assisted coding.
[23:57] And in my own work, I'm always scared
[23:59] to get way too big diffs.
[24:00] I always go in small incremental chunks.
[24:03] I want to make sure that everything is good.
[24:05] I want to spin this loop very, very fast.
[24:07] And I'd sort of work on small chunks
[24:09] of single concrete thing.
[24:11] And so I think many of you probably
[24:13] are developing similar ways of working with LLMs.
[24:18] I also saw a number of blog posts
[24:19] that try to develop these best practices for working
[24:22] with LLMs.
[24:23] And here's one that I read recently
[24:24] and I thought was quite good.
[24:26] And it kind of discussed some techniques.
[24:27] And some of them have to do with how
[24:28] you keep the AI on the leash.
[24:30] And so as an example, if you are prompting,
[24:32] if your prompt is vague, then the AI might not
[24:36] do exactly what you wanted.
[24:37] And in that case, verification will fail.
[24:39] You're going to ask for something else.
[24:41] If a verification fails, then you're
[24:42] going to start spinning.
[24:43] So it makes a lot more sense to spend a bit more time
[24:45] to be more concrete in your prompts, which
[24:47] increases the probability of successful verification,
[24:49] and you can move forward.
[24:51] And so I think a lot of us are going to end up finding
[24:54] techniques like this.
[24:55] I think in my own work as well, I'm currently
[24:57] interested in what education looks like together with kind
[25:01] of like, now that we have AI and all that,
[25:03] what does education look like?
[25:05] And I think a large amount of thought for me
[25:08] goes into how we keep AI on the leash.
[25:10] I don't think it just works to go to Chashie PT
[25:12] and be like, hey, teach me physics.
[25:14] I don't think this works, because the AI
[25:16] gets lost in the woods.
[25:17] And so for me, this is actually two separate apps,
[25:19] for example.
[25:20] There's an app for a teacher that creates courses,
[25:24] and then there's an app that takes courses
[25:25] and serves them to students.
[25:27] And in both cases, we now have this intermediate artifact
[25:30] of a course that is auditable,
[25:32] and we can make sure it's good,
[25:33] we can make sure it's consistent,
[25:34] and the AI is kept on the leash
[25:36] with respect to a certain syllabus,
[25:37] a certain progression of projects, and so on.
[25:42] And so this is one way of keeping the AI on leash,
[25:43] and I think has a much higher likelihood of working.
[25:46] and the AI is not getting lost in the woods.
[25:49] One more kind of analogy I wanted to sort of allude to
[25:52] is I'm no stranger to partial autonomy
[25:55] and I've kind of worked on this I think
[25:57] for five years at Tesla.
[25:58] And this is also a partial autonomy product
[26:01] and shares a lot of the features.
[26:02] Like for example, right there in the instrument panel
[26:04] is the GUI of the autopilot.
[26:06] So it's showing me what the neural network sees
[26:08] and so on.
[26:09] And we have the autonomy slider
[26:10] where over the course of my tenure there,
[26:13] we did more and more autonomous tasks for the user.
[26:17] And maybe the story that I wanted to tell very briefly
[26:19] is actually the first time I drove a self-driving vehicle
[26:23] was in 2013, and I had a friend who worked at Waymo,
[26:26] and he offered to give me a drive around Palo Alto.
[26:30] I took this picture using Google Glass at the time,
[26:33] and many of you are so young
[26:34] that you might not even know what that is,
[26:36] but yeah, this was like all the rage at the time.
[26:39] And we got into this car,
[26:40] and we went for about a 30-minute drive around Palo Alto,
[26:42] highways, streets, and so on,
[26:44] and this drive was perfect.
[26:46] There was zero interventions.
[26:48] And this was 2013, which is now 12 years ago.
[26:51] And it kind of struck me because at the time
[26:53] when I had this perfect drive, this perfect demo,
[26:55] I felt like, wow, self-driving is imminent
[26:59] because this just worked, this is incredible.
[27:02] But here we are 12 years later
[27:03] and we are still working on autonomy.
[27:06] We are still working on driving agents.
[27:07] And even now, we haven't actually fully
[27:09] solved the problem.
[27:11] You may see Waymo's going around
[27:12] and they look driverless, but there's still
[27:15] a lot of teleoperation and a lot of human in the loop
[27:18] of a lot of this driving.
[27:19] So we still haven't even declared success,
[27:21] but I think it's definitely going to succeed at this point,
[27:24] but it just took a long time.
[27:26] And so I think software is really tricky,
[27:30] I think, in the same way that driving is tricky.
[27:33] And so when I see things like,
[27:35] oh, 2025 is the year of agents,
[27:36] I get very concerned and I kind of feel like
[27:40] this is the decade of agents
[27:42] and this is going to be quite some time.
[27:44] We need humans in the loop, we need to do this carefully.
[27:46] This is software.
[27:48] Let's be serious here.
[27:50] One more kind of analogy that I always think through
[27:53] is the Iron Man suit.
[27:55] I think this is, I always love Iron Man.
[27:57] I think it's like so correct in a bunch of ways
[28:01] with respect to technology and how it will play out.
[28:03] And what I love about the Iron Man suit
[28:05] is that it's both an augmentation
[28:06] and Tony Stark can drive it, and it's also an agent.
[28:09] And in some of the movies, the Iron Man suit
[28:11] is quite autonomous and can fly around
[28:13] and fine-toning and all this kind of stuff.
[28:15] And so this is the autonomy slider,
[28:16] is we can build augmentations or we can build agents.
[28:19] And we kind of want to do a bit of both,
[28:21] but at this stage, I would say,
[28:23] working with fallible LLMs and so on,
[28:26] I would say, you know, it's less Ironman robots
[28:29] and more Ironman suits that you want to build.
[28:32] It's less like building flashy demos of autonomous agents
[28:35] and more building partial autonomy products.
[28:38] And these products have custom GUIs and UI UX,
[28:41] and we're trying to, and this is done
[28:43] so that the generation verification loop of the human
[28:45] is very, very fast.
[28:47] But we are not losing the sight of the fact
[28:49] that it is in principle possible to automate this work.
[28:51] And there should be an autonomy slider in your product
[28:54] and you should be thinking about how you can slide
[28:55] that autonomy slider and make your product
[28:58] sort of more autonomous over time.
[29:01] But this is kind of how I think there's lots
[29:02] of opportunities in these kinds of products.
[29:05] I wanna now switch gears a little bit
[29:06] and talk about one other dimension
[29:08] that I think is very unique.
[29:09] Not only is there a new type of programming language
[29:12] that allows for autonomy in software,
[29:14] but also, as I mentioned, it's programmed in English,
[29:16] which is this natural interface.
[29:18] And suddenly, everyone is a programmer
[29:20] because everyone speaks natural language, like English.
[29:23] So this is extremely bullish and very interesting to me
[29:26] and also completely unprecedented, I would say.
[29:28] It used to be the case that you need to spend
[29:30] five to 10 years studying something
[29:31] to be able to do something in software.
[29:33] This is not the case anymore.
[29:35] So I don't know if by any chance
[29:36] anyone has heard of vibe coding.
[29:40] This is the tweet that kind of like introduced this,
[29:43] but I'm told that this is now like a major meme.
[29:46] Fun story about this is that I've been on Twitter
[29:49] for like 15 years or something like that at this point,
[29:52] and I still have no clue which tweet will become viral
[29:56] and which tweet like fizzles and no one cares.
[29:58] And I thought that this tweet was gonna be the latter.
[30:01] I don't know, it was just like a shower of thoughts,
[30:03] but this became like a total meme,
[30:04] and I really just can't tell,
[30:06] but I guess like it struck a chord
[30:07] and gave a name to something that everyone was feeling,
[30:10] but couldn't quite say in words.
[30:13] So now there's a Wikipedia page and everything.
[30:15] This is like, yeah, this is like a major contribution now
[30:27] or something like that.
[30:28] So Tom Wolf from Hugging Face shared this beautiful video
[30:33] that I really love.
[30:37] These are kids' vibe coding.
[30:42] And I find that this is such a wholesome video.
[30:44] Like I love this video.
[30:46] Like how can you look at this video
[30:47] and feel bad about the future?
[30:49] The future is great.
[30:50] I think this will end up being like a gateway drug
[30:54] to software development.
[30:57] I'm not a doomer about the future of the generation
[31:00] and I think, yeah, I love this video.
[31:03] So I tried byte coding a little bit as well
[31:06] because it's so fun.
[31:07] So, byte coding is so great when you wanna build
[31:09] something super duper custom that doesn't appear
[31:11] to exist and you just wanna wing it
[31:13] because it's a Saturday or something like that.
[31:14] So I built this iOS app and I can't actually
[31:19] program in Swift, but I was really shocked
[31:21] that I was able to build like a super basic app,
[31:23] and I'm not gonna explain it, it's really dumb,
[31:25] but I kind of like, this was just like a day of work,
[31:28] and this was running on my phone like later that day,
[31:30] and I was like, wow, this is amazing.
[31:32] I didn't have to like read through Swift
[31:33] for like five days or something like that
[31:36] to like get started.
[31:37] I also web coded this app called MenuGen,
[31:40] and this is live, you can try it in menugen.app,
[31:43] and I basically had this problem
[31:44] where I show up at a restaurant,
[31:45] I read through the menu,
[31:46] and I have no idea what any of the things are,
[31:48] And I need pictures.
[31:49] So this doesn't exist.
[31:51] So I was like, hey, I'm gonna bytecode it.
[31:53] So this is what it looks like.
[31:55] You go to menugen.app and you take a picture of a menu
[32:02] and then menugen generates the images.
[32:04] And everyone gets $5 in credits for free when you sign up
[32:07] and therefore this is a major cost center in my life.
[32:11] So this is a negative revenue app for me right now.
[32:16] No, I've lost a huge amount of money on menu gen.
[32:21] Okay, but the fascinating thing about menu gen for me
[32:25] is that the code, the vibe coding part,
[32:29] the code was actually the easy part of vibe coding menu gen.
[32:33] And most of it actually was when I tried to make it real
[32:35] so that you can actually have authentication
[32:37] and payments and the domain name
[32:39] and the versatile deployment.
[32:40] This was really hard and all of this was not code.
[32:43] All of this DevOps stuff was me
[32:46] in the browser clicking stuff.
[32:47] And this was extreme slog and took another week.
[32:50] So it was really fascinating that I had the menu gen
[32:54] basically demo working on my laptop in a few hours.
[32:58] And then it took me a week
[32:59] because I was trying to make it real.
[33:00] And the reason for this is this was just really annoying.
[33:04] So for example,
[33:05] if you try to add Google login to your webpage,
[33:07] I know this is very small,
[33:08] but just a huge amount of instructions
[33:11] of this clerk library telling me how to integrate this.
[33:14] And this is crazy.
[33:15] it's telling me, go to this URL, click on this dropdown,
[33:18] choose this, go to this, and click on that,
[33:20] and it's like telling me what to do,
[33:21] like a computer is telling me
[33:23] the actions I should be taking, like you do it.
[33:25] Why am I doing this?
[33:28] What the hell?
[33:31] I had to follow all these instructions.
[33:33] This was crazy.
[33:34] So I think the last part of my talk, therefore,
[33:37] focuses on, can we just build for agents?
[33:41] I don't want to do this work.
[33:42] Can agents do this?
[33:43] Thank you.
[33:44] Okay, so roughly speaking, I think there's a new category of consumer and manipulator
[33:51] of digital information.
[33:52] It used to be just humans through GUIs, or computers through APIs, and now we have a
[33:57] completely new thing.
[33:59] And agents are their computers, but they are human-like, kind of, right?
[34:03] They're people spirits.
[34:04] There's people spirits on the internet, and they need to interact with our software
[34:06] infrastructure.
[34:07] What can we build for them?
[34:08] It's a new thing.
[34:10] So as an example, you can have robots.txt on your domain,
[34:13] and you can instruct or advise, I suppose, web crawlers
[34:18] on how to behave on your website.
[34:19] In the same way, you can have maybe LLM.txt file,
[34:21] which is just a simple markdown that's telling LLMs what
[34:24] this domain is about.
[34:26] And this is very readable to an LLM.
[34:29] If it had to instead get the HTML of your web page
[34:31] and try to parse it, this is very error-prone
[34:33] and difficult, and it will screw it up,
[34:35] and it's not going to work.
[34:36] So we can just directly speak to the LLM.
[34:38] It's worth it.
[34:40] A huge amount of documentation
[34:41] is currently written for people.
[34:42] So you will see things like lists and bold and pictures.
[34:46] And this is not directly accessible by an LLM.
[34:49] So I see some of the services now
[34:51] are transitioning a lot of their docs
[34:53] to be specifically for LLMs.
[34:55] So Versel and Stripe, as an example,
[34:57] are early movers here,
[34:58] but there are a few more that I've seen already.
[35:01] And they offer their documentation in Markdown.
[35:04] Markdown is super easy for LLMs to understand.
[35:08] This is great.
[35:09] Maybe one simple example from my experience as well.
[35:13] Maybe some of you know 3Blue1Brown.
[35:15] He makes beautiful animation videos on YouTube.
[35:17] Yeah, I love this library so that he wrote Manon.
[35:26] And I wanted to make my own.
[35:27] And there's extensive documentations
[35:30] on how to use Manon.
[35:31] And so I didn't want to actually read through it.
[35:34] So I copy pasted the whole thing to an LLM
[35:36] and I described what I wanted
[35:37] and it just worked out of the box.
[35:39] Like LLM just byte coded me an animation
[35:41] exactly what I wanted and I was like, wow, this is amazing.
[35:44] So if we can make docs legible to LLMs,
[35:47] it's going to unlock a huge amount of kind of use
[35:49] and I think this is wonderful and should happen more.
[35:54] The other thing I wanted to point out
[35:55] is that you do unfortunately have to,
[35:57] it's not just about taking your docs
[35:58] and making them appear in markdown.
[36:00] That's the easy part.
[36:00] We actually have to change the docs
[36:02] because anytime your docs say click, this is bad
[36:05] and LLM will not be able to natively
[36:07] take this action right now.
[36:09] So Bercel, for example, is replacing every occurrence
[36:12] of click with the equivalent curl command
[36:14] that your LLM agent could take on your behalf.
[36:18] And so I think this is very interesting.
[36:19] And then of course there's a model context protocol
[36:21] from Anthropic and this is also another way,
[36:24] it's a protocol speaking directly to agents
[36:26] as this new consumer and manipulator
[36:27] of digital information.
[36:28] So I'm very bullish on these ideas.
[36:30] The other thing I really like is a number
[36:32] of little tools here and there that are helping
[36:35] ingest data in like very LLM friendly formats.
[36:38] So for example, when I go to a GitHub repo,
[36:40] like my nano-gpt repo,
[36:42] I can't feed this to an LLM and ask questions about it
[36:45] because this is a human interface on GitHub.
[36:48] So when you just change the URL from GitHub to git ingest,
[36:51] then this will actually concatenate all the files
[36:53] into a single giant text
[36:55] and it will create a directory structure, et cetera,
[36:57] and this is ready to be copy-pasted
[36:58] into your favorite LLM and you can do stuff.
[37:01] Maybe even more dramatic example of this is deep wiki,
[37:04] where it's not just the raw content of these files.
[37:07] This is from Devon, but also like they have Devon
[37:10] basically do analysis of the GitHub repo
[37:12] and Devon basically builds up a whole docs pages
[37:16] just for your repo and you can imagine
[37:18] that this is even more helpful
[37:20] to copy paste into your LLM.
[37:22] So I love all the little tools
[37:23] that basically where you just change the URL
[37:25] and it makes something accessible to an LLM.
[37:27] So this is all well and great
[37:28] and I think there should be a lot more of it.
[37:31] One more note I wanted to make is that
[37:33] it is absolutely possible that in the future
[37:36] LLMs will be able to, this is not even future,
[37:38] this is today, they'll be able to go around
[37:40] and they'll be able to click stuff and so on.
[37:42] But I still think it's very worth
[37:44] basically meeting LLMs halfway
[37:48] and making it easier for them
[37:49] to access all this information
[37:50] because this is still fairly expensive,
[37:52] I would say, to use and a lot more difficult.
[37:55] And so I do think that lots of software,
[37:57] there will be a long tail where it won't adapt
[38:00] because these are not like live player
[38:02] sort of repositories or digital infrastructure
[38:05] And we will need these tools, but I think for everyone else,
[38:08] I think it's very worth kind of like meeting
[38:10] in some middle point.
[38:11] So I'm bullish on both, if that makes sense.
[38:14] So in summary, what an amazing time
[38:17] to get into the industry.
[38:18] We need to rewrite a ton of code.
[38:19] A ton of code will be written
[38:21] by professionals and by coders.
[38:24] These LLMs are kind of like utilities,
[38:26] kind of like fabs, but they're kind of especially
[38:28] like operating systems, but it's so early.
[38:30] It's like 1960s of operating systems.
[38:33] And I think a lot of the analogies cross over.
[38:38] And these LLMs are kind of like these fallible people spirits
[38:42] that we have to learn to work with.
[38:44] And in order to do that properly,
[38:45] we need to adjust our infrastructure towards it.
[38:48] So when you're building these LLM apps,
[38:49] I describe some of the ways of working effectively
[38:52] with these LLMs and some of the tools that
[38:54] make that possible, and how you can spin this loop very,
[38:57] very quickly and basically create partial telling products.
[39:01] And then, yeah, a lot of code has to also be written
[39:04] for the agents or directly.
[39:06] But in any case, going back to the Iron Man suit analogy,
[39:09] I think what we'll see over the next decade, roughly,
[39:12] is we're going to take the slider from left to right.
[39:15] And I'm very interesting.
[39:16] It's gonna be very interesting to see
[39:18] what that looks like.
[39:19] And I can't wait to build it with all of you.
[39:22] Thank you.