Cursor 201

0:00 You know what? We got over 100 people. I said, let's do it. Um okay. So, thanks everybody for joining us. Um I'm Ian. I I'm on the field engineering team here at at Cursor. Used to be a software engineer. Uh got out of school, got into a crazy Ruby on Rails code base with all kinds of strange legacy stuff happening in it that was very different than what I got taught in undergrad. So, uh sure a lot of folks out there similar similar boat. You know, it's not all not all

0:25 green fields. So, that's going to be a big focus of kind of what we talk about today. Um We also have Daniel on our AI deployment side for all the questions and and kind of stuff that you're probably going to be putting in the chat as we go here. So, um All right. With that, let me uh let me jump right in. Okay. So, I'd like to kind of start this off with like, you know, who should be here. And I promise we're going to spend most of the time in the product today. Not going

0:50 to not going to kill you with slides, but um you know, if you've if you've done a Cursor 101 in the past, you're looking for some more advanced workflows, cool. This is definitely the right place for you. Um you know, if you are looking to use all of the frontier models uh including what we're building at Cursor, which we'll talk about in a little bit, with you know, really optimized harnesses for each of those models, again, you're in the right place. If you're a professional developer, that's really

1:15 who we are primarily building for, but that's not the only folks that that use Cursor. You know, we've got developers, we've got hobbyists who just love building things, we've got founders, we've got all kinds of folks in between. Um so, you don't have to be necessarily a professional developer uh to get something out of today. And finally, if you just want to ship faster, like that's what we're all trying to do with with AI coding. Uh and so, today we kind of want to show you how to do that in Cursor. Okay.

1:43 So, the agenda. We'll do a a a really super fast 101 recap. We'll cover some of the kind of key concepts that that hopefully you picked up if you did the 101 in the past. We'll get into some stuff of the more advanced stuff here. So, skills and automations, uh stuff like sub agents and multitasking, you know, going from just having a single agent working on a single task at a time. Cloud agents uh are really powerful way to, you know, not have the agent tied to just just your file system, kind of set

2:09 them, let them run over time on on bigger bigger pieces of functionality. We'll talk a little bit about BugBot, which I think we're all kind of seeing this, all this code is getting generated, right, with with AI today. So, what do you do when you need to review it? Um and so, we're really kind of pushing into that part of the SDLC as well here at Cursor.

2:28 Uh and then we'll we'll cover the CLI if we have time. Um but we also want to open this up to to Q&A from you folks. So, if you have questions, you know, put them in the chat as we go here, and then we'll we'll we'll have some dedicated time for that here in in just a little bit. So, not going to be presenting at you the uh the entire time.

2:45 Okay. So, one just quick announcement. Uh first first up before we get into it, um you might have seen this yesterday. We we just launched uh our newest version of Composer, our own model here at Cursor. So, this just came out, 2.5. You can see some of the benchmarks there. You can you can dig into that. Um I think a couple things we've started to notice, it's better at longer-running tasks. It's got improved tool use and intent understanding.

3:11 Uh we even worked on the the personality a little bit to kind of make it a, you know, a better coworker uh to interact with. But, at the end of the day, like, we we want to hear from, you know, all you folks out there who are using Cursor every day. Like, we want to know how Composer 2.5 is working for you. So, let us know. Um okay. So, this is this is kind of the start of my uh my 101 recap. Uh this is something that we talked about there in the beginning, all the different surfaces where you can interact with

3:37 with Cursor. Like, a lot of folks think of us as this this IDE alone. Um that's probably the desktop app that folks are thinking of, but there are a lot of different ways you can interact with the platform. Um you can kick things off in the cloud. You can run, you know, the the Cursor app is a is a PWA on your on your phone if you want. We've got automations. We just launched the cursor SDK, which we'll probably cover in a in a more advanced session in the future that kind of lets you take our harness and and

4:02 build applications on top of it. We've got the CLI. If you're in the, you know, the JetBrains ecosystem, like we we're on the ACP there, so you can you can get cursor functionality in your in your IDE of choice as well. But, with that, let me just hop right in um and I'll cover a couple of kind of the the foundational concepts that that that often come up in the in a 101, but we want to really spend most of our time talking about more of the more of the

4:27 advanced stuff here. Um Okay, so right now you're seeing what we call the the agent window here within cursor. Um so, I'll close over my my browser here for for the moment. Um a lot of folks, you know, might be more familiar with the the IDE view. I'm going to spend my time here in the in the agents window just because I think this is where we see software engineering going in the future. You can always get um you always get to the IDE if you if you want to. And also the

4:53 code, it it's here, you know, like we're we're not trying to hide the code or the the terminal from you like you can still get to that layer if you want to. But, for the most part, I'm going to be interacting with the agent directly. I'm going to let it work on on all the code that I have um in this repo. So, a couple things to to call out here and I'm just going to go ahead and and start a new agent in this repo that I'm in right now.

5:13 Um some of the foundational stuff that we we talk about in the 101 are the different modes that are available to you. So, typically like when I'm when I'm starting out in a in a code base for the first time, um I go into ask mode. The nice thing about that is, you know, you can just have a conversation with the with the agent, essentially have a conversation with your code base, um and figure out, all right, how do how do things work in here? So, just, you know, explain this repo to me.

5:42 And then we'll say use diagrams where appropriate. Let the agent decide a little bit. Uh and you'll notice that I'm I'm using Composer 2.5 here, so you can see a little bit of that in action. Um and so the nice thing about ask is like it's not going to make any changes to the files. It's going to look through this repo. It's going to help me understand what this project is uh that I'm working with right now. And just so you can see where I'm working right now, this is an open-source project called

6:08 nopCommerce. It's .NET. You know, there's a there's a little bit of legacy here. Like no offense to the folks that are maintaining it. I think it's a a really powerful way to kind of spin up an e-commerce site, but we know that, you know, folks out there like you're working in in old, complex repositories.

