PRD to PR

0:01 Okay. All right, sweet. I think we can get started. Looks like we got about 450 people here. Um sweet. So, this session is called PRD to PR. Uh it's a very brandable name, I think. Uh but basically what it is it's it's going to walk you through some of the slightly more advanced workflows or or connective tissue layers in Cursor. Uh basically that's going to allow you to move from, you know, our requirements document in, you know, pick your favorite program management tool of

0:33 choice all the way to actually getting that up in either production or just in in GitHub. So, we're going to walk through a bunch of stuff, um but I do have a couple slides uh to kind of walk through before we hop into the actual demo. And then I will also periodically pause for questions. So, if you just want to throw your questions in the the Q&A section, uh and then Matt and Taylor will help me uh highlight some of the the the common ones there. Um so, basically just wanted to

1:02 highlight like what how Cursor has kind of evolved uh before we hop into the demo. So, uh you know, last year in February, you know, Cursor's core product was really like just these three things like tab indexing and chat. And if we kind of fast forward to today, so like a year later, uh you know, we've been releasing a lot like a a ton of new things constantly. Um so, that's why we have a lot of these webinars is because even something we might have presented,

1:28 you know, a few months ago, uh we have usually better approaches or more tools to do it faster, to do it better. Um and that's kind of some of the things we're going to walk through today. So, the agenda right now is we're just going to do kind of like a a quick basic overview in case, you know, you haven't uh touched Cursor in a while. Uh then we're going to hop into MCPs. So, specifically that like kind of connective tissue there. Um and this is all going to be with like a live

1:53 project. Uh then we're going to hop into specifically plan mode to help our implementation. Uh we'll touch on skills and commands. Uh and then we're going to move into cloud agents and then how all of this kind of ties together into this kind of nice narrative from PRD to PR. So, uh here just some of the resources.

2:12 We don't really have to go over that. Um again, we can use Cursor throughout all of these different platforms. Um so, the CLI, the desktop, um the the mobile agents, um and now JetBrains IDEs as well. Um so, specifically we're mostly going to be focused focusing in on the cloud and specifically that uh Cursor desktop client.

2:35 Uh and then here's just a quick quick start guide if you uh do want to kind of follow along or just explore Cursor as we kind of do this. So, I always like to include this slide. Um I made this slide, that's why it doesn't look as nice as the other ones. Um I'm not a great UX designer. But basically I like to throw this up before a lot of these kind of enablement sessions just to like take a step back and get like a a broader architectural view of like

3:01 what's actually happening with Cursor. Because, you know, there's a lot of people that think um you know, Cursor's just this kind of, you know, client desktop app and we just, you know, send your prompts directly to the model providers um and and that's kind of the relationship there. Uh what's really happening is this, you know, deep proprietary infrastructure in the cloud that we call the Cursor harness. Uh your prompt goes there or whatever you're

3:26 trying to do will go there and we do all this fancy optimization, this context enriching, this compaction uh that really allows really really great responses in a much quicker way. We also have train our own uh purpose-built software engineering models. Um so, those are available in our own harness as well and then you get the response back. So, again, just like to briefly highlight this um before we actually hop into the demo because I feel like it it helps people

3:55 understand um kind of at a at a high level here. Uh okay. So, we're actually going to hop into the demo now. So, I'm going to minimize this. I'm going to open this. Um so, when you open Cursor for the first time, uh you're going to see something like this. I'm going to pop open a project. Um and again, just to quickly walk through everything uh and then we'll move on to some of the more advanced stuff. So, if you've never opened Cursor before, you're probably going to be greeted with uh interface

4:22 that looks somewhat like this. This is kind of the agent first view. So, um really good if you're specifically working through a bunch of different agents here that you would see populated on the side. Um so, you can see like some of my archived uh settings or archived agents there. But if you're more familiar with um you know, typical IDEs, you might see something like this.

4:43 Um you know, where you can >> You're still on the uh Google uh Google Slides page just so you know. Oh, whoops. Sorry. I thought I did not share the whole thing. Thank you for let me do that. Hold on. Okay. Let me share my entire desktop instead. All right. So, this is what you guys should be seeing. So, as I was just saying, um if you open Cursor for the first time, you're probably going to be greeted with something that looks like this. Again,

5:14 this is kind of like the agents view. Um again, kind of like what I was saying, uh you know, you'll be able to see a lot of your archived agents. Really good for for orchestrating or doing a lot of uh agentic workflows. But if we switch to the editor view, uh and this is probably what you're more familiar familiar familiar with um when you think about IDEs. So, the typical kind of structure here with your file explorer on the left, your code in the center,

5:41 and then the terminal on the bottom. Uh and then we have this agent pane on the right. Um and I will just quickly walk through this and then we can kind of dive deep. Uh so, in the agent pane, this is kind of like where you're going to be doing a lot of that like agentic, a lot of that um advanced kind of uh coding work here. So, uh you have this drop-down that you can toggle between different modes. So, just at a high level, you have agent mode.

