The next era of AI coding

0:03 It's so good to see everyone. Thank you for joining us for our first event in this office. It's an exciting time in the world and we're really glad to be able to discuss the future of software with you all. But before we jump into it, I want to talk a little bit about the place we are standing right now and it's place in technology history. A few decades ago at the end of the 1970s in May, the first Star Wars actually premiered here. This used to be a movie theater.

0:32 And um Star Wars was an amazing film for many reasons and a consequential film for many reasons. One of the reasons it was consequential was its place in both film technology history and in film history. And in particular, the team that worked on Star Wars didn't just they weren't just great storytellers. They actually innovated on the technology in many ways. For instance, this is a Dykstraflex, I am told, which is a uh computer-controlled camera system that can repeat the exact same camera moves multiple times. It can shoot models in layers and it can combine them into a seamless shot.

1:09 And so, the original Star Wars used this technique, you know, without humans in the loop entirely controlling these computers with cameras to help make the movie a reality and to help make the sci-fi fantasy that is Star Wars a reality. And I think that this is a great example of how technology can redefine categories, can kind of mark the boundary between a before period and an industry and an after period in an industry. And I think we are definitely in this right now with software engineering. And so, we're excited to dive into it and talk a little bit about how software has changed. But if we're going to go back again to ancient history and look at some code, which maybe some of you haven't done in a long time, both as leaders and also maybe some of the engineers in your team are looking at code a little bit less lately. If you'll remember, just a few years ago the way you built software was entirely by text editing formal programming languages. And so, for instance, here we have a very, very simple Python script where we're creating a list, we're going through it, we're adding to the list, we're then iterating through the list, and we're computing some things about it. But this, you know, this act of writing down logic in the form of formal programming languages was the only way in which humanity could build software until just a few years ago. And what's annoying and hard about this? What takes, you know, lots amounts of time?

2:26 What racks up hundreds of millions of dollars on a company's R&D budget with this? It's that one, you really need to take your high-level thoughts, the things you'd like to build on a computer, and you have to turn them in these into these little itty bits of logic. You have to really spell everything out exactly for the computer. And so, for instance, for the longest time, you've had to write software in if this, then that statements, in statements where you're looping over things, in statements where you're saying take this little piece of data over here and put it over here. And that's really tedious. You have to be really verbose.

3:01 And it might be that a feature that can be described in a couple of paragraphs to a human actually turns out to be many tens of thousands of lines of this logic. The other thing that for the longest time has made especially professional software engineering quite difficult is the weight of the existing logic because you're not dealing with the simple Python script, you're dealing with tens of millions of lines of code. And I think that this is one of the tragedies of software development is that all of this complexity is kind of hidden. It makes software feel trivial.

3:31 And I don't think that this is the case uniformly across engineering disciplines. Like, for instance, if you visit a Gothic cathedral and you look at it, kind of wears the weight of all it took to build that thing on its sleeve. You can see just how complex the thing is. But with software, since we're serving users, we want to make it feel really simple. And so, you just see buttons and just the little bits of information we want a human user to know at any given point of time, and you don't see all of this complexity and logic that exists under the hood. And so, product managers, uh non-technical folks, for decades have gone to engineers and asked them to make changes, and they've been, you know, pretty frustrated by how long it actually takes to build software. And it's because those professional engineers are wrangling the tens of millions of lines of code under the hood, and instead of writing these simple Python files, they're making changes throughout thousands of thousands of files. Uh and having to edit the existing logic. We can look at the data, and we've seen over the course of 2025, for instance, that the ratio of tab accepts to agent requests has completely exploded, where the number of agent requests in our product has gone up over 15x year over year. And at the start of 2025, you were seeing 10x more tab accepts than agent requests, and at this point you see many more agent requests than uh tab accepts. And that's especially consequential because an agent request is usually a giant body of work, and tab accept is, you know, maybe just a few characters or a few lines of code. And so, we've seen this this change happening in Cursor over the course of the past year. And we are also seeing, too, the start of kind of this third era, this teams era, starting to take hold within certain, especially forward-thinking companies. To cherry-pick a forward-thinking company in particular, this is our internal data of uh of Cursor Cursor engineers, but at this point, 30% of the PRs within our company are entirely developed end-to-end by an agent with no human intervention, and they're done with an agent that has their own computer, that's running in a cloud environment remotely, that works for many hours or potentially even days on a task end-to-end. These trends are not just things that show up in, you know, startups or mid-market companies.