6:23 Um not everything is just like Rust and and React out there. So, hopefully this kind of, you know, you you feel a little bit of where you're working today um and what we're going to show here. So, we'll get back to the to the repo self in a little bit, but so here's what the agent came back to me with. It's giving me a sense, all right, cool.

6:39 ASP.NET, it's an e-commerce platform. Cool. Um and then it's giving me this kind of like top-level diagram. So, it's using diagrams where it it thinks that they're appropriate. And so, this is another piece that we talk about in the 101. Like this is the, you know, code base understanding piece where we, you know, kind of chunk the code base up. We store those as as vector embeddings so then that when you when you prompt the agent in the future, we're able to pull the right context and send that, you know,

7:07 with your your prompt so that you get the right code generated back based on an understanding of the of the code base. Also makes it easy to find what you're what you're looking for in here as well. So, that's one of those kind of fundamental pieces of, you know, working working with Cursor.

7:23 That's ask mode. Um plan mode, hopefully, if you've done the 101, like you've experienced plan mode. Similar to ask mode, it's not going to make any changes to the underlying, you know, files that you've got in in the repo here, but it is going to put a plan in place that you can then edit. You can make changes to it. And you what the agent is going to use to actually implement the code that you're that you're trying to build.

7:48 And so I'll also talk quickly just about model selection here. Um so again, that's another thing that we we you've probably seen already, so I'm not going to spend a ton of time on it. Uh there are a couple options here I think that are worth calling out. You can go into auto, uh which is often where a lot of folks will will go. Um you know, if you're if you're working on a complex task, like put it in thinking mode. The default auto here is going to go to to our model uh composer. If you don't want to have

8:12 to think about it for a given task, like that's a great option. Uh but you always have the control here to determine which model do I want to use per task. Typically, you know, I'll use one of the thinking models like Opus 47, uh though I'm starting to use composer 2.5 a lot for this now as well, to generate a really detailed plan, and then I'm going to switch over to a cheaper model because if you have Opus 47 writing all of your code for you, you're probably

8:36 going to run out of your your token budget like pretty quickly. Have it do the plan, switch to a cheaper model, do the implementation, um and then you can start to use some of the others when you're debugging things and and ultimately like trying to run something down the line.

8:51 Okay. Cool. So, that's that's most of most of what you you you get to in the in the 101. So, from here, we're going to switch over into some of the more advanced functionality within Cursor. Um and so you already saw a little bit of this um ahead of time.

9:07 So, this is this is what I had when we first started up here. So, this this repo that we're talking about, it it's relatively complex to get things up and going. It's it's running in Docker, like there's this install process that you that you have to do. And so it it it can get a little bit complicated. Um and so I actually ran through this a few days ago. Let me scroll up back to the beginning here. So, I asked the agent, all right, hey, like I'm in this repo, like can you just get the thing get the server running for

9:33 me? Like I don't really want to know the details, like just get it up and running so I can start interacting with it. Um and so it went through the went through the process here. Uh I noticed like it it doesn't it didn't quite have everything all in in place and then later on I you know, I was getting kind of funny with it told it to bring the server down. Uh but I was like okay, there's there's there's a lot of pieces to this like it probably we probably don't need the agent to do a bunch of thinking every single time that

9:56 it brings up the server, right? Like we don't need this this probabilistic system this LLM to be doing something that has a defined set of steps every single time. And so the first thing that we want to talk about today are skills. And so skills are a way of kind of like packaging up a prompt is one way of thinking about it but also just like a deterministic action like some kind of standard path that you would go through typically like as a developer like bringing up a server. Um and so I had the agent here

10:26 create a skill for me so there's actually a command to create a skill. So let's let's put one together that brings up the server locally. Um it actually asked me a couple questions about where I want it to be at the project level or at my user level. For me it just it's a project level skill because it's specific to this repo. So it went through it did all those pieces. Um we had a little bit of a back and forth conversation and then you know, now that resulted in me when I was setting up for the demo earlier today to

10:52 make sure everything was running before we got here. All I had to do was just do this this slash command the skill for start local nopcommerce commerce and we're good to go and I'm I'm up and running um you know, with my with my server over here. So skills are and I'll show you the the menu here.

11:09 Skills are a great way like I said to kind of package up these like repeatable actions that you're doing over and over again like set up tear down um or things that you're doing you know, within any given repo. They can also live a little bit higher than that if it's a common pattern that's that's you know, beyond the level of just one one code base. You can you can put them at that level too.

11:30 Um and as you can see here there's a there's a lot going on. There's some custom stuff that I've that I've done like this this local Knob Commerce one. Um, there are also some built-in skills like creating skills and rules and hooks to make some of those pieces uh a little bit easier for you as the developer. Uh, because often times the way that we create skills internally and what we hear from from folks out you like you out there in the world using Cursor um,

11:52 is you've gone through this whole you know, you've done gone through this whole chat like I did here. Uh, and then you're like at the end of that it's like oh wow, like I want to make that repeatable for next time. That's a great opportunity to just at the end of that chat just go create a skill and then you don't have to to go through that process again and you can probably save on tokens in the future cuz then you're not going to have the model thinking about

12:12 how to do something that only has a standard you know, five-step process to uh to get it done. Um, you can also create skills and have those you know, up at the at the team level so you can expose those to the rest of the organization. So that gets into some of the kind of the enterprise admin type of stuff too. So you can share best practices across the team, but it's absolutely also something you can just do here um, you know, as a as an individual.

12:38 Okay. So just a just to recap here quickly. Um, I've got these little little kind of chapter slides if you will along the way just to kind of anchor us. So we just talked about skills, reusable instructions helping your agent do specific kind of deterministic tasks. Um, the next thing we're going to talk about are automations. So automations kind of they kind of take skills up to that they're they're they're similar to skills. Kind of take it up to the next

13:02 level of like all right, I have a I have a repeatable thing. I want to do it say over and over again on a schedule or maybe I want to do it based on you know, a trigger from some other system. So I'll I'll show you the the templates that we have first because I think anytime like I'm starting something new and in a product and I haven't tried that thing before like I always like to go to the you know, what what are the templates? What are the standard ways of