6:04 That mode can basically do everything. It can write code, it can create plans, to-do lists, run terminal commands, all the fancy stuff. Um you also have plan mode. So, plan mode, as the name kind of implies, it will only output a plan, um but it will research your entire code base. Cursor indexes everything. Super efficient at that. Uh and then actually output a plan, but it actually won't implement that plan until you tell it to. And then it will

6:29 switch to agent mode. Uh we also have debug mode here. So, we might dive into this a little bit later. Uh and that's specifically um to diagnose issues. So, you'll say, "Hey, my search bar isn't working." Uh it will go through, read your code, and it'll actually walk you through um how to reproduce the issue, and then it will monitor either um the terminal or it'll monitor debug logs that are set up. Uh it will add instrumentation.

6:55 Uh and that way you can kind of walk through how uh to debug different issues. And then we have ask mode, which basically doesn't output anything. It will just search your code base, try to answer your questions, and really really helpful for specifically more like less technical uh people or if you really are just trying to get up to speed with uh the the code base or ongoing work that might be happening. Um so, those are kind of the different modes. Uh you can select different models here as well. So, I'm sure many

7:25 of you have already seen this. If you open it for the first time, you'll probably be opted into auto automatically. But if you untoggle that, you can see kind of all of the different models. And we'll we'll briefly talk about some of the models towards the end of this. Um but I'm going to leave it off auto and I'm going to keep it on composer 1.5 right now.

7:42 Uh and then we'll also talk about these three different settings here. Right now, I'm just having it run uh locally, but we'll we'll get into work tree and we'll get into the specifically cloud a little bit later. So, right now do right now, I'm just going to uh run the app. I even misspelled the. Um so, it'll still work. Uh and basically like what this app is, I like to use it cuz it's a it's a cool demo app and it actually opens um in the the uh Cursor inbuilt browser, which I find very helpful uh specifically when

8:12 I'm doing front-end work because uh you know, especially on a laptop screen, if you're limited and you don't have a lot of screen space, uh before you have to kind of like keep swapping between different windows, uh now I can just make changes immediately. You can also highlight specific components um by just clicking this little button up here and highlighting those.

8:33 But really to get back to the whole kind of narrative here, which is like PRD to PR. So, we have this like blog app. It's called Cursor Curious. Um so, you know, it's just a basic kind of blog app right now. Um nothing too nothing too crazy. Just a couple different articles, some basic search func functionality, uh dates and things, um keywords, all that that fun sort of stuff that you might see um in an actual blog. And this is where we start to get to

9:00 like kind of the first step in this in this narrative, right? So, you have a PRD sitting somewhere and, you know, there's a lot of people that you might use Google Docs or Notion or uh Jira or Linear, for example, uh that houses a lot of your planning work, right? And houses the requirements and all all those things like that. Uh and that's where we get into the idea of MCPs, which is model context protocols. Uh I'm sure some of you have already

9:28 heard of this. Uh but basically it's just a way for agents to utilize and communicate with other tools in kind of their own language. Um so, you can actually see which ones I have active at the moment if I just go to Cursor settings here. And go down to MCP. Uh you can see that I have a bunch of these set up. So, I have like the Atlassian, uh some Glean, Granola, all these other ones. Uh but I've actually also set up plugins. So, plugins are kind of uh Cursor's way of just pre-packaging

9:59 everything for you. And you can actually go to the marketplace as well in Cursor and just add whatever whichever plugins you might want for whatever services that you actually use. That way you don't have to you know go in and edit a MCP JSON file manually.

10:17 This is all comes pre-packaged. You can basically just click on it add to your Cursor environment and really get set up with everything. So here I've already added the the linear one. So for those not familiar Linear's just another project management tool and if I swap to Linear I think you guys can still see my screen here. Um if I swap to Linear you can see I have just a couple of like demo projects set up. So I have two one for bookmark functionality and then one for comment section. So these are two projects that

10:52 let's say in my example blog app that I that I want to build and these are kind of like two projects that like the product managers you know outlined and wrote this big PRD. So you can see it in the description here they kind of highlighted all the user stories maybe the functional requirements data models UI components.

11:16 You know just kind of like a very basic PRD. It doesn't specifically talk about like implementation steps for example which I do want to highlight really just kind of like a broad like what does this functionality actually need to do here. So since I'm already I already have the linear MCP here what I can do is I'm just going to open up a new new terminal and I'm just going to say um you know what's the project description for bookmarks from Linear. And now what's a what what that's going

11:52 to do is you can see it's kind of going through its thinking process and saying hey I noticed that there's actually an MCP so again this tooling that I have access to and I'm going to try to look through the projects that are in Linear at the moment. So again if we hop back to Linear while it's kind of grabbing that information for us you should you should be able to see like all of this information that's that's getting pulled and again this this MCP layer I kind of mentioned it a couple times this is this