5:33 They're showing up in an enterprise setting, too, where I think that over about a year ago, maybe 15 to 20% of the code within our enterprise segment was AI-generated. At this point, it's about 75% is entirely being AI-generated, and humans just aren't touching the syntax themselves. They're instead delegating to agents. And so, what does engineering become as we progress through these stages? Well, for instance, I think in the boundary of this agent era and this teams era, you're seeing that folks are more and more not touching the syntax at all.

6:04 They're just becoming agent managers. And I think the conceptual model to have of your organization as you go from the agent era to the teams era is for the longest time, you've had this human work force of a couple thousand engineers working on your software. And now, you don't just have a couple thousand engineers working on your software, you have tens of thousands of ghost colleagues working on your software aside these human collaborators. And both you want to hire the most intelligent, most price performant agent colleagues to work with you, but also the workflows, the ways in which humans work with the AI, and the AIs work with each other, and humans work with each other change a lot, too. But we're seeing that folks are becoming agent managers, and increasingly, you know, think of their role as one of that's delegating and kind of managing all of these agents working in parallel. Folks are spending much more time on review.

6:50 You definitely There are ways to move through this progression of tab to agents to team, which can hurt an organization. And definitely, you can generate lots of code that's unsustainable, that makes bad architecture decisions, that's going to be riddled with bugs. You definitely don't want to do that. And so, increasingly, people are spending much more of their time, engineers are spending much more of their time reviewing the work. Looking at the syntax itself, looking at build versions of the software, testing it. And so, folks are spending a bunch of time in the review phase.

7:20 And folks are multitasking a lot. You know, in the agent era, when you're just sitting there, you're babysitting agents, you're feeding them the next bit of a task, the next bit of a task, and they're running locally on your computer. You're kind of bottlenecked in how many you can handle at once. Maybe you can handle one to three because they're all kind of editing the same version of the code base. As you move more towards the teams model with agents that have their own computer, you can be working with dozens of agent colleagues that are all working on their own task at once, running for a long time autonomously.

7:49 Um and that means a bit more multitasking. That means more parallelism. That means more context switching. That's maybe a little bit of a look into how people are working today. And I also want to tease a little bit at the far future. And this is something that we've experimented with here at Cursor of what does it look like if you can really get to a world where there's as much self-improvement as possible and as much as little human intervention as possible, too. So, for instance, we have played around with the idea of developing browsers entirely end-to-end autonomously using agents with no humans in the loop. And you were here seeing the progression of an agent system and agent team that worked over the course of an entire week with no humans, generated many, many PRs, 3 million lines of code, and it generated a mostly functional prototype browser. And so, you're seeing that on day one, it can't render apple.com well, it can't render this landing page well, and then day two, day three, day four, and then at the end, you actually have, you know, a pretty good web rendering system that was developed without humans in the loop entirely autonomously.

8:52 Uh and this experiment is very nascent. This stuff is not ready for prime time. You can see the summary statistics here of the amount of code, the number of concurrent agents on the team that ran at once, the number of tokens that were used. And here you can also see um actually a video of the agent team generating files. This is the code base, the files of a code base, uh and the connections between files being generated over the course of the week.

9:14 This stuff is is very nascent, uh very experimental, not ready for prime time yet. Um but we're excited to continue experimenting with pushing the boundaries on the side of how far can you go completely autonomously. And it's helped to inform the product decisions that we make for the kind of teams era of product development within Cursor.