13:27 doing it so I can kind of get a sense for what are people doing with this piece of functionality. So you can see down here things like this is one of my favorites fixing a a bug that's been reported in slack and this is the kind of thing that we do internally at cursor like we have folks reporting issues that they're finding on pre-release builds and stuff in our slack instance all the time so I can I can use this kind of template I can target this to a specific channel

13:51 it's going to react whatever emoji that you want it to on completion. You can give the agent detailed instructions here. So this is where the where kind of the skill and automation overlap to me is a little bit like this these agent instructions are are really kind of a skill for this particular automation and then you can have it do things after that like this is kind of like hey what do I what do I what triggers me at the beginning here what do you want me to do

14:17 in the middle and then the very end is like okay now that we've done that action what do we do next so do I I post in slack do I open a PR based on the fix that we just made and you can even target target it to a specific model here as well so if it's something that doesn't require a lot of you know a lot of the thinking capabilities of one of the flagship models you might not be wanting to use you know 55 or 47 for that that particular task. Um I think it's worth calling out some of

14:44 the other triggers too. So in this case like we have the more of like a an action happening in another system type of trigger. We've got those pre-built for a number of different integrations out there stuff like slack linear pager duty as you can imagine like incident triage and that kind of thing. There's also a generic webhook trigger as well so if it if there's not a system that's already built here and we're adding new integrations all the time you can always trigger it via generic

15:11 webhook but I think often times there isn't you know there isn't a triggering system that's going to get us into this situation and so that's when you can set up essentially a cron job Um, so I can say hey, maybe every day at 9:00 Eastern, I want this to I want this to fire. And it wouldn't necessarily be the kind of thing that you would do here for for this uh this Slack triage. Um, but that's another entry point, you know, for getting a for getting an

15:37 automation to run. You can do it on a schedule like that. And just to flip over to some more team ones here, like you can see that uh the diggery on the on the FE team has this daily kind of like making sure that we're WCAG compliant in a particular repo automation going, just because like that stuff it can change so easily. And often times, you know, developers, right? Like we're not we're not necessarily thinking about accessibility all the time when we're building things. So, having that daily sweep kind of

16:05 happen, look through a particular code base, make sure we haven't introduced any sort of like issues that are going to break our our WCAG compliance. Like, that's a type of, you know, long-running, on a schedule automation that you can use. Um, and then of course, like you're seeing some high-level metrics here around like which ones were successful. You can see that we had some failures. So, you can dig into the details there, um, as well.

16:27 So, it's not just like a black box. The automations are running and you don't know you don't know what's happening behind the scenes. Okay. Cool. So, the next area that that I want to get into here, um, are sub agents and and multitasking. Um, so kind of kind of similar. Uh, and this is this is an advanced topic because most of the time, you know, when we're interacting, at least early on, with a coding agent like this, like we're giving it one task, we're waiting for that task to complete, and then we're moving on, um,

17:00 to the to the next task. And so, there there are a couple areas where, um, I'll I'll talk about sub agents in a in a second in in a in a slightly different context. But for now, I'm just going to spin up a spin up a new agent here, um, which again is another kind of best practice from the 101, hopefully that that you picked up where if you've ever gotten to the point where your context window is at, you know, 50, 60, 70, 80, hopefully not 90%, like the the quality of the output that you're

17:28 going to be getting from that agent is really going to go down steeply. Um and so often times a best practice is if you've got a new feature that you're building, um you know, spin up a new agent for that because then you're going to you're going to have the full context available to you there.

17:44 Um all right. So, let's we'll we'll we'll we'll give it a we'll give it a mar- multi-part uh task here. And I'm going to switch it into multitask mode so that we don't just have the single agent working on everything and and kind of waiting for the one thing to be done. Let's say we're going to add 429 rate limit error handling to all API controllers.

18:07 Exponential back off. Cool. All right, that's that's task number one and then we'll add a rate limit log event. Admin error dashboard. Oh. Cool. Um all right, nice. So, given this given this prompt and the fact that we're in multitask mode here, um the agent is going to spin up multiple, you know, other other agents um and I can see them here at the bottom. I've got two separately working. I can click into each of these to see the progress. Um so I like to use this say if I have a back end change and a front end change,

18:55 like I'm adding, you know, some kind of new chat functionality say to like a new website or in this case like we're doing this this we're doing the the error handling um with the 429s, but we also want to add the admin side of that as well. So, we have like a back end change and a front end change. It's a great opportunity to spin up, you know, multiple agents here. Each one can focus on its particular its particular area. They're going to do their own

19:19 independent kind of like understanding of the code base. And the nice thing with with multitasking as well as like sub agents, which you you may have seen before, um if you've done any like code base exploration, especially with one of the thinking models in cursor, um the the sub agents have their own context window. Um and that's nice because kind of the the the main agent that's in charge here, it doesn't have to have all that context. It's just handing off

19:45 those tasks to the to the sub agents. They do their own thing. They've got their own context, and then they essentially just kind of hand off that finished work um to the central agent once they're done. Um so there's a lot of power in that. And there's there's not not really a limit.

20:01 Um would would encourage you to go out and try to find it in terms of the the number of of different tasks you can work on in parallel. Um but there's a lot of power in this, so you don't have to just kind of wait and do things like sequentially, blocking, you know, one task at a time. Um you can really start to, you know, parallelize that effort and have multiple agents um all going at once.

20:23 All right. So, that's multitask. I'm sure there'll be questions about that, and we'll get into that uh in a little bit later. We'll do some some some of the live Q&A. Uh the second piece just to just so you can see it happen. Um so I'm going to switch over to one of the thinking models. Uh And I'll just say explore this code base. This is a spot where you can see um you can see one of the the built-in sub agents that the cursor has running here.

20:47 So, in terms of code base exploration, um if you're using a one of the thinking models, you know, like this, typically they'll they'll spin up a they'll spin up a sub agent um using potentially like a one of the one of the cheaper to use models. Um actually didn't look like it didn't look like it did it there. So, you'll you'll have to you'll have to take my word for it on on that one. Um so we saw the we saw the multitasking, but the the the idea is we have some of these built-in subagents um