12:19 big like connective tissue right? Um which it is really nice because we're trying to focus in everything within Cursor so that like you don't have to keep swapping between all of these different tools. You know there sometimes it feels like there's a lot of sources of truth or you're not really sure where to look but if you have everything already connected everything accessible via this agent um you don't have to keep swapping back and forth and

12:45 like lose either your flow state that you're in or just have a lot of like mental bandwidth that you're kind of running through at the moment. So you can see that it it highlighted hey here's the bookmark functionality that I found from Linear gave us a brief a brief overview. What I'm going to say is like can you give me the full description?

13:08 It's going to go and do that and then we're going to hop to actually plan mode so you can see it's kind of spitting out the full description there. And the reason I really like using Composer 1.5 and we'll we'll talk about it a little bit later is that Composer 1.5 is like purpose built for software engineering.

13:26 So it's extremely fast. It doesn't really need to you know give you travel plans right? As some of the foundational models do or give you like legal advice or anything like that. You know it's very purpose built for software engineering and for for tasks like this it's extremely fast. It's also much cheaper than a lot of the other models. So we have this full kind of PRD and you know if I'm a software engineer I can kind of go and look through this without ever having to go to Linear cuz it's

13:54 already connected. You know scan it basically and now I'm like okay I think I understand what the requirements are asking. I'm going to switch it to plan mode and I'm actually going to switch to one of these high reasoning models. So I'm going to use like a a GP let's do GPT 5.3 Codex which I personally am a fan of um and I'm just going to say um you know create an implementation plan for the bookmarks functionality.

14:29 And as it's kind of working through this I'm going to briefly talk about kind of the delineation between these different models. So you mentioned that I or I previously mentioned that you know I was using using Composer 1.5 you know purpose built software engineering model but then there's also these these high reasoning models. So like the the GPT 5.4s the 5.3s the Opus 4.6s for example and they're very very good at thinking through big implementations big

14:59 refactors hard problems right? Um and you can see that this this agent actually deployed multiple sub agents. So in a in a brief words sub agents are basically you know smaller agents that are all working in parallel they all have their own context windows right? And they're all working towards the same goal. So this agent so Codex determined that hey there's these kind of three parallel work streams that I can work on. I'm going to deploy sub agents to address those and you can actually click on and see what each sub

15:32 agent was kind of doing and this ultimately just helps both improve the response improve the speed cuz they're working in parallel and it avoids what's called kind of like context corruption or like filling up your context too much. Too much. So as this kind of wraps up we're again we're kind of using the high reasoning model exactly for what it's for which is thinking through the actual implementation of of something that might be like complex right? So like this bookmark functionality

16:03 depending on like how this app is actually laid out can be fairly fairly complex. Um so we can see that the the sub agents have completed and there's actually going to be a follow-up question here. And I'm I'm glad it actually did this because sometimes you know I said hey just create an implement implementation plan for this. It's going to scan through all the the linear information that it had and then it's going to say hey there's some open questions that I'm not curious about.

16:32 Sorry my other screen just fell. Um and then it's going to say hey how should this actually be stored? So I'm going to say you know it's giving me a couple different options. Right now since this is just a demo I don't want to do like fully authenticated users. I'm actually just going to do a local first V1 just to so that we can kind of get it up and running. But I do like to show that that you know the PRD said one thing right? It said hey use

17:00 authenticated users we're going to have this authentication scheme but then the agent actually determined hey I don't really see any sort of authentication at the moment. Like how do we kind of want approach this discrepancy? Do we want to build the full authentication in this in this one go in the same plan or do we just kind of want to get it set up running locally? So what it's doing now is it's running through it's split it's spitting out this plan and we can kind of go in we can look at

17:28 the plan. You can actually save it too. So I actually do this personally a lot in my day-to-day work at Cursor. I will go through plan mode in one of these high reasoning models. I will save the plan I will edit it or I'll actually bring that plan to a different code base so I'll try to keep the plan like agnostic and say you know don't don't reference any local file files just reference methodologies and I will actually copy plans between different projects. That way I can

17:57 ensure that you know all of the functionality is staying the same. Um so you can kind of scan through this everything's kind of hyperlinked. Again it gives you a really nice kind of architectural diagram of kind of the data flow there. Again this is all just created by the agent works out of the box it references any previous chats that you might might do.

18:17 Um and then the next thing that we can kind of do here is again I kind of used Codex 5.3 for the actual planning. Um but you actually don't need to do it fully for the implementation. So that the high reasoning model again the thing that's really good at figuring out how to approach different problems how to solve different things we've already done a lot of the planning work. So it it it got its kind of you know money's worth if you could if you could say. Um so I'll actually switch to you know

18:44 Composer 1.5 to actually build the plan. So again purpose built software engineering model really really fast so we should get up and running pretty quickly. Um and again it's much cheaper. So I actually don't need to use the the entire full full reasoning model to do the implementation now that we already have the plan. If I didn't have the plan then I probably would opt to use the one of the high reasoning models again to think through all of these different

