# Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan

Markdown copy of https://realalpha.app/v/96jN2OCOfLs/ on Real Alpha, the best minutes from long interviews with the people building AI. Cite and link the page, not this copy.

Andrej Karpathy says agentic engineering can speed up professional software work without lowering its quality bar.

- Show: Training Data
- Hosts: Stephanie Zhan
- Guest: [Andrej Karpathy](https://realalpha.app/builders/andrej-karpathy/) is co-founder of OpenAI, former head of AI at Tesla, and founder of Eureka Labs.
- Published: Apr 29, 2026
- Length: 30 min

## The best minutes

- [2:24](https://realalpha.app/v/96jN2OCOfLs/?t=144) [Software 3.0 makes some apps unnecessary](https://realalpha.app/s/software-3-0-makes-some-apps-unnecessary/) (5 min)
- [9:29](https://realalpha.app/v/96jN2OCOfLs/?t=569) [Verifiability helps explain where AI excels](https://realalpha.app/s/verifiability-helps-explain-where-ai-excels/) (4 min)
- [19:22](https://realalpha.app/v/96jN2OCOfLs/?t=1162) [Engineers still need to own judgment and system design](https://realalpha.app/s/engineers-still-need-to-own-judgment-and-system-design/) (4 min)

## Also worth watching

- [15:42](https://realalpha.app/v/96jN2OCOfLs/?t=942) [Agentic engineering raises output without lowering the quality bar](https://realalpha.app/s/agentic-engineering-raises-output-without-lowering-the/) (4 min)
- [25:15](https://realalpha.app/v/96jN2OCOfLs/?t=1515) [Agent-first services should let agents handle setup and deployment](https://realalpha.app/s/agent-first-services-should-let-agents-handle-setup-and/) (2 min)
- [27:40](https://realalpha.app/v/96jN2OCOfLs/?t=1660) [You can outsource thinking but not understanding](https://realalpha.app/s/you-can-outsource-thinking-but-not-understanding/) (2 min)

Skip the opening setup, the founder discussion about automatable work, and the animals-versus-ghosts framing.

## Summary

Andrej Karpathy co-founded OpenAI, served as head of AI at Tesla, and founded Eureka Labs. At AI Ascent 2026, he discussed how agentic tools are changing programming and software development.

Andrej Karpathy says agentic tools began producing code he could trust around December, and that agentic engineering now aims to preserve professional software quality while increasing speed. He describes Software 3.0 as programming through prompts and context, with neural networks enabling new forms of information processing rather than simply speeding up existing software. He argues that AI capability is jagged: models excel where tasks are verifiable and labs train for them, but still need human oversight. Karpathy says people remain responsible for taste, design, and understanding, while software and infrastructure should become more agent-native.

### Minute by minute

- [0:37](https://realalpha.app/v/96jN2OCOfLs/?t=37) **Agentic tools changed coding.** Andrej Karpathy says newer models began producing code that worked without his corrections around December. As he trusted them more, he started vibe coding and filling his side-projects folder, a shift he says went beyond the ChatGPT-style use many people had seen the year before.
- [2:24](https://realalpha.app/v/96jN2OCOfLs/?t=144) **Prompts become the programming interface.** Karpathy describes Software 1.0 as writing code, Software 2.0 as training neural networks with data, and Software 3.0 as programming through prompts and context. He points to OpenClaw’s agent-based installation: instead of maintaining a complex shell script for different computers, users give instructions to an agent that can inspect and configure the environment.
- [4:46](https://realalpha.app/v/96jN2OCOfLs/?t=286) **Some apps can disappear.** Karpathy built Menugen to turn restaurant-menu photos into illustrated menus, using code, OCR, and image generation. He says he was surprised when a prompt to Gemini using NanoBanana produced the result directly, making much of his app unnecessary. He sees this as a shift toward neural networks processing information without conventional software in between.
- [7:33](https://realalpha.app/v/96jN2OCOfLs/?t=453) **Neural networks may run the show.** Karpathy imagines systems that take raw audio or video and generate a suitable interface, with neural networks doing most of the work. He suggests the neural network could become the host process while the CPU acts more like a co-processor, but says the path there remains uncertain.
- [9:41](https://realalpha.app/v/96jN2OCOfLs/?t=581) **Verifiable tasks create jagged skills.** Karpathy says models often excel at verifiable tasks such as math and code because labs can train them with reinforcement-learning rewards, while capability remains uneven elsewhere. He contrasts models that can refactor large codebases with ones that advise walking 50 meters to a car wash. He also says chess improved from GPT-3.5 to GPT-4 partly because chess data was included in training.
- [13:36](https://realalpha.app/v/96jN2OCOfLs/?t=816) **Verifiable domains invite fine-tuning.** Karpathy says founders may be able to build valuable reinforcement-learning environments in domains the major labs have not prioritized, then fine-tune models on them. He argues that almost everything can be made verifiable to some extent, including writing judged by a council of LLMs, and says everything is ultimately automatable.
- [15:42](https://realalpha.app/v/96jN2OCOfLs/?t=942) **Agentic engineering protects quality.** Karpathy distinguishes vibe coding, which raises the floor of what everyone can build, from agentic engineering, which aims to preserve professional software quality while moving faster. He describes agents as powerful but fallible and says coordinating them without sacrificing quality is an engineering discipline. In his view, skilled practitioners can gain far more than 10x.
- [17:17](https://realalpha.app/v/96jN2OCOfLs/?t=1037) **Hiring should test real projects.** Karpathy says strong agentic engineers invest in their tools and make use of their features. He argues that hiring should move beyond puzzles toward large projects, such as building a secure Twitter clone and then having agents try to break it.
- [19:33](https://realalpha.app/v/96jN2OCOfLs/?t=1173) **People still own judgment.** Karpathy says people remain responsible for aesthetics, judgment, specifications, and oversight. He gives Menugen’s account system as an example: an agent matched Google and Stripe accounts by email, even though users could use different addresses. He says people must define the right design, such as tying funds to unique user IDs, while agents fill in implementation details.
- [23:32](https://realalpha.app/v/96jN2OCOfLs/?t=1412) **Treat models as ghosts, not animals.** Karpathy says the ghost framing helps him think about models as statistical simulations shaped by pretraining and reinforcement learning, rather than as animal intelligences. He says yelling at them will not change how they work; the framing mainly encourages suspicion and careful evaluation rather than offering a fixed recipe for improvement.
- [25:15](https://realalpha.app/v/96jN2OCOfLs/?t=1515) **Infrastructure needs to serve agents.** Karpathy says much of today’s software and documentation is built for humans, and argues for agent-native tools and infrastructure. He wants users to describe a task to an agent and have it handle steps such as deploying Menugen, without manual service configuration. He also anticipates agents representing people and organizations and handling some coordination with one another.
- [27:40](https://realalpha.app/v/96jN2OCOfLs/?t=1660) **Understanding remains essential.** Karpathy says people may outsource thinking but cannot outsource understanding: someone still has to decide what to build, why it matters, and how to direct agents. He uses LLM-generated knowledge bases to reorganize information and prompt new insights, but says humans remain responsible for understanding what the models do not.

## Transcript

Training Data, hosted by Stephanie Zhan, with Andrej Karpathy.

Transcribed by machine (Whisper) from the episode’s audio, so a word may be off here and there.

[0:01](https://realalpha.app/v/96jN2OCOfLs/?t=1) we're so excited for our very first special guest he has helped build modern AI then explain modern AI and then occasionally rename modern AI he actually helped co-found OpenAI right inside of this office was the one who actually got autopilot working at Tesla back in the day and he has a rare gift of making the most complex technical shifts feel both accessible and inevitable. You all know him for having coined the term vibe coding last year, but just in the last few months, he said something even more startling, that he's never felt more behind as a programmer. That's where we're starting today.

[0:42](https://realalpha.app/v/96jN2OCOfLs/?t=42) Thank you, Andre, for joining us. Yeah, hello. Excited to be here and to kick us off. Okay, so just a couple months ago, you said that you've never felt more behind as a programmer. that's startling to hear from you of all people can you help us unpack that was that feeling exhilarating or unsettling yeah a mixture of both for sure well first of all I guess like as many of you I've been using agentic tools like lot code adjacent things for a while maybe over the last year as it came out and it was very good at you know chunks of code and sometimes it would mess up and you have to edit them and it was kind of helpful and then I would say December was this clear point where for me, I was on a break so I had a bit more time.

[1:22](https://realalpha.app/v/96jN2OCOfLs/?t=82) I think many other people are similar. And I just started to notice that with the latest models, the chunks just came out fine. And then I kept asking for more and just came out fine. And then I can't remember the last time I corrected it. And then I just trusted the system more and more. And then I was vibe coding. And so it was kind of a, I do think that it was a very stark transition. I think that a lot of people actually, I tried to stress this on Twitter and or X because I think a lot of people experienced AI last year as chat GPT adjacent thing but you really had to look again and you had to look as of December because things have changed fundamentally and especially on this like agentic coherent workflow that really started to actually work and so I would say that yeah it was just that realization that really had me go down their whole rabbit hole of just, you know, infinity side project.

[2:16](https://realalpha.app/v/96jN2OCOfLs/?t=136) My side projects folder is like extremely full with lots of random things and just by coding all the time. So yeah, that kind of happened in December, I would say. And I was looking at the repercussions of that since. You've talked a lot about this idea. of LLMs as a new computer. That it isn't just better software, it's a whole new computing paradigm. And software 1.0 was explicit rules, software 2.0 was learned weights, software 3.0 is this. If that's actually true, what does a team build differently the day they actually believe this? Right, so yeah, exactly. So software 1.0, I'm writing code.

[2:54](https://realalpha.app/v/96jN2OCOfLs/?t=174) Software 2.0, I'm actually programming by creating data sets and training neural networks. So the programming is kind of like arranging data sets and maybe some objectives and neural network architectures. And then what happened is that basically, if you train one of these GPT models or LLMs on a sufficiently large set of tasks, basically implicitly, because by training on the internet, you have to multitask all the things that are in the data set. These actually become kind of like a programmable computer in a certain sense. So software 3.0 is kind of about,

[3:22](https://realalpha.app/v/96jN2OCOfLs/?t=202) **Andrej Karpathy:** you know, your programming now turns to prompting. And what's in the context window is your lever over the interpreter, that is the LLM, that is kind of like interpreting your context and performing computation in the digital information space.

[3:35](https://realalpha.app/v/96jN2OCOfLs/?t=215) So I guess, yeah, that's kind of the transition. And I think there's a few examples of that really drove it home for me, and maybe that might be instructive. So, for example, when OpenClaw came out, when you want to install OpenClaw, you would expect that normally this is a bash script, like a shell script. So run the shell script to install OpenClaw. But the thing is that in order to target lots of different platforms and lots of different types of computers you might run in OpenClaw, these shell scripts usually balloon up and become extremely complex. But the thing is you're still stuck in a software 1.0 universe of wanting to write the code.

[4:08](https://realalpha.app/v/96jN2OCOfLs/?t=248) And actually the OpenClaw installation is a copy-paste of a bunch of text that you're supposed to give to your agent. So basically it's a little skill of copy-paste this and give it to your agent and it will install OpenClaw. And the reason this is a lot more powerful is you're working now in the software 3.0 paradigm where you don't have to Precisely spell out, you know all the individual details of that setup The agent has its own intelligence that it packages up and then it kind of follows the instructions and it looks at your Environment your computer and it kind of like performs intelligent actions to make things work and debug things in the loop And it's just like so much more powerful, right?

[4:42](https://realalpha.app/v/96jN2OCOfLs/?t=282) So I think that's a very different kind of like way of thinking about it It's just like what is the piece of text to copy paste to your agent? That's the programming paradigm now I think one more maybe example that comes to mind that is even more extreme than that is when I was building Menugen. So Menugen is this idea where you... You come to a restaurant, they give you a menu, there's no pictures usually, so I don't know what any of these things are. Usually, like 30% of the things, I have no idea what they are, 50%. So I wanted to take a photo of the restaurant menu and to get pictures of what those things might look like in a generic sense. And so I built, I bytecoded this app that basically lets you upload a photo, and it does all this stuff, and it runs on Vercel, and it basically re-renders the menu, and it gives you like all the items, and it gives you a picture that it uses an image, you know, generator four, to basically OCR all the different titles, use the image generator to get pictures of them, and then shows it to you. And then I saw the software 3.0 version of this, which is, which blew my mind, which is literally just take your photo, give it to Gemini, and say, use NanoBanana to overlay the things onto the menu. And NanoBanana basically

[5:51](https://realalpha.app/v/96jN2OCOfLs/?t=351) returned an image that is exactly the picture of the menu that I took, but it actually put into the pixels, it rendered the different things in the menu. And this blew my mind, because actually all of my menu gen is spurious, it's working in the old paradigm, that app shouldn't exist. And yeah, the software 3.0 paradigm is a lot more kind of raw, it just, your neural network is doing more and more of the work, and your prompt or context is just the image, and the output is an image, and there's no need to have any of the app in between. mean. So I think that people have to kind of like reframe, you know, not to work in the existing paradigm of what things existed and just think about it as a speed up of what exists. It's actually like new things are available now. And going back to your programming question, it's not even, I think that's also an example of working in the old mindset because it's not just about programming and programming becoming faster. This is more general information processing that is automatable now. So it's not just even about code. So previous code worked over kind of like structured data, right?

[6:52](https://realalpha.app/v/96jN2OCOfLs/?t=412) And you write code over structured data. But like for example, with my LLM Knowledge Bases project, basically you get LLMs to create wikis for your organization or for you in person, et cetera. This is not even a program. This is not something that could exist before because there was no code that would create a knowledge base based on a bunch of facts. But now you can just take these documents and basically recompile them in a different way and reorder them and create something that is new and interesting as a reframing of the data. And so these are new things that weren't possible. And so I think this is something that I keep trying to get back to as to not only what can we do that existed that is fact.

[7:30](https://realalpha.app/v/96jN2OCOfLs/?t=450) But I think there's new opportunities of just things that couldn't be possible before. And I almost think that that's more exciting. I love the menu gen progression and dichotomy that you laid out. And I think even I'm sure many folks here followed your own progression of programming from last October to early January, February this year. If you extrapolate that further, what is the 2026 equivalent for building websites in the 90s, building mobile apps in the 2010s, building SaaS in the last cloud era, what will look completely obvious in hindsight that is still mostly unbuilt today? Well, going with the example of Menugen, I guess, so a lot of this code shouldn't exist and it's just neural networks doing most of the work.

[8:16](https://realalpha.app/v/96jN2OCOfLs/?t=496) I do think that the extrapolation looks very weird because you could basically imagine, I don't think, yeah, so you could imagine completely neural computers in a certain sense. You feed raw videos, like imagine a device He takes raw videos or audio into basically what's a neural net and uses diffusion to render a UI that is kind of like, you know, unique for that moment in a certain sense. And I kind of feel like in the early days of computing, actually, people were a little bit confused as to whether computers would look like calculators or computers would look like neural nets. And in the 50s and 60s, it was not really obvious which way it would go.

[8:51](https://realalpha.app/v/96jN2OCOfLs/?t=531) And, of course, we went down the calculator path and ended up building classical computing. And then neural nets are currently running virtualized on existing computers. But you could imagine I think that a lot of this will flip and that the neural net becomes kind of like the host process and The CPU has become kind of like the co-processor So we saw the diagram of you know intelligence compute is going to of neural networks is going to take over and become the dominant Spend of flops so you could imagine something really weird and foreign when where neural nets are doing most of the heavy lifting They're using tool use as just like, you know Historical appendage for some kinds of like deterministic tasks, but what's really running the show is these neural nets that are networked in a certain way.

[9:30](https://realalpha.app/v/96jN2OCOfLs/?t=570) So you can imagine something extremely foreign as the extrapolation, but I think we're going to probably get there sort of piece by piece. And that progression is TBD, I would say. I'd love to talk a little bit about this concept of verifiability, the fact that AI will automate faster and more easily domains where the output can be verified. If that framework is right, what work is about to move much faster than people realize, And what professions do we have that people actually think are safe? that are actually highly verifiable. Yeah, so I spent some time writing about verifiability and basically like traditional computers can easily automate what you can specify in code and kind of this latest round of LLMs can easily automate what you can verify in a certain sense.

[10:19](https://realalpha.app/v/96jN2OCOfLs/?t=619) Because the way this works is that when Frontier Labs are training these LLMs, these are giant reinforcement learning environments, so they are given verification rewards, and then because of the way that these models are trained, and they end up basically progressing and creating these jagged entities that really peak in capability in verifiable domains like math and code and adjacent, and stagnate and are a little bit rough around the edges when things are not in that space. So I think the reason I wrote about verifiability is I'm trying to understand why these things are so jagged. And some of it has to do with how the labs train the models, but I think some of it also has to do with the focus of the labs and what they happen to put into the data distribution.

[10:59](https://realalpha.app/v/96jN2OCOfLs/?t=659) Because some things basically are significantly more valuable in economy and end up creating more environments because the labs wanted to work in those settings. So I think code is a good example of that. There's probably lots of verifiable environments they could think about that happen not to make it into the mix because they're just not that useful to have the capability around. But I think, to me, the big, I guess, like the big mystery is the favorite example for a while was that how many letters R are in a strawberry and the models would famously get this wrong. and it's an example of jacketness.

[11:27](https://realalpha.app/v/96jN2OCOfLs/?t=687) The models now patch this, I think, but the new one is I wanna go to a car wash to wash my car and it's 50 meters away, should I drive or should I walk? And state-of-the-art models today will tell you to walk because it's so close. How is it possible that state-of-the-art Opus 4.7 will simultaneously refactor 100,000 line code base or find zero-day vulnerabilities and yet tells me to walk to this car wash? This is insane. And to whatever extent these models remain jagged, it's an indication that, number one, maybe something slightly off, or number two, you need to actually be in the loop a little bit, and you need to treat them as tools, and you do have to kind of stay in touch with what they're doing. And so I think all of my writing, long story short, about verifiability is just trying to understand why these things are jagged. Is there any pattern to it? And I think it's some kind of a combination of verifiable plus labs care. Maybe one more anecdote that is instructive is from GPT 3.5 to GPT 4.

[12:30](https://realalpha.app/v/96jN2OCOfLs/?t=750) People noticed that chess improved a lot, and I think a lot of people thought, oh, well, it's just a progression of the capabilities, but actually it's more that, I think this is public information, I think I saw it on the internet, a huge amount of data of chess made it into the pre-chaining set, and just because it's in the data distribution, basically the model improved a lot more than it would just by default. So someone at OpenAI decided to add this data, and now you have a capability that just peaked a lot more. And so that's why I think I'm stressing this dimension of it, as we are slightly at the mercy of whatever the labs are doing, whatever they happen to put into the mix, and you have to actually explore this thing that they give you that has no manual. And it works in certain settings, but maybe not in some settings, and you have to kind of explore it a little bit. And if you're in the circuits that were part of the RL, you fly, and if you're in the circuits that are out of the data distribution you're going to struggle and you have to kind of figure out which circuits you're in in your application. And if you're not in the circuits then you have to really look at fine-tuning and doing some of your own work

[13:32](https://realalpha.app/v/96jN2OCOfLs/?t=812) because it's not going to necessarily come out of the LLM out of the box. I'd love to come back to the concept of jagged intelligence in a little bit. If you were a founder today and thinking about building a company you are trying to solve a problem that you think is tractable, something that is a domain that is verifiable but you look around you think oh my gosh well the labs have really really started getting to escape velocity in the ones that seem most obvious math coding and others what would your advice be to the founders in the audience so I think maybe that comes to the previous question of I do think that verifiability because it let me think so verifiability makes something tractable in the current paradigm because you can throw a huge amount of RL at it. So maybe one way to see it is that that remains true even if the labs are not focusing on it directly. So if you are in a verifiable setting where you could create these RL environments or examples then that actually sets you up to potentially do your own fine-tuning and you might benefit from that. But that is fundamentally technology that just works.

[14:38](https://realalpha.app/v/96jN2OCOfLs/?t=878) You can pull a lever if you have huge amount of diverse data sets of RL environments, et cetera, you can use your favorite fine-tuning framework and pull the lever and get something that actually works pretty well. So I don't know what the examples of this might be, but I do think there are some very valuable reinforcement learning environments that people could think of that I think are not part of the... Yeah, I don't want to give away the answer, but there is one domain that I think is very, oh, okay, sorry. I don't mean to vague post on the stage, but there are some examples of this. On the flip side, what do you think still feels automatable, only from a distance?

[15:14](https://realalpha.app/v/96jN2OCOfLs/?t=914) I do think that ultimately almost everything can be made verifiable to some extent, some things easier than others. Because even for things like writing or so on, you can imagine having a council of LLM judges and probably get something reasonable from this kind of an approach. So it's more about what's easy or hard. So I do think that ultimately, yeah, I think... Everything. Everything is automatable. Amazing, okay. So last year you coined the term vibe coding, and today we're in a world that feels a little bit more serious, more organic engineering. What do you think is the difference between the two, and what would you actually call what we're in today?

[15:57](https://realalpha.app/v/96jN2OCOfLs/?t=957) Yeah, so I would say VibeCoding is about raising the floor for everyone in terms of what they can do in software. So the floor rises, everyone can VibeCode anything, and that's amazing, incredible.

[16:07](https://realalpha.app/v/96jN2OCOfLs/?t=967) **Andrej Karpathy:** But then I would say agentic engineering is about preserving the quality bar of what existed before in professional software.

[16:12](https://realalpha.app/v/96jN2OCOfLs/?t=972) So you're not allowed to introduce vulnerabilities due to VibeCoding. You're still responsible for your software, just as before, but can you go faster? And spoiler is, you can, but how do you do that properly? And so to me, agentic engineering, I call it that because I do think it's kind of like an engineering discipline. You have these agents, which are these like spiky entities. They're a bit fallible, a little bit stochastic, but they are extremely powerful. And it's how do you coordinate them to go faster without sacrificing your quality bar? And doing that well and correctly is the realm of agentic engineering.

[16:48](https://realalpha.app/v/96jN2OCOfLs/?t=1008) So I kind of see them as different. Like one is about maybe raising the floor and the other is about extrapolating. And what I'm seeing, I think, is there is a very high ceiling on agentic engineer capability. And, you know, people used to talk about the 10x engineer previously. I think that this is magnified a lot more. 10x is not the speed up you gain. And I think it does seem to me like people who are very good at this peak a lot more than 10x from my perspective right now. I really like that framing. One thing that when Sam Altman came to AI Ascent last year, one memorable thing he said was that people of different generations use ChatGPT differently.

[17:28](https://realalpha.app/v/96jN2OCOfLs/?t=1048) So if you're in your 30s, you use it as. as a Google search replacement. But if you're in your teens, ChatGPT is your gateway to the internet. What is the parallel here in coding today? If we were to watch two people code using OpenClaw, CloudCode, CodeX, one you'd consider mediocre at it, and one you would consider fully AI native, how would you describe the difference? I mean, I think it's just trying to get the most out of the tools that are available, utilizing all of their features, investing into your own kind of setup. So just like previously, all the engineers are used to basically getting the most out of the tools you use.

[18:04](https://realalpha.app/v/96jN2OCOfLs/?t=1084) Either it's Vim or VS Code, or now it's, you know, ClothCode or Codex or so on. So just investing into your setup and utilizing a lot of the, you know, tools that are available to you. And I think it just kind of looks like that. I do think that maybe related thought is a lot of people are maybe hiring for this, right? because they want to hire strong agentic engineers. I do think that what I'm seeing is that the, you know, most people have still not refactored their hiring process for agentic engineer capability, right? Like, if you're giving out puzzles to solve, then this is still the old paradigm.

[18:47](https://realalpha.app/v/96jN2OCOfLs/?t=1127) I would say that hiring has to look like, give me a really big project and see someone implement that big project. Like, let's write, say, a Twitter clone for agents and then make it really good, make it really secure, and then have some agents simulate some activity on this Twitter. And then I'm going to use 10 codecs, 5.4x high, to try to break your website that you deployed. And they're going to try to basically break it, and they should not be able to break it. And so maybe it looks like that, right? And so, yeah, watching people in that setting and building bigger projects and utilizing the tooling is maybe what I would look at for the most part.

[19:28](https://realalpha.app/v/96jN2OCOfLs/?t=1168) And as agents do more, what human skill do you think becomes more valuable, not less? So, yeah, it's a good question. I think, well, right now the answer is that the agents are kind of like these intern entities, right? So it's remarkable.

[19:45](https://realalpha.app/v/96jN2OCOfLs/?t=1185) **Andrej Karpathy:** You basically still have to be in charge of the aesthetics, the judgment, the taste, and a little bit of oversight.

[19:51](https://realalpha.app/v/96jN2OCOfLs/?t=1191) Maybe one of my favorite examples of, like, the weirdness of agents is for Menugen. you sign up with a Google account, but you... purchase credits using a Stripe account, and both of them have email addresses. And my agent actually tries to basically, like when you purchase credits, it assigned it using the email address from Stripe to the Google email address. Like there wasn't a persistent user ID that for people. It was trying to match up the email addresses, but you could use different email address for your Stripe and your Google, and basically would not associate the funds. And so this is the kind of thing that these agents still will make mistakes about.

[20:30](https://realalpha.app/v/96jN2OCOfLs/?t=1230) It's like, why would you use email addresses to try to cross-correlate the funds? They can be arbitrary. You can use different emails, et cetera. Like, this is such a weird thing to do. So I think people have to be in charge of this spec, this plan, and I actually don't even like the plan mode. I would, I mean, obviously it's very useful, but I think there's something more general here where you have to work with your agent to design a spec that is very detailed, and maybe it's basically the docs, and then get the agents to write them. and you're in charge of the oversight and the top level categories, but the agents are doing a lot of that under the hood.

[21:02](https://realalpha.app/v/96jN2OCOfLs/?t=1262) And so I think you're not caring about some of the details. So as an example also with arrays or tensors in neural networks, there's a ton of details between PyTorch and NumPy and all the different, like Pandas and so on, for all the different little API details. And I already forgot about the keepdims versus keepdim, or whether it's dim or axis or reshape or permute or transpose, I don't remember this stuff anymore, right? Because you don't have to. This is the kind of details that are handled by the intern because they have very good recall. But you still have to know, for example, that there's underlying tensor, there's an underlying view, and then you can manipulate view of the same storage, or you can have different storage which would be less efficient.

[21:39](https://realalpha.app/v/96jN2OCOfLs/?t=1299) And so you still have to have an understanding of what this stuff is doing and some of the fundamentals so that you're not copying memory around unnecessarily and so on. But the details of the APIs are not handed off. So you're in charge of the taste, the engineering, the design, and that it makes sense, and that you're asking for the right things, and that you're saying that, okay, these have to be unique user IDs that we're going to tie everything to. And so you're doing some of the design and development, and the engineers are doing the fill-in-the-blanks. And that's currently kind of like where we are, and I think that's what everyone, of course, is seeing, I think, right now.

[22:13](https://realalpha.app/v/96jN2OCOfLs/?t=1333) Do you think there's a chance that this taste and judgment matters less over time, or will the ceiling just keep rising? Yeah, it's a good question. I would say, I mean, I'm hoping that it improves. I think probably the reason it does doesn't improve right now is again, it's not part of the RL. There's probably no aesthetics cost or reward, or it's not good enough or something like that. I do think that when you actually look at the code, sometimes I get a little bit of a heart attack because it's not like super amazing code necessarily all the time and it's very bloaty and there's a lot of copy paste and there's awkward abstractions that are brittle and like it works, but it's just really gross.

[22:54](https://realalpha.app/v/96jN2OCOfLs/?t=1374) And I do hope that this can improve in future models. A good example also is this micro-GPT project where I was trying to simplify LLM training to be as simple as possible. The models hate this. They can't do it. I kept trying to prompt an LLM to simplify more, simplify more, and it just can't... You feel like you're outside of the RL circuits. It feels like you're obviously pulling teeth. It's not like light speed. So I do think that people still remain in charge of this, but I do think that there's There's nothing fundamental, again, that's preventing it. It's just the labs haven't done it yet, almost.

[23:30](https://realalpha.app/v/96jN2OCOfLs/?t=1410) Yeah. So I'd love to come back to this idea of jagged forms of intelligence. You wrote a little bit about this with a very thought-provoking piece around animals versus ghosts. And the idea is that we're not building animals. We are summoning ghosts. And these are jagged forms of intelligence that are shaped by data and reward functions, but not by intrinsic motivation, or fun, or curiosity, or empowerment, things that kind of came about via evolution. Why does that framing matter, and what does it actually change about how you build and deploy and evaluate or even trust them? Yeah, so, yeah, I think the reason I wrote about this is because I'm trying to wrap my head around what these things are, right, because if you have a good model of what they are or are not, then you're going to be more competent at using them, and I do think that I don't know if it has, I'm not sure if it actually has like real power. I think it's a little bit of philosophizing, but I do think that, I think it's just coming to terms with the fact that these things are not, you know, animal intelligences, like if you yell at them, they're not going to work better or worse, or it doesn't have any impact.

[24:45](https://realalpha.app/v/96jN2OCOfLs/?t=1485) and it's all just kind of like these statistical simulation circuits where the the substrate is pre-training, so like statistics, and then but then there's RL bolting on top so it kind of like increases the appendages and... Maybe it's just kind of like a mindset of what I'm coming into or what's likely to work or not likely to work or how to modify it. But I don't actually, I don't know that I have like, here are the five obvious outcomes of how to make your system better. It's more just being suspicious of it and figuring it out over time. That's where it starts. Okay, so you are so deep in working with agents that don't just chat. They have real permissions. They have local context. They actually take action on your behalf. What does the world look like when we all start to live in that world?

[25:31](https://realalpha.app/v/96jN2OCOfLs/?t=1531) Yeah, I think a lot of people probably here are excited about what this native agentic environment looks like. And everything has to be rewritten. Everything is still fundamentally written for humans and has to be moved around. I still use, most of the time when I use different frameworks or libraries or things like that, they still have docs that are fundamentally written for humans. This is my favorite pet peeve. Like, I don't, why are people still telling me what to do? Like, I don't want to do anything.

[25:57](https://realalpha.app/v/96jN2OCOfLs/?t=1557) **Andrej Karpathy:** What is the thing I should copy paste to my agent?

[26:00](https://realalpha.app/v/96jN2OCOfLs/?t=1560) Like, so it's just, every time I'm told, you know, go to this URL or something like that, it's just like, oh, you know. So everyone is, I think, excited about how do we decompose the workloads that need to happen into fundamentally sensors over the world, actuators over the world. How do we make it agent-native? Basically, describe it to agents first, and then have a lot of automation around, you know, the, yeah, around data structures that are very legible to the LLMs. So I think, yeah, I'm hoping that there's a lot of agent-first infrastructure out there. And that for Menugen, famously, when I wrote the, I'm not sure how famously, but when I wrote the blog post about Menugen, a lot of the work, a lot of the trouble was not even writing the code for Menugen, it was deploying it in Vercel, because I had to work with all these different services and I had to string them up and I had to go to their settings and the menus and configure my DNS, and it was just so annoying.

[26:56](https://realalpha.app/v/96jN2OCOfLs/?t=1616) And so that's a good example of I would hope that Menugen, that I could give a prompt to an LLM, build Menugen, and that I didn't have to touch anything and it's deployed in that same way on the internet. I think that would be a good kind of a test for whether or not a lot of our infrastructure is becoming more and more agent native. And then ultimately I would say, yeah, I do think we're going towards a world where there's agent representation for people and for organizations. and I'll have my agent talk to your agent to figure out some of the details of our meetings. Things like that, so. I do think that that's roughly where things are going, but yeah, I think everyone here is excited about that.

[27:37](https://realalpha.app/v/96jN2OCOfLs/?t=1657) I really like the visual analogy of sensors and actuators. I actually hadn't thought about that. It's super interesting. Right. Okay, I think we have to end on a question about education because you are probably one of the very best in the world at making complex technical concepts simple and deeply thoughtful about how we design education around it. what still remains worth learning deeply when intelligence gets cheap as we move into the next era of AI yeah there was a tweet that blew my mind recently and I keep thinking about it like

[28:09](https://realalpha.app/v/96jN2OCOfLs/?t=1689) **Andrej Karpathy:** every other day it was something along the lines of you can outsource your thinking but you can't outsource your understanding and I think that's really nicely put I so yeah because I still I'm

[28:22](https://realalpha.app/v/96jN2OCOfLs/?t=1702) I'm still part of the system and I still have to, somehow information still has to make it into my brain and I feel like I'm becoming a bottleneck of just even knowing what are we trying to build, why is it worth doing, how do I direct my agents and so on. So I do still think that ultimately something has to direct the thinking and the processing and so on. And that's still kind of fundamentally constrained somehow by understanding. And this is one reason I also was very excited about all the LLM knowledge bases, because I feel like that's a way for me to process information and anytime I see a different projection onto information I always like feel like I gain insight. So it's really just a lot of prompts for me to do synthetic data generation kind of over some fixed data. So I really enjoy whenever I read an article I have my you know my wiki that's being built up from these articles and I love asking questions about things or and I think that ultimately these are tools to enhance understanding in a certain way and this is still kind of like a bit of a bottleneck because then you can't direct the you can be a good director if you still because the LLNs certainly don't excel at understanding you still are uniquely in charge of that so yeah I

[29:29](https://realalpha.app/v/96jN2OCOfLs/?t=1769) think tools to that effect I think are incredibly interesting exciting I'm excited to be back here in a couple years and to see if we've been fully automated out of the loop and they actually take care of understanding as well thank you so much for joining us Andre I really appreciate it