21:17 for things like code-based exploration. There are also you also have the ability and you probably saw that earlier um to create a subagent. And so what I way I the way I kind of like to think about this is like a skill is, you know, an action that you have uh you know, the agent taking for you.

21:35 A subagent is almost more of like a full like give it give it a personality. Like give it a give it a role. Like this is the subagent that handles, you know, generating tests. Or this is the subagent that's really good at it's it's like a it's the technical writer. It's going to generate documentation for us as we're we're building code along the way. Um so that's typically a good best practice if you want to create a subagent of your own, you know, give

21:59 them a give them a role like that. So that then when maybe one of the one of the thinking models is going to start spawning some subagents, it knows what it has available to it and it's like, all right, part of my you know, part of my directive here is to ensure that everything is well tested that I build along the way. Okay.

22:17 So again, just to just to recap, subagents, multitasking, you know, kind of similar ideas here that we don't want you to just have to wait for one single agent to work on one task at a time. Often times things are touching multiple pieces of the code base that are that are independent like front end back end changes so you can spin up multiple agents to work on those different pieces at the same time. Um okay.

22:43 So next thing here uh we want to talk about is cloud agents. Um so for the most part, everything that we've been doing here has been working as you can see off of my my local, you know, copy of this of this nopCommerce repo. Um so before we before we kicked off here, I actually um had a had a cloud agent that I set up to go through and do more of a long-running task. So, what that looked like here, um because my my repo is is is hooked up like the the cursor app is is allowed to to access it in GitHub, um I'm able to

23:20 spin up this cloud agent. Essentially, what that does, it spins up a VM. So, you can see over here it even has its own little desktop terminal. Um it checks out a copy of that code base. Um it's going to implement the plan that we worked on together. And then it's going to it's going to let me know, you know, how that that how that went essentially. Um so, it's able to do this long-running task. I don't have to sit there and babysit it for it or or wait for it and and babysit it. Um and it even opened a PR here into um

23:51 into my repo, my my nopCommerce repo. And cool, I was I was hoping this worked. I wasn't totally sure, so I didn't want to say it yet. Uh the other thing that cloud agents are able to do is record a video of themselves um kind of doing a demo of that feature that they just implemented within a within a given repo. So, I I made slides for me. All right. Well, that's something to that's something to work on in the future cuz I I wanted a demo of it actually working, not a demo

24:20 of slides, but all right. Well, the agent and I will have a conversation later. But hopefully you get the idea there. Um you know, when you're working with a with a local code base, like you do have to be there. Like your laptop has to be open uh when you're going to be working on a on a particular feature. Cloud agents allow you to kind of step back, kind of be the be the CTO of getting this this feature feature live and to market. The agent has its own isolated environment that it

24:47 can test in. And I think importantly from like a like an enterprise, you know, security perspective, right? Cuz we all work at at at companies that have security postures, that VM then gets torn down um after that process is finished. You don't have to worry about like, oh, is my is my code base sitting there sitting there long-term over time. Um So, we'd definitely encourage you as a takeaway from this, um if you haven't explored cloud agents yet, definitely

25:13 give those a give those a shot. And if you're in a more kind of regulated environment, we also have other options for um more like a self-hosted approach there. So, if you have questions on that, let us know. Um but let me let me pop back here, kind of recap the the cloud agent side. Like I said, you know, they they run in this isolated environment. They're able to do these long-running tasks without you needing to kind of sit over there over their shoulder, close your laptop, come back later, see that it's been

25:39 implemented. Hopefully, unlike in my case, they give you a video of the feature actually working, um and they they stick to that plan that you've that you've put in place. They can open a PR like we saw there at the at the end of the process. Um okay. So, I've got one one or two more. We'll call it one for right now, things to to show you before we kind of get over to the more of the the formal kind of Q&A section here. Um So, and you might have seen this on the on

26:07 the PR a second ago. Uh like I was mentioning, you I think we're all seeing like so much more code being generated now. Like if if you're a heavy user of of agentic coding platforms like Cursor, like there's probably a lot more PRs going in in your organization than, you know, the the folks that typically would review them have time to look at. That's really the bottleneck that we're starting to see in the SDLC today with a lot more AI in there.

26:33 So, I opened this PR up. Um I've got a couple of them here earlier, and so I actually have a trigger um on this repo to use BugBot. So, I'll I'll tell I got to probably back up and tell you what BugBot is. So, BugBot is um essentially like a reviewer for you for your code base, you know, powered by the the agents that the cursor exposes. Um it's integrated here into GitHub. So, every time I open a PR in this particular repo, BugBot is going to fire. It's going to look at the changes

27:06 that happened. Um and then it's going to tell me not only like are there any issues that it might have identified? So, in this case, um we've got some security problems. There's some some you know, some keys being exposed potentially. Probably not great.

27:20 And so, that's it with with this this huge volume of code generated, like it's going to be able to catch a lot of that stuff that a that a human reviewer would typically have to do. And so, hopefully the idea over time is that that we the human reviewers get to the point where like we're just looking at a really really nice summary that the agent has put in front of us of like, "Hey, the the other agent generated 3 million lines of code. Here are the seven things

27:45 that you the human reviewer with expertise in this organization systems should look at and decide on before this gets, you know, merged." And the other nice thing about this is I can actually go immediately into fixing this in cursor. You can also set it to just automatically fix things that it that it finds, but in my experience, oftentimes, right, like professional engineers, like we we want to kind of see what's happening. We want to click the button. Um we don't

28:09 necessarily want the agent to be going and doing that automatically. But I think over time, like that's where that's where you want to get to. You want to build that level of trust where you can you can say, "All right, you know what? It's fine. The agent can just fix stuff that it that it finds.

28:21 We're comfortable with that." But in the meantime, um I can push this over into cursor and I can get it fixed. Um and then the nice thing is that the the bot is also going to have an idea of the fix that needs to be put into place. So, hopefully that gets you from, you know, PR open, you know, reviewed, issues found to a fix in a really, you know, tight tight loop um that's going to make that make that a lot easier than if you were having to review every single line of code uh that's getting created by by the