19:16 contingencies but since we've done the plan we were very token efficient. We didn't actually have to output all the code we just had to you know theorize about it. And then I'm actually just going to hit hit build and we're going to let it kind of rip through as it's kind of building. So as it's building this we'll come back to it. I want to briefly mention skills which some of you have probably heard of you probably used it. Um but I do want to kind of bring that up

19:42 here and I'm kind of just going to minimize this to the side a little bit. Um and if we scroll down to the skills section here we can kind of explore what's what's going on here. So, skills are in a word, like if you're not familiar with it, are just kind of these specialized predefined capabilities that agents basically have access to. So, for example, there's a couple ones that I had kind of predefined here. So, there's like add component, which specifically is like a React component

20:14 skill, and you can kind of go through and see like what this what this skill actually does. Again, you don't actually have to create the skill yourself. You know, I don't think anyone really likes writing markdown files by hand. So, we actually already pre-package everything here. So, that's why I kind of set up this new agent here, and you can actually just do create skill.

20:36 And you can create a skill for whatever you want again. So, this one is specifically for creating React components. Um, if we go back, we can look at some of the other ones. So, I have a PR to fork only. So, I actually forked this repo from somebody else, and I want to only I only want to create PRs on my my fork. So, I always do that for for demos like this. So, I really just created a skill so that if I say, "Hey, open a PR," which we will do later, that, you know, I don't have to say on this branch on

21:15 this branch or on this fork, that by default it'll just always go um to to um to my fork. So, let's check on how the implementation is going. So, it looks like it completed here, and it will provide a brief summary. So, if we close some of the skills here, and we go back to the actual browser, let's see. Cursor curious.

21:44 So, if we go back to the browser, let me expand this a little bit. I can click on this, and you can see that the bookmark's actually there. And that'll book bookmark it. Again, we're not using like any actual authentication. It's using just like local storage, for example. Um, and let's say like I wanted, "Hey, I actually don't want to have to like click on the bookmark, to or I don't want to click on the article to bookmark it. Maybe I want to bookmark here." I can always say like, "Hey,

22:16 highlight this," and I can say, um, "Add the bookmark button here, also." And now this kind of shows the ability to, you know, ingest this PRD, but also make changes on the fly. So, like let's say, "Hey, I actually think having this PRD, you know, having this button over here might work better." Um, so, that that kind of kind of highlights that the different approaches you can kind of tailor based on, you know, what problems you're trying to solve. You can also see that like, since I had previously bookmarked

22:55 this one, it it appears there. So, I do want to briefly pause for questions before we get into some cloud agents and and some other cloud things, because right now we've been running everything locally. So, if I go back to here, you can see that I've had I've been set on this local setting kind of the entire time.

23:18 But, what gets really powerful, specifically if you have to, you know, get it from your laptop, or if you're doing other things, is this cloud setting. So, before we hop to the cloud section, just to recap everything, we connected our linear MCP, we've ingested the entire PRD. We also had an agent, a high reasoning model, create an implementation plan around that PRD, ask clarifying questions, and then actually implement kind of a very basic or MVP version,

23:50 specifically of that of that PRD. And then we're going to hop to the cloud. So, Taylor or Matthew, have you ever have you seen any questions, people, or or areas you want to double-click on? Yeah, I think Marissa, if you want to expand a little bit on, you know, we've been getting a lot of questions around um one, which which models the skills know how to leverage, so maybe we can take a look at skills front matter and and just talk a little bit about how

24:20 um skills leverage and how the agent knows when to invoke a skill. And then I think the other the other piece is just pairing the right model to the right task. If you want to touch briefly on how to think about which models to use throughout this throughout the process here.

24:35 Yeah, great. Sweet. So, yeah, before we hop into cloud, let's address some of those those questions. So, yeah, skills. So, there's a couple different ways that the skills actually become invoked, right? So, there's these other ideas, these other primitives of like rules, and then there's also commands down here. So, like rules are always applied. Usually this this is tailored to more like stylistic settings like always use camel case in Python, or

25:03 whatever, as an example. There's also a lot of like security things. Commands are are usually for workflows, so you invoke those by hitting the slash command. So, you can say like, when I do slash PR or whatever, it'll open a PR in in whatever repo. And then skills are are kind of this unique area in between where you're kind of letting an agent determine if that skill [snorts] should be applied or not. So, to use kind of like an anecdotal example for myself,

25:39 I have a bunch of like in my day-to-day work, I use a bunch of skills for data aggregation. I I connected to Databricks, and it basically tells the agent how to use the Databricks CLI correctly. And the reason I like doing that is because skills are a way of saying, you know, if I if I ask a data-related question, the agent will be like, "Okay, do I have any sort of data-related skills? I might I might not, but let me just check if I do." And then it'll say,

26:11 "Hey, I do see that there's a Databricks CLI skill here. What does that say?" And it basically gives it instructions on like these reusable instructions on how to to use the Databricks CLI. Again, this is leaving it up to the agent on when to invoke it. So, an agent's saying, "Hey, the user's asking to query some data from Databricks, or create a new data visualization.

26:41 Let me look at the Databricks CLI, determine if that gives me the correct instructions to build this." You can also specifically invoke the skill. So, like let's say I said like, "Add component," and that's like a hard use this skill, right? So, you can kind of do it both ways. You can say, leave it up to the agent if you had a bunch of skills, and it'll it does a really really great job of of using skills. So, I rarely ever have to invoke it directly. But, if you just want to be sure and say, "I want you to use this

27:16 skill exactly." For example, if you had maybe skills that kind of overlap, or or that are ambiguous based on the task, you can also directly invoke it. And again, you don't have to be writing these skills. So, for example, I did not write this, you know, PR to fork only skill. I just said, "Hey, whenever I do whenever I open a PR in this project, always open it against my fork branch for demo purposes."

27:47 So, that's how I have that skill. So, when I when I say pull or open a PR, it'll have the knowledge to look at, "Hey, do I have any skills related to opening PRs? Oh, I do. Let me use that." So, that's kind of the the skill section, and you can get really really deep and get a lot of power from it. Again, I kind of highlighted the plugin marketplace towards the beginning, but that's not all that's not only just for MCPs, it also includes um combinations of skills. So, for example, if I go to I think it's called

28:25 superpowers. So, you can see I could add this to Cursor, and basically it it comes with a package of all of these different skills that are available that Cursor kind of put together for you. So, if you're just not sure like what what skills I should be using for a particular project, you don't have to even worry about like how do I prompt creating a skill for this.

28:47 We predefined a bunch of them in the plugin marketplace, as well as some of our partners. And you can really just add them to your workspace. So, there's almost like zero overhead. You just add them, and then it basically gives the agents all these specialized capabilities, specialized knowledge, and tooling, all with basically just just that one click.

29:09 So, then briefly touching on model selection. So, I I mentioned in the drop-down here, you can select between these these different models here. You can always add models as well in the Cursor settings. I've just these toggled on at the moment. But, basically anything with a little brain right now, I think which is most of them, is like a reasoning model, and there's differences between a high reasoning or like a medium reasoning model. But, just for kind of, you know, brevity's sake,

29:42 I think most people will probably be using the composer 1.5 down to Codex 5.3 GPT 5.4, probably some Sonnets, Opus 4.6, and then maybe like a Gemini 3.1 Pro. And so there's this difference between like the frontier models which are I would say the GPT 5.4, the Codex 5.3, and the Opus 4.6 models. So these are kind of like the the most intelligent, the highest reasoning, but also the most expensive models. So their input output tokens cost is extremely expensive, but

30:21 again like I mentioned when we were creating that plan, it's very very token token intensive, but very good at reasoning through these these hard problems, right? So I generally use that again for large refactors. I typically again use it for the planning aspect of it cuz I want to create a really detailed plan. And and that's a lot of what we're seeing internally as well is is a lot of the work is shifting to the the planning side of things and the

30:53 reviewing side of things. So like reviewing code as well as the planning aspect. Because these models have gotten so good at actually writing code, making sure what they're building is actually accurate and not ambiguous is super important. But also like reviewing the code that they had just written is also super important. So really trying to catch it on both sides of the spectrum there.

31:16 So again I use Codex 5.3 a lot. I use GPT 5.4 a lot and I even use Opus 4.6 a lot for those kind of large refactors, detailed plans. And then for kind of my my day-to-day my daily driver tasks, I'll usually use the composer 1.5 just cuz I like that it's so fast.

31:39 I'm sure some of you have experienced that you know sometimes you'll you'll write a prompt that's you know pretty simple and you know it'll spin for a while like if you use one of the other high reasoning models or like a Sonnet 4.6 it you know sometimes it's just hard to stay in like the actual you know software engineering flow state. So I like composer 1.5 cuz it just like does it super fast.

32:02 And again I usually save that for easier implementation details or like from just change this color to blue. I don't know where it is and composer 1.5 can can let it rip. And then equivalently there's like the Sonnet 4.6 that's pretty good as a daily driver.

32:20 And then I've even been seeing some Gemini 3.1 Pro being being used occasionally pretty successfully. So that's kind of the split is that the daily driver tasks for the easy implementation stuff and then the high reasoning models that again I want to warn you that it is a lot more expensive at the model layer for those for those GPT 5.4s and those Opuses 4.6s. Okay, so we talked about skills and model selection. And then we're going to hop actually

32:49 into the cloud section of this of this training. So we implemented that that functionality, right? Of the of the bookmarking. But let's say there was like another another functionality or another feature that we wanted to build which I actually did beforehand to make sure that it was um that it was ready. So there was this other feature in here called comment section and I want to build like a comment section, right? Which is a pretty substantial thing to do. Again, you can look at like the goals so it

33:20 specifically calls out authenticated users, non-goals, bunch of user stories, data data models, it even included a server section. Again, I'm running this locally. So that's like the other feature that we really want to build. And let's say like I'm like you know oh man I got to I got to go to a meeting, right? So I uh I'm like I I can't just like leave my laptop spinning open, the screen's going to shut off or something. You know I I got to I got to do