28:49 agent in the first place. Um So, just uh to hop over here quickly so you can kind of see what the dashboard looks like. If there are any, you know, folks on the engineering leadership side out there, like you have these sorts of like dashboards to see what's happening um for things like BugBot. We're also doing this on a security, more of a security focused front that's probably something we can save for a for a future session, but you can see these high-level metrics like over the

29:12 last 30 days, how many PRs were reviewed, issues that were resolved, um and, you know, automatic fixes, like I was mentioning earlier, that emerge. So, you can see all that detail. You can dial it into specific repos. Um so, there's a lot of power in here, not just in terms of of what the agent's actually doing to to find those problems and fix them, but also this high-level view cuz, you know, we all have a lot of different code bases out there and a lot of

29:36 different teams working on them. Having this central view to see like, how is this how is this having an impact over time, um you know, justifies I mean, the having the agent do the review as well. All right. Cool. Um so, let me pop back over here. Well, here's our here's our recap. Uh just so we, you know, we're all on the same page. The idea is is to be able to to review all all the PRs that you have out there. Um similar kind of triggers like we talked

30:07 about with automations earlier. Catch bugs before they reach production. Um Have those fixes proposed in line and then have the ability to take action on it kind of like point another agent at it to actually implement the fix. Um okay. So, the last thing uh and I know we want to make sure we've got plenty of time for for questions here. So, if somebody has a question on the CLI, I'll I'll pull it up live. I've got it running on a on another screen, but I

30:31 think I I I like to make it clear that, you know, kind of like what we we talked about earlier, a lot of folks think of of Cursor as just this just an IDE, an IDE that has some AI baked in. And hopefully, you know, what you saw today is that we're pretty far beyond that. Like you can get into the IDE view if you want it, but really, you know, we see ourselves as as much more of like a control plane around a lot of different agents that you have running on different tasks at different times.

30:58 They're automations. They're things running in the cloud. Um and I think for the folks out there who are like me, you know, I I I came up on on Vim. You know, my manager at the time wouldn't let me use an IDE of any kind. It was like, "We're all using Vim." So I still colon write quit everything all the time. If you're somebody who likes to work in the terminal, um or you want to get Cursor working inside of another IDE that you you prefer, um the Cursor CLI is the way to get to

31:25 that. You know, it still has the the Cursor harness, the ability to go into the different modes, use all the different models that we expose, but do that, you know, from from a from a command line. Okay. And with that, um actually, yeah, I forgot about this one. One last thing, just to just to kind of call it out. I I I tried to point it out as we go through here for the most part. Um you know, certain certain situations call for different, you know, different

31:51 models for for better token efficiency. Um we do a lot of that behind the scenes. Like that's that's what the Cursor harness is doing. And and we we really have specific harnesses like for all the different models out there because each one has these nuances, right? When you're working with them. Like we try to abstract that stuff away so you don't have to think about it. Like you can just focus on building and and keeping the lights on at your organization. Um

32:16 but a couple of, you know, practical tips here. Like I was mentioning earlier, like the thinking models, they're really great for putting plans together. Um so always try to use plan mode if at all possible. It's going to it's going to save you in the long run because you probably don't need the flagship model to actually implement the the code for you. Um would highly recommend giving Composer your Composer 2.5, out now, a shot for that in terms of actually doing the implementation post plan.

32:43 Um again, we'd love to love to hear your feedback on that. And then, you know, there are often other models that are really good for things like debug and triage, like GPT 5.5 and and 5.3 code X are are really good in those pieces as well. Okay. So, with that, that's everything I was I was hoping to to show today. So, I think Daniel, I'm sure we I I was I was seeing my thing pop up with uh with questions a bunch as we go through here, but anything that you you think we should

33:10 try to answer live? >> Yeah, I saved a few. And thanks for everyone for posting in Q&A. It's been super helpful. Um but if you could just walk through that self-hosted agent idea that you mentioned um more for closed environments and maybe demo some of something around that, that would be helpful. >> Yeah. Yeah, let me um let me see what I can I can pull up behind the scenes here, but uh I'll I'll I'll at least like talk talk you folks through it um in the meantime. So,

33:37 the idea behind the the self-hosted or the yeah, the self-hosted cloud agents is it's you still the same benefits of having having a cloud agent, but the agent or the the container that it's running in isn't in our infrastructure uh at Cursor. So, the idea behind that is you can set up essentially like a pool on a on a machine that that you have uh something in your network that has access to you know, say if you if you have your your source control is like totally

34:08 on prem um or you have different different servers and like different tools, like different MCP servers that are only exposed like within your network, um you can have that container essentially running within your network, so that all those pieces happen there.

34:23 I think one thing that I I do like to call out on that cuz often times people hear like self-hosted and they think, "Oh, we're going to like the model inference and stuff is going to be self-hosted, too. So that that's not the case. Um Um the all of that all that kind of pre-processing like working with the code base the isolated VM like that would happen within your infrastructure, but then the agent is still going to have to call out like to hit the to hit the model providers. Like if you're using

34:50 one of the Opus models like it's still going to have to hit Anthropic's API in order to do that. So it's not like a totally on-prem thing, but for environments where you have stuff that is just never going to be able to hit the internet, um it's a it's an option there.

35:06 >> Wait. We had a few questions come up that I wanted to save live that were based on cloud agents. Uh and the first one is just on can we trigger cloud agents via Slack? >> Um yeah, I I believe I believe you can. Um yeah, cuz we So there's a there's a cursor again at cursor command in in Slack. Um Let me see. I think I've got my I think I've got a demo instance of Slack here I can uh I can try to pull up and see if we can get that get that going. Yeah.

35:42 Okay. Nice. All right. Um and that actually a good opportunity to show some other pieces too. So this is also this is also the result of some automations and some like security reviews and bug bot triages that are happening that are getting sent back to me uh here in Cursor. But yeah, so I can also Here we go. The kind of the how to use how to use Cursor thing here. So this is the idea like kind of like I was mentioning earlier with that automation,