33:49 something else right now. I can't I can't just like have cursor open right now. So what you can actually do is switch it to cloud. And there's a couple different aspects of this. So if you actually go to cursor.com/onboard, this is really really cool and this is kind of where the cloud section comes in. So you can select your repositories and I've already selected mine. So I've already added the example that we're doing. So I'm not going to do it here. And what it's going to do is it's going

34:21 to go set up that environment in the cloud which is basically like giving an agent its own computer and environment to run run this whole app itself in the cloud so that I don't need to keep my laptop open. And I can seamlessly carry over into the cloud. So I can say you know build the comment section feature from Linear.

34:49 And I'm not I've already done this so we'll we'll look at the results so I'm not going to submit it again. But what that'll do is if I hit submit here, it's actually going to send it into the cloud and I can actually fully shut my laptop and get up and leave and close cursor because now that agent is operating autonomously in the cloud. Because I've already onboarded onboarded it. So I would always I would encourage if you're you know if you have some side projects or even in your your work,

35:18 onboard the agents in cursor.com/onboard. It'll go through and automatically set up the environment so you really don't have to do much. It probably takes [clears throat] like 20 minutes to onboard and then you'll save the environment and then you can just again connect seamlessly both from the the client itself that I'm on right now swapping between local and swapping between cloud.

35:43 And then just be able to carry your work on um again fully async which we really think is is going to be a lot of the future here. So I mentioned that I had already done this. So I'm going to go here and I'm going this is my cursor dashboard. I have a couple environments already set up that I've been playing with, right? And I'm just going to hit back to agents. And you can see that yesterday I had done this implementation. So if I click on this,

36:15 this is the the cloud section of cursor, right? So you can scroll back and you can see all of the implementation details. It uh one of the the really cool things here is not only does it you know provide the whole summary, but it actually will send you a video so you can connect this to Slack for example. I didn't do that for this demo. But it'll send you a video of the actual implementation. So I thought it'd be really cool if we just pull this up real

36:45 quick. Again, I said this is a comment section. It even added local storage. Now again, this is an agent operating autonomously. I didn't instruct it to do this. So it's going in, it's signed in, it put a test display name, it signed in, put a test comment. And now that we see that the comment actually populates for for this individual blog article here.

37:07 And it actually sent me this this this video. It's kind of showing you that like hey you can continue editing the comments for example. And it'll go through kind of these different use cases and it even highlights it. You can kind of see it in the video here which is like replying to a comment, editing a comment, deleting a comment over here.

37:27 And again this is this is really fascinating again because like I did all I did all I said to the cloud agent was hey can you implement the comments section feature from Linear. And the cloud agent even has access to the MCP tools that you had previously connected. So that's one of the really powerful things as well is that you know it'll still have access to basically everything you have access to on the client side and it'll just do it by itself. So we can

38:03 see that it worked for 1 hour and 8 minutes. So it set up the environment. It worked for an hour and 8 minutes and what that working session basically is at a high level is it'll implement some of the features, but then it'll actually record a video for itself and it will process the video. And it if something doesn't seem right like let's say the editing of the comment actually didn't work and it'll say hey I noticed that like either there's you know debug logs happening or I'm seeing console errors or like the UI is

38:36 looking weird. Let me try to reorient myself. So it'll go through the series of making changes, filming a video, processing the video itself, and then eventually after it's done working, it will send you the video as an artifact. And it'll say hey here's here's kind of everything that I did.

38:57 You can see these different sections. It also added like just some screenshots if I want to include those as well. It also added interestingly testing. So it did it just tested all the different type checks. This would also apply if you had like a test suite for example which we don't in this demo repo. And then what I can actually do here is I can say create PR.

39:24 And what that's going to do is it's going to you know merge it into our our branch branch directly. It created its own branch. And then I can squash and merge it here. I can go review the the changes. Again, you can also do this with BugBot and have it review for additional changes. But again, you can do this all all in the cloud and on the fly. So, I've actually played around with this on my mobile device. So, like let's say I'm leaving work, I've done this before, and I'm like, "Man, I really wish I just

39:52 had time to kind of like finish that up." Uh when I already have the cloud agent onboarded to my repository, uh I can really just, you know, send it either in the client back here and with a with the cloud section, or I can just hop back into my dashboard on my phone, you know, just go to cursor.com, go to go to dashboard, and then click on your agents, and and just type the prompt in there. Uh so, you can do it like that, as well.

40:19 So, that was kind of the example of the whole cloud agents functionality. Um and again, we can also do the same thing here. So, if I switch it back to local, and if we actually want to like um uh open a PR for for our book bookmarks bookmarking, excuse me, functionality, uh we can just say open a PR.

40:45 Um and now what that's going to do is it's going to you can see it kind of pulled in my my skill up there. Uh and it's actually going to go open a PR. It's going to say, "Hey, I made all of these specific changes. I think I was also on a different branch before before this demo." So, it's going to say, "Hey, I'm going to swap to this different branch. Here's the um I can copy this repo link. So, if I open it here, we can see the changes here.

41:17 I can look at the commits. I can see kind of the summary of the changes. And then, for example, if you had bug bug bot enabled on this repo, I could simply just have it run to double-check it. Um so, again, kind of like summarizing, cuz we did a bunch of stuff, right? We did We did the local changes where we were all in the cursor editor. We have the browser open. We're making active changes. We're collaborating with the agent.

41:42 We're doing all this stuff. We're pulling in the PRD from Linear. Uh and then we're actually opening a PR directly from from Cursor. And again, I didn't have to say at GitHub or {slash} GitHub. I just said, "Open a PR." It said, "Hey, I know you want to only open a PR on your fork repo. So, I'm going to go and do that." It did it. It outputted the URL, and then we can kind of go review the changes. We can merge it. Then there was the whole cloud section, which I had prepared

42:09 beforehand, which is implementing an entirely different feature on the same repo, fully asynchronously. So, it took, you know, again, like an hour, and then it sent me that video. Again, if we hop back to it, it sent me that that video of the actual like implementation. Um and then again, we can kind of open a PR from here, or we can kind of add a follow-up and say, "Hey, can you do this instead? Can you make the comments neon green?" Or, you know, "Can you add a button to

42:43 uh pin a comment, for example?" And we can handle that all all right here in the cloud. Um and this really starts to tie into automations, as well. Now, we're not going to go too deep in automations in this example, um specifically to just kind of tailor it to this, you know, PRD to PR narrative. But, automations also use this idea of autonomous cloud agents, basically just saying, "Hey, can I actually have a cloud agent on a trigger of some kind?" So, I could have a cloud agent when

43:16 there's a PR, for example, or I can have a cloud agent when there's a PagerDuty notification that that's happening, or when there's a new Linear issue that's happening. Um and you can have it do all of these different things, again, without even having your computer open. You can check on it on mobile. You can chat with it on mobile. I was literally doing this the other day. Um after work, I was like, "Hey, I want to see the progress." You can hop in here anytime to your cursor dashboard

43:44 and really just see the progress. Again, you can also connect this directly to Slack or other channels, and it'll just Slack you the video when it's done. So, you don't even have to hop in here. You can also get email completions, notification completions, and everything like that. So, yeah, we covered a lot. I can hop back to the slide deck, but I do want to see if there's any questions specifically in the last 10-ish here. Anything about cloud agents or anything

44:14 that people want to kind of double-click on? Taylor or or Matt, if you've seen anything. Um yeah, I think that there's been a few questions just around where can I go to onboard a a new repo? And so, that piece, and then I think just around the pricing for for cloud agents, and how we how we calculate for that.

44:39 Yeah, yeah. So, I think So, the pricing, like again, this is like using up your usage. Again, it depends on kind of like what what plan that you're on. If you're on a teams, enterprise, or like a solo plan. Um To actually onboard something, just go to cursor.com/onboard. Um and then you'll be able to actually add a repositories here. So, these are the ones that I've added, but you can click on add repositories. These are the ones that I'm a part of. I can configure it. You just install to GitHub. I already

45:09 have I also have it in some of the cursor projects here. Uh once you do that, you'll be able to actually select it. So, I think I call this one cursor demo hub. You can go to the advanced settings. You can add some like environment variables, for example. So, if if I needed environment variables to run my app, whatever I need to run the app locally, you basically just copy that here. And again, you can kind of think of it like giving a computer to an agent, and it being able to operate it in that way. Um

45:41 I've also gotten a lot of questions specifically about like security issues. So, you can also just only allow specific domains, so that it doesn't do anything crazy. Um for this demo, I didn't really need any restrictions, cuz again, it's just implementing the comments section there.

45:59 Um and you can also start from an existing environment. So, for example, I would do my personal environment here, because I've already set up that environment. So, once you Once you onboard, you probably won't have an existing environment. Uh but once you do, you'll be able to to save it. That way you don't need to keep keep creating new environments, and you can share it across. You can also swap the branch to to a bunch of different branches, for example. Um so, that's how you do it. I would I would suggest you

46:29 everyone kind of go play around with it. It's super fun. I love doing it. Again, you can also restrict how long something goes for. So, let me see if I can bring up uh an agent. You can see, for example, on um this MCPs section here, I can toggle any of the MCPs that I had access to. So, for that previous example, uh I toggled on like the Linear one, and I've already authenticated to it, so I don't need to authenticate again. Uh you can swap between what model's actually being used for it. So, you can

47:04 see the model selections we have there. Uh and then we also have kind of preview available, which is this long-running This idea of long-running tasks. So, for example, if I wanted to toggle this on, and some of you have might have seen this in other areas, you can set the grind until done section. But, this is specifically for like very very long and hard and in difficult features.