36:07 um you can you can at mention Cursor and have it, you know, fix a a particular issue like in a in a particular repo. So um at Cursor and say Since I know that it's got access to that repo, um so so yeah, I can I can kick this off and then this is going to this is going to have to use a cloud agent because it you know it doesn't have the context of my of my file system and and everything here.

36:36 Yeah. Cool. And so the agent's kicked off, and then I can yeah I can I can click into it and it's you you don't want to see it set up all the all the different pieces there, but but hopefully that gives you a a sense of of how that works. >> Sweet.

36:49 Thanks Ian. Are you uh could you give some more color on the code quality of the code that cloud agents are are putting through and maybe some of the guardrails that are built in um to make sure that they are running properly. >> Yeah. Yeah, that's a it's a good question. I think in terms of the in terms of the quality, I mean you're you're going to see the same the same level of quality that you would um if you were running running the agent like from the from the desktop app. Like it's it's the same models, it's the same

37:23 cursor harness, like all those all those pieces are still there and like you know if if it's running on our infrastructure like you know com- compute isn't like an issue in terms of running the the VMs. Um in terms of guardrails like that that is where it starts to get uh get interesting here. Let me let me see if I can get in. Um So and this is I think probably maybe a more advanced topic um down the line, but there are some of these other pieces beyond just like skills that let you put

37:51 some some guardrails into place for how how the how the agents are able to function. One big one is hooks um and hooks are are really like truly a a deterministic thing that'll that'll happen um you know before or after the after the prompt. Um and so like this is like actual like code that's going to execute in in the shell. So often times we'll have people use this to look for certain certain types of data that they might not want to have come through in a

38:20 prompt. So um so there's a lot of power in that and so those hooks can be applied and then the, you know, the cloud agent isn't going to be able to do anything um, if it if it's in violation of that of that hook. Uh, and then there are also some, you know, some kind of specific pieces around uh, like default models that get used um, like if you don't want to auto create PRs, like there's there's some settings and stuff that you can put in place that are specific to cloud agents,

38:46 but but generally um, things like hooks are are often like what we're what we're using whether I'm interacting with an agent like in the desktop app or I've got a cloud agent going. Like those those kind of things you can build once, hopefully share across the team and across the different types of agents as well. >> Awesome.

39:04 Another question here from Eric, super interesting on just uh, model selection and best practices. What do we advise our customers and just general cursor users on when they should use Opus 4.7 versus composer uh, when it comes to just general thinking and then execution?

39:23 >> Yeah, it it's a great question and it actually I think the answer might be shifting um, and I I would love I would love for people to try this and like and let us know. So the the answer before composer 2.5 came out yesterday by the way, was you know, use Opus 4.7 or GPT 5.5 cuz it's a little cheaper than 4.7 like to do the thinking. Like those models are really good at the thinking and reasoning and putting together like a really detailed plan. Um,

39:51 and then from there like I was mentioning like those those tend to be, you know, significantly more expensive than than something like uh, like a composer and so um, typically it's it's best to to then switch to, yeah, like in the past it was composer two. That was often like our kind of standard recommendation was like hey, if this is like a a pretty complicated thing, have 4.7 do the plan, then give it to composer to actually implement the plan. Because composer is

40:19 really good with code. Like that's what we fine-tuned it on. Um it's good at understanding it. It's good at generating it. Not that it's not good at planning, but you know, open source 7 is historically like edged it out. I think we don't necessarily know if that's still the answer given composer 2.5. Like we've been using a lot internally. Like I've been seeing good results with it doing a little bit more of the reasoning side of things. is also another thing that's that's that's

40:47 pretty significantly improved with with composer 2.5 is the ability to kind of like decide what's a what's like a high effort versus a low effort task. Um and like not not over engineer things too much. So I think we may be seeing a world where like you know, you you might be generating some plans like with with composer 2.5 now.

41:11 Um it's something that I think I'm going to start trying out a little bit. You're still not going to you're not going to go wrong having like one of the flagship thinking models do your plan and then have have composer you know, do do the implementation. But if you're if you're really looking to control like costs you know, you might look into having composer 2.5 do the do the plan for you too. Because if you can get the results that you want kind of side by side against one of the flagship thinking

41:37 models then you know, that that'd be your that'd be your answer. If you if you I would do a formal eval on it though. You know, don't just don't totally distrust it, but I think we may be seeing that answer kind of shift over time. >> Now another question on how does cursor handle context window limits when working across very large mono repos and how do you prioritize? What gets prioritized in the code base and what doesn't fit?

42:04 >> Yeah, that's it's a great question. Um so there there are a couple pieces to it. The the way that we So when you when you first use like a particular code base with within cursor, when you first open it up, um we we do some like indexing of it. So, essentially like breaking up the code base into like pieces like functions um and and like chunking it up, creating vector embeddings, and then what gets stored is like long-term is a essentially like just like a vector database of all those different pieces.

42:36 So, then the this cuz I we often get this question like the actual code like it's it's there ephemerally and then it's we we delete it. Like we don't we don't want your code base any more than you want us to have your your code base long-term. Um but then that vector database is is used like when I when I prompt um the agent to do something here, like when I was having it, you know, I was having some issues with getting sample data loaded into nopCommerce earlier, um

43:03 like it knows that there are specific files that are related to like the sample sample data loading. So, it's going to do some of that semantic search to figure out like what are the most relevant pieces of the code base, and then those are the pieces that are going to get like pulled into the context window, um and then ultimately like that's what the what the model's going to have to work with to determine like what's our what's our output. So, that's

43:25 like the a big part of the the harness. Um You can you can specify um you know, particular files. Like if you if you know like if you know the code base inside and out and you're like, "All right, I don't I don't want them you know, I don't want cursor to have to think about that. I'm just going to say specifically like this is this is where I want you to look. Um You know, you can you can at-mention files and and specify them and ensure that they make it into the into the context. Uh generally we're we're pretty