47:28 So, typically, you don't need to do the the long-running tasks. You can kind of just toggle it on, say, "Hey, can you implement this feature?" And it does a very very good job. And you can kind of see all of the previous ones that I had open. I had merged some previous ones, and this is the one we were just looking at here.

47:45 And you can also go to the terminal, and you can actually go to the desktop, as well, which is really cool. If you actually wanted to kind of explore it a little bit. So, I opened up a virtual desktop here, and I actually can go and click on these different things and and see like what's actually happening. So, for example, I could say like, "Hey, it seems like I'm getting internal server error when I try to click on this page." Probably because

48:10 the server's no longer running. Um since it sent it sent me this video yesterday, so it terminated the process. Um But, that's also a really really cool functionality in case you just want to play around in this like virtual environment. Again, you can also do this fully on mobile. So, if you're on the go, or if you can't, you know, open your laptop for whatever reason. Um okay, great. So, that covers most of what I wanted to cover in the demo. Any last questions here you see, Taylor

48:44 or Matt, before I swap back to the the slide deck here? Nope. Okay. So, cool. Yeah, just a couple last-minute slides. Um So, there's a couple things here, just kind of cursor as a whole. So, you saw kind of like how fast we were able to output stuff. Like we weren't sitting there for a long time, even when I was using like the high-reasoning models and using sub-agents and things like that. Because cursor had built this thing called semantic search, right? So, other coding tools use something called

49:20 grep, which is basically just like searching a code base, right? But, you know, that can be effective in small code bases, but if you have, you know, like a 2 million line code base in a production setting, just searching by like a substring or a string is going to take a really, really long time. So, semantic search is basically we're able to take in the context of what you're asking for as well as since we've indexed your entire code base in a vector database, we can basically see

49:50 like in in in all of the context, what do you like semantically mean? So, if you say I want to change the button to blue, I just said button, I just said blue. Those are very ambiguous, especially in a large code base. But even if you said that, Cursor usually gives a very, very good response that's very applicable due to the semantic search. It's also extremely fast on large code bases because of that that vector searching.

50:18 So again, if we kind of go through, I mentioned plan mode, we briefly talked about skills, a little bit about sub-agents. Um Again, we talked about the model selection here. This is kind of just some hard metrics on some of the models in terms of spend efficiency. So, again, I I really like using 5.3 codex. I find it very good for for coding.

50:40 Again, it's a coding more coding specific model. And it's again very, very token efficient. So, again, how many tokens do you actually get per per $100 spent? I do like Opus 4.6 as well, but it's with the knowledge that you know, it's it's more expensive than some of the other models available. And again, these are kind of the frontier models. So, the hardest work, the biggest refactors, the hardest features to do. And that's kind of what you use these

51:07 models for. Again, that's kind of the same thing. We also talk about this is actually some recent news. We've implemented our own benchmarking system called CursorBench. So, basically what this is testing is both performance and actual token efficiency because we're starting to see specifically in the market as a whole this conversation around price, efficiency, and things like that.

51:33 And basically this is how we've plotted the models. So, you can see that you know, GPT 5.4 has the best performance on our CursorBench. Somewhere in the middle around the the token spend. And then you can see some of the lower effort GPT 5.3 codex models actually use much cheaper or much fewer tokens.

51:58 But with slightly less performance there. So, you can kind of see it curving to the left which which generally makes sense. And then there's also this kind of idea of model selection which is the your daily drivers. So, ones that are still really good, but you know, they're not these like frontier I'm using models. So, I mentioned kind of the the Claude 4.6 Sonnet, Gemini 3 Flash is extremely, extremely spend efficient, our composer 1.5 model, and then Claude 4.5 Haiku.

52:32 But you can see also their terminal bench 2.0 scores here. So again, you're kind of trying to balance between the efficiency of the input tokens per $100 that you spend, but also like the output that you're getting. So, you know, you can have something that's very token efficient, but you know, if it's not giving you the greatest results and you have to keep prompting it 100 times, then actually maybe it's not super efficient. Same ways likewise, if you if you

52:59 if you have something that one shots a really easy feature, but it uses a 1 billion tokens or something, again not not being super efficient. And then we kind of walk through some of our multi-model agent flows. I'm not going to walk through. And then we also just have some some some tips on really how do you build this this sense of token efficiency. And we've also made a lot of internal improvements to our own cursor harness that I kind of mentioned at the beginning. So, we we do a lot of caching. We have built this

53:32 thing called dynamic context discovery. So again, that with just using Cursor's harness, so like our own proprietary infrastructure, we're reducing the agent tokens by around that 47%. Again, that's using other companies' models. And we we do that through a lot of cool, cool, cool and different ways. And then I talked about semantic search. So, we're right at the end here.

53:57 So, I do want to thank you everyone for your time. I think we'll be distributing this recording. Feel free to connect with me on LinkedIn or follow me on X. And it was great. I really appreciate you guys' time and and thank you so much Taylor and Matthew for helping highlight the highlight questions in the chat and and monitoring that.