43:53 good at determining the right stuff and not overloading the context window with too much um too much bloat. But I would say like when you start to get at a point like this, like I'm I'm getting up close to 50% for me personally, I kind of hit 50, 60, and I'm like, "Okay, it's it's probably time to time to time to move on to a new one." You can also break this down and see exactly like what is filling up the context window at any given point. Um but often times what I'll do is uh got to type it right.

44:22 It's chat for a new agent. Um you can just do this when you're kind of hitting that limit. Uh summarize what you've done what what you've done up to this point. Um and I think what's what's important is like you know, just the chat itself, like it's got a lot of the back and forth, but like hopefully the the real source of truth, like the real context that the next agent's going to need, like is the code base, you know? It's it's the commits that were made by the previous agent. It's like new code that was

44:50 generated. Hopefully some good documentation in there, so maybe you've got that sub agent doing documentation. Um and then I can take this. This is like a, you know, a effectively very tiny amount of text. I can copy this and start a new agent, and then I don't have to worry um about the context window filling up for for this one. Uh and that that's often why we say like if it's a new feature, um it's a good opportunity to just like spin up a spin up a new agent to to work on it. Like

45:17 we don't we don't want the whole code base in the context window. Like that we're we're not we're not doing that. >> Maybe a bit of a rogue question here for you, but I think it's good to demo. So, I love in your uh nopCommerce, could we potentially demo design mode using Composer 2.5 given it came out yesterday just to show some of the capabilities?

45:38 >> Yeah, that's a that is a great question. Um Okay, so design mode, um which we haven't talked about yet. A lot of a lot of power in this if you're on the front end side, or you're say on the back end side, and and someone is asking you to do some front end work. Um Good opportunity. So, you come in here.

45:57 We're in the the built-in browser in Cursors. Um and then I can just target, you know, specific elements uh that we've that we've got in the UI here. So, let's say, all right, on this on this categories div, um let's lowercase this and give it rounded rounded corners. That seems good. Um and then hopefully you saw in the you know, that I was able to select the model that gets used um when I'm here in design mode as well. Uh and so now instead of me kind of having to like prompt the agent with the specific area

46:34 that I wanted it to focus on and then it has to like find that in the DOM. It's it's probably going to do a good job of it, but it's it's also an an opportunity for it to just like burn tokens on something that I could just I could just click on. Like I know the exact thing that I wanted to look at. Um so it's going to go through. Hopefully it'll uh it'll do a decent job here of of making that change. Um I'm going to have to Yeah, I'm sorry. We'll We'll let it reload everything.

47:03 Reload it. Bring the Bring the whole Bring the whole container down and uh yeah, we'll we'll let it do some of those pieces, but yeah, design mode um there's a lot of power in that, you know, in terms of like I mentioned like saving saving on on tokens by like not having it do some thinking about figuring out exactly, you know, where you wanted it to look um in the DOM. I think it's also a good opportunity to like bring in folks who might not have as much of a technical background um

47:33 to be able to make a change like this one. Like folks on the product side, business analysts, like and this might result in a in a PR into production, but it's also okay if this is just a way of like someone kind of visually communicating to the engineering team um like, "Hey, here's here's a thing that I think we should do." This is something like we try to do at Cursor is like, "Hey, our engineers are obviously very busy building the product like if I can kind of target them to a specific area and

48:03 say hey, a customer was asking about this like here's how I think we could do it. They're probably not going to do it exactly like I did but it's an opportunity to maybe get them a little bit more context before they go in and try to actually make a change. Yeah, that was a good one.

48:19 >> Awesome. I love the the live Q&A and funneling that into and previously previously not done demo. Could we do a little bit just diving into maybe clicking in on that 56% context and diving into how cursor is able to show your context window and then also just walk through if there is a specific way to see what percentage of the context is used for agentic workflows.

48:48 >> Okay, so the yeah, so the piece you're seeing here and this is this is relatively new that we're we're kind of breaking it breaking it down this way. I mean it's just into the into the categories like the system prompt hopefully is always going to be pretty small like tool use often like if you're if you've got an MCP server and you're loading every single tool in it like I I've seen that and it go crazy in terms of of blowing up a context window.

49:13 So you can dial it into the specific pieces here. Um I'm not I'm not quite sure on the on the second part of that though like the like the what specifically like for agentic work. I don't know Daniel if you've got if you've got thoughts on on that piece.

49:29 >> Yeah, I haven't seen it specifically for just isolating like a complete agentic workflow but as you see here you can see if you're using certain sub agents that you're either spinning up yourself or your actual parent agent is spinning up you can isolate that but just seeing it for agentic versus maybe ask plan mode etc. is is It's interesting um is an interesting ask that we can think about.

49:54 >> Yes, yeah. >> Um that was all the questions. I did uh mention the chat. I I saw some uh folks raise hands, but I don't think that we're able to um have you guys ask questions live. So, if you have any more questions, please feel free to put it in the webinar chat um or the Q&A. And if not, then uh we can give you guys a minute to do that. And if not, we can we can potentially end this early.

50:19 >> Cool. >> I'll give you guys about 10 seconds. >> Let me uh I like at my notes here and see if I had anything else I was if I had anything else that I cut. Here we go. We got more. All right. >> We got more from Jerry. Um if you can show how to integrate with Teams. >> Okay. Yeah, so I um Let me have the All right. Make sure I don't have anything else going on in here.

50:53 Okay. So, I I actually just installed um our our our Teams integration pretty recently. So, this this might not be the the the complete demo of it. I would I would, you know, suggest giving it a giving it a shot on your on your own. I believe we're just like um Actually, let me Let me pause that again. Let me get a browser up here. And get to the actual page. Uh All right, there we go. So, I think we've got the docs. Yeah, so it should be Yeah, it's just it's under integrations.

51:28 So, for the for the actual setup piece, um yeah, so same way that like historically we we've done Slack and and other platforms like that, there's a Teams integration. So, it's like a first-party thing here. If I go to manage, it's it's it's on the Microsoft marketplace. You can install it. Um you probably need to be an admin of your of your Teams instance. Uh and then once you do that, it's very similar to to how you saw the Slack integration functioning here as well. So,

51:54 like you can see like I I I I tried to ask it a question, let me know that I I don't have my cursor account linked yet. So, I I linked it up there and then um this is it's it's exactly the same. It's like it's it's got the agent. It's able to spin one up, um answer any questions that you that you might have. And then this is it started it started up, you know.

52:14 Luckily in in nopCommerce so I can go and then I can look at whatever's actually happening um in that agent. So, a similar idea of like a if you want to if you got to fix in a particular repo, um you know, you're you're just you're just starting up that that agent to work um on one of the repos that it has access to.

52:35 There's There's probably more in there that I didn't that I missed cuz I'm I'm still I'm still figuring out exactly how the Teams integration works that's different from Slack, but but yeah, that hopefully that gets you what you need to know to at least get started and and yeah.

52:48 >> For sure. We also got a suggestion from Keenan on doing another webinar on MCPs specifically working with cursor which I think is a great idea. Um and I'll suggest to our our growth team cuz that's something that we uh love in terms of our product offering. Um question, another one, are there any tips and tricks for using cursor cloud effectively to get the best results in QA processes?

53:11 >> Mhm. Yeah, I uh I think it when it comes to um when it comes to actually like generating generating tests, um like this one this one's near and dear to my heart. Uh in in a past life I I worked a lot more like closely with the like the API testing side of the world. Um I think uh you know, a few things that are going to they're going to help you be successful there. Um and it's it's kind of similar to just you know, when you're when you're working with with the agent in general. I think ensuring that you have a good

53:41 picture of the of the code base. Like so doing some of that early like code base understanding before you you know, before you start to like generate tests alongside with the with the code that you're building. Um but I think like I mentioned earlier there might be an opportunity whether it's a skill or potentially even a full sub agent. Like I think those are those are pieces that you could hand off, you know, especially to a sub agent. Like if

54:06 you have one that's that's built around doing um like doing testing and has the context around your repo so you can give that sub agent like all the context that it needs about your preferences for for how tests work, like the the other platforms you're using, like even context into like the users who are going to use your platform. Um the more that you give it like the better that that it'll be able to then you know, run. Anytime you've got a cloud agent going like and you can put that into a you can put that into a

54:34 rule so that like maybe if it if a certain part of your code base is touched, hey ensure that to pull in the the the sub agent that does testing so that that you've got full test coverage there. You can also have that be something that like bug bot looks at when you when you open PRs to ensure that you have like not just test coverage cuz like you we we can all get to 100% you know, but like is it actually testing what you wanted to what you wanted to test? And I

55:01 think like giving it the context, like the underlying models, I mean they're they're they're smart. Like you can give it the context about your end users. And I think we we we often kind of forget that. It's like we're we're building software but it's like who's who's using it on the other end? And I think that'll also help you kind of get a better picture of it, you know, for the agent to get the best tests in place possible.

55:23 And also have it run them. Um like sometimes the agent's going to do that on the on its own, sometimes it's not. That's another thing you can kind of explicitly bake in as a rule or as part of a skill so that when it does generate tests, it runs them. If they don't pass, it figures out why and you can kind of set it onto a loop of like iterating over that over time until it it passes all the tests that it's written. >> Awesome. Maybe last question that we

55:49 could answer live. I'm also typing away to try to get as many answers while Ian will answer that. But this is a this is a good one. So for setting a custom marketplace, what's the best practice to test a new version of a plugin or a scale before shipping to all? Like to choose a branch so we can use stable or beta user groups. >> Hey, yeah, that's a that is a that's a good question and I I'll pull up the the marketplaces. I don't I don't actually know offhand um

56:17 when you add a new one if it uh Is the marketplace? Where am I at? Yeah, I that's that's a good one we might want to we might have to look into um cuz I like I know you add it, you know, obviously we view it via like a like a repo that you have out there, but I I don't remember if there's like a like an only me option or if it's enabled for everybody by default. Um So, we'll we'll look into that one uh and I'm not sure what the follow-up mechanism is exactly here, but uh but yeah, we'll

56:54 we'll check that one out. I would I would recommend looking at just like the the screen where you where you actually load the custom marketplace and just seeing if there's an option to set it to like just you. That's that's where I would start. >> Oh, actually I I misspoke. Maybe one more. It's given we have a minute and a half.

57:11 Uh it's from Tim. Um really cool content. Thank you. Uh how does Cloud Agent how do Cloud Agents work across multi repos and different programming languages? As an example, he has Ruby, Node.js, and React.js repos. He wants to make sure that the change he's making is done simultaneously across the multiple repos. Any tips or tricks on the matter?

57:30 >> Yeah, that's that's a that's a pretty new one. Um the in terms of the the cloud agent being able to work across across multiple repos if I'm remembering right from from something that we just launched pretty recently. Um so I don't I don't have a great answer a great best practice for you off hand yet. I think that's probably another good one for um probably like a future webinar cuz I think it's it's it's going to come up and um yeah, so wish I wish I had a better answer for you right now. I'd say like

57:59 definitely the the pieces that are out there like hooks and skills and some of the pieces you can kind of package up to ensure that the cloud agent, you know, on one repo is is acting how you expect it to are still going to be part of the part of the picture, but I think that's something that we need to kind of put out there into the world of like best practices of having a cloud agent working across multiple Wait.

58:22 All right. Well, guess we're we're about it about a time here. I'll put my I'll put my thank you slide up again here just cuz I I appreciate everybody showing up showing up today. Hopefully you you learned something something new um and uh I'm sure we're going to have, you know, more advanced and and like role specific workshops in the future. We've already got some ideas, right? So >> Totally. You're getting lots of positive feedback. Amazing content and great job, Ian. Um and just to answer a lot of you

58:49 guys had asked about whether this is recorded. It is. It will be posted on the cursor.com/workshops website which will link you to a YouTube page that will have the video. Um so thank you guys. >> I All right. Thanks, everyone.