Cursor 101

0:00 Simon, can you see this? All good? Yep, we're good. Okay, so in today's session here, I'm going to show you something that's changed how I work every day. We're going to take a real open-source code base. It's about 100,000 lines of code that I'm very unfamiliar with. It's um uh it's called Excalidraw. You'll see in a second here, and we're going to build a real feature live on top of it here in the session.

0:29 Um so but first, I kind of want to talk a little bit about Cursor at a high level. So, Cursor is a leading AI coding platform for professional software engineers. And what makes it different is that it's not just a coding tool or a plugin that's added to an editor. It's an entire full platform for AI-assisted development.

0:49 So, um it's built for the entire software development life cycle. It will help you read unfamiliar code. It will make changes across files, help you with debugging even. Uh it's going to review. It has a capability to review code for you. Uh help you ship, and even now we're sort of moving into this space here where you've got this idea of cloud agents running on their own virtual machines, um and that just run day and night. So, there's quite a lot of breadth

1:20 and a lot of depth also across the entire software development life cycle. So, it's really great that you have access to all that. Now, another differentiator I think that you'll get out of the box with Cursor is that gives you access to all of the frontier models.

1:36 Claude, GPT, Gemini, and then we have our own in-house model as well, uh called uh Composer 2. And um and that's really nice because I mean, I'm sure you've seen on the news, there's just so many models that come out all the time. And it's good to just always be leveraging and being able to be uh flexible and choose the right model for the right type of task. Um also, you know, if you're investing in a tool, uh it can be a little dangerous to pick the wrong horse. Who knows who the best

2:05 model's going to be in a year. It could be very different than what it is right now. Finally, it's extremely effective just right out of the box, you know, if you're new and you just pop it open, it's very helpful right out the gate. But also, it allows for so much customization on top of it. Um which we'll see some of that as well.

2:28 Okay, so I think it's always really great to kick things off with just some resources for you guys to help yourself get oriented as you're uh as you're playing around with the product. So, Cursor docs, I'm not going to just send you just normal docs. I think the way you navigate this is slightly different than sort of your typical documentation.

2:50 And so, you just go up here and where it says ask AI, click that, and you can ask questions in natural language. Super nice way to navigate uh a documentation. So, you can say um you know, tell me about sub-agents or MCPs. You know, just navigate it this way, and and it's really uh it answers the majority of your questions that way.

3:16 Of course, you are all very familiar with the Cursor workshops because you're in one right now. And uh here you can look at all of the upcoming events uh that are coming up here. This morning, there was a Cursor 101 in French. So, we're starting to get some native speakers out there in other languages, but also, you can follow up for more specific uh verticals here. So, for example, you can do a follow-up of the 101 to do a 201 here, more advanced kind of conversations. One on

3:45 specifically the rules, commands, hooks, and skills. These guidelines [clears throat] and guardrails to help your agent perform better over time. Um you've got Cursor for designers, really helpful. A lot of people love this. Uh Cursor for data scientists, Cursor for sales engineers, and so and so forth. Uh so, really uh really nice to have these resources to kind of go in and and learn on demand whenever you're ready. Uh and finally, in the morning, where

4:14 you're drinking a little cup of coffee or a cup of tea, wherever you are in the world, and you want to do a little light reading, uh best practices for coding with agents. This is has a lot of helpful information here. Uh you can see in the table of contents that it covers quite an extensive amount of things. Um so, a lot of resources out there, and obviously there's communities and and uh that you can tap into as well.

4:38 All right. So, uh here there are many ways of working. As I mentioned earlier, it's a platform that we're dealing with, not just an IDE, or not just uh CLI. There's a lot of things you can do, and we're going to look at this a lot right here. This is the uh IDE right here, and it's real code-centric, something more traditional that a lot of you, if you've come from software engineering background, might be used to. Uh then there's this agent-first model,

5:08 which slowly we're sort of transitioning into this space where agents have a lot more um autonomy. And so, this is sort of a small step in that direction. You're still kind of a little bit close to your code running locally, but you have sort of a familiar um interface if you're familiar with LLMs.

5:27 Uh multi-agent terminal, so this is if you've used Cloud Code, something similar like that. You can run them in your terminal. Uh and let's see, for front-end engineers and designers, this is super cool. You can have uh features around the browser. It's a fully functioning Chromium browser, and there's really nifty uh features to connect the agent to certain elements of the browser. Long-running async agents, alluded to this earlier, these cloud agents that can run in the background in parallel um

6:01 at at all times, day and night. Blood, sweat, and tears working for you. Super nice to have that. Uh you know, actually, a quick note on this, internally at Cursor, roughly 35% of all of the code making it to production are coming from these cloud agents, these agents that are running completely autonomous on their own virtual machines. So, really powerful once you dial in the systems for the agents to execute.

6:26 Uh automations across the software development life cycle. We are actually going to get to see this in this demo. Uh you can hook up some of the external tools that you have and uh and benefit from them and trigger them from Slack, from if you use Linear or Jira, task management systems, GitHub issues. You can kind of hook them all up so your agents can can access them through something called MCP, which we'll get into.

6:51 And then here you can hook up uh Cursor to uh the IDE of your choice. Obviously, um you know, we've got it was originally forked from VS Code, so if you're familiar with VS Code, it'll be very familiar with you uh for you already, but you've got some other options here, IntelliJ and JetBrains as well.

7:11 Um okay. Great. That's a lot of talking. I think it's good to um just jump right in from here. I'm going to send you guys in the link. Let's see. This link to download Cursor if you haven't already. Feel free to poke around as I'm talking. One sec. Let me find the [clears throat] chat.

7:37 Huh. I can't I find the chat? One second, guys. Sorry about this. Oh, it's up here. It's hidden. Okay. Simon, can you all see that, the link I just posted there? Yep. Yep, we're good. Okay, cool. So, feel free to download um it might be a little tricky to follow along like one-to-one, but it's always nice to poke around and and play around with the with the product as I'm talking. So, feel free to to do that. Okay.

8:14 So, all right. So, this is Cursor. See, oh, raise hand. Let's see. Do you want to uh let's see. Can Okay, uh Bruce, go for it. We'll we'll accept a a comment, but not I don't want to open up the uh floor too much here, but go ahead. Uh I think you're on mute, Bruce.

8:47 Turning on mute. Sorry, yeah, nothing for me. I'm just following along. Oh, okay. >> Okay, gotcha. Got it. There's a raise hand feature that must have been accidentally pressed. No problem at all. >> [laughter] >> Uh okay, so here is uh Cursor. If it looks familiar, that's intentional. It's built on top of VS Code, so all of your extensions, your key bindings, your themes, they're all going to carry over, and you're not learning a new editor, which is super

9:12 nice. Um one thing that is a bit different is on the right-hand side. Uh this is called the agent panel, and this is where you interface with the agent and the code base. And so, what I did is I cloned an open-source project called Excalidraw. And it's uh yeah, like I said, about 100,000 lines of code, and it's a production whiteboarding app. So, let's run it and see what it looks like.

9:37 What I'm going to do is hit command J to open up the terminal. There's other ways of doing this, too. If you take your cursor up here, and you can hit this toggle panel on the very, very top right. And I'm going to just run the project by running yarn start.

9:55 Now, I have already installed everything so that we could move quickly through that. So, as expected, it opens up in a browser the project, but I want to go back over here and show you guys something that's kind of neat. So, if I press command shift P, command shift P opens up these uh these settings and super helpful for navigating around the uh the IDE. If you've used VS Code, this probably is familiar. And I can type in uh browser.

10:25 And so, this will open up a native browser for uh inside of Cursor. And let's run it the local host in here. So, here's the project. Um let's poke around and and mess around with this. So, it looks like you can change some backgrounds. Can make some um some shapes. Very nice. Can connect them. They kind of stick to each other, which is cool. Got some free drawing.

10:59 Kind of looks like we're drawing a little John Lennon here. Nice. Uh okay, cool. So, um that's the project. So, um I think what we should do is start to implement something. Okay. So, I'm going to over here interface with the project and and have it run something. So, I'm going to I'm going to just show you sort of the end result and then we're going to work backwards together so you can see how I got there. Um because typically uh if you're a software engineer by trade and and you work at a company, uh you're not always

11:44 jumping right in and just freestyling. Sometimes, but maybe not so much in a professional environment. You're typically pulling from a backlog, you know, uh perhaps through Linear, uh Jira, GitHub issues, whatever it is that your team uses. So, um I'm going to use uh Linear and have uh I preconfigured an MCP to connect to my Linear account. And so, I'm going to write down here what are my open tasks in Linear.

12:22 Um all right, let's run that. So, right now it's uh you know, it's it's just basically looking through the tools that I have. It re-recognizes that I have an MCP server configured called Linear, and so it's going to go get that. And here it really quickly pulled up the tasks that I have uh preset up. Looks like there's two, uh Luke one and Luke two. One is a uh add a star-shaped the shape toolbar.

12:52 If we click on it here, it'll link us out to it so we could see what it looks like. And uh you know, I spent some time here making sure that the uh that the context is well articulated and well thought out. Um I have some user stories, some extra context, some requirements. Uh some scoping constraints.

13:14 You know, the this had a little bit of of work and effort to get this going. Um and so, I think what we should do is build one of these. And uh I think I'm going to choose this first one here, add a star uh shape to the toolbar. So, I'm going to open a new chat. And I'm going to type in plan Luke one add a star shape to the toolbar. Let me make sure I got that right. Luke one add a star shape to the toolbar. Yeah, I did. Okay.

13:47 So, now rather than just throwing the prompt at the agent and hoping for the best, I'm going to use something called plan mode. And this essentially tells the agent, don't write code yet. Uh research the code base first and then give me a plan that I can review before implement- implementing. So, to do that, you go over here to this where it says agent mode, this drop down. Pop that open and I'm going to hit plan.

14:14 Okay, great. Now, over here, this is another really important thing. If you've ever worked with AI in coding, uh and the output is Oh, no, sorry. Yeah. So, for planning, if you've ever if you've ever experienced very inconsistent behavior or like frustratingly bad responses, it's typically just because your context and your setup work wasn't done right. And so, planning is very, very important. Um so, the other thing that you want to think about is what model do I want to

14:44 use for this particular task. And for planning and when you're sort of uh thinking about reasoning, you want to choose like a high reasoning model, not one that's optimized for coding, but one that's optimized for for thinking. And uh there's a few different options here, and we are going to talk more about model selection in a little bit because it's really, really important.

15:08 But I'm going to choose uh GPT 5.4 because that's the best performing one for these types of things at the moment. And okay. Let's run it. So, if we watch what it's doing here, it's starting to kind of gather resources, starting to plan here. Okay, this is very cool. These three things, these are called sub agents. And I'm glad we got to see it in the wild.

15:37 So, basically, the way it works is there's a primary agent, sort of the root agent, the parent agent. And when it's taking in in a request, it's asking itself, can I delegate some of this work to other uh sub agents? And so, if it decides that it that it could, it will spawn these sub agents.

15:57 And uh the sub agents will branch off of the work tree and will uh work in their own context and implement on a task. And then they'll come back and give the answer to the parent. Super nice for paralyzing paralyzing tasks. It helps uh not bog down the primary agent with context and just more synchronous um workflows. Uh you can have about I think it's eight sub agents and then another eight for each of those sub agents underneath those. So, quite a lot of delegation. Uh

16:32 really, really powerful. Um now, another thing here that we might come up and and hopefully get to see, uh let's see. Oh, okay. So, this is nice. It came up it with a It's asking me a question. Uh and usually when it asks questions, that's a really good sign. It's trying to gather context to better uh to better set up this plan. So, let's see. What should Luke one mean by adding star shape to the toolbar? A full first-class star element drawn canvas edit resize toolbar only. Yeah, let's

17:02 let's make sure we want the whole thing. We want it to give us the whole shape. Cool. So, it's still moving. Great. So, um here where it says explored and exploring, this is another really powerful thing in Cursor. Um so, it's using something called semantic search. Uh Cursor has indexed this entire code base, and the agent can make these meaningful searches based on concepts, not just keywords. You know, typically, if you search through a code base, you do something called grep, which is searching for a specific word.

17:39 And what's nice about the way that Cursor handles this is that it can search more efficiently by ideas. So, for example, if it's searching for shapes and and diamonds, it'll it'll pull things that are adjacent to the idea of shapes and diamonds, not just the word shape.

17:58 Um this is one of the key reasons why model performance is really, really good inside of Cursor other uh compared to other tools. Um okay, great. So, now it's starting to work on the plan. Let's see how it's doing. Okay. So, we have a plan. Now, this is super important here because I'm not just going to accept it and hit go. I want to actually read through this and make sure that I'm comfortable with the approach. Uh this is where a lot of people uh might kind

18:33 of get a little lazy and skip ahead and then wonder why the output down the line wasn't what they expected. So, let's see what we got here. A goal, um add new first-class star shape to Yeah, it looks good. Some key findings, pulled some files, implementation approach, that's helpful. Interesting, it brought in some risks.

18:58 That's interesting, too. I I haven't seen that before, actually. So, one thing I noticed that it didn't do is I don't see anything about tests. And so, I'm going to specify Let's see. I don't see anything about testing for the star shape. Can you add how we'll handle that?

19:26 So, here I can go back and forth, making sure I'm really happy with the approach before any code gets writ- uh written. I might ask for more details on a certain section or like I just did here, ask for ask for uh more tests. Um and this might feel like it takes longer, but it saves you a huge amount of headache and back and forth downstream. Pretty much every power user I've I know and I can think of uses plan mode extensively. It's one of the highest

19:55 leverage habits that you can that you can build. You know, additionally testing is one of those things that uh is really important for these agents to self-correct. It's something definitive that they can point to that say, does this work? Yes or no, something binary.

20:15 Otherwise, sometimes the agent will assume something's working but not definitively confirm it. All right, let's take a look here. Give a little bit of a testing strategy. Uh Okay. All right. Looks good. I say we run it. Again, you'd probably be a little more careful here than than what I'm doing right now, but but I think it's good for the for the sake of this example. Um So, I'm going [clears throat] to actually come up here and you can see on the top

20:52 you can build and choose a model. It automatically selected composer two, which is great. That's what we want. That's cursor's in-house model optimized for coding, trained just on code, not for high reasoning, but specifically to uh to um just to code. So, let's run that. It's going to probably do this for a little bit.

21:19 All right. So, while this runs, I want to spend a little bit of time um digging a little bit into the different models and and just how to think about model selection in general because this is really going to directly impact how much value you get out of cursor. So, let's go back over here to these slides.

21:44 All right. So, model choice 101. So, I think I mentioned this earlier. Cursor is model neutral or model agnostic. Uh Simon, I saw you um uh you unmuted. Do you have Do you have something to add? Uh no, sorry. I actually went on mute cuz I'm just typing to answer these questions.

22:07 Keep going. You're all good. >> I'm sure you're pretty busy over there. No, no worries. Um >> [clears throat] >> So, okay. Cursor is model agnostic, model neutral. In other words, you can choose um the best models in the world and and leverage all of their all of their capabilities or characteristics, and you're not locked into one provider. And why does this matter? Um the top models have changed so many times in the past year. Every time a new model takes the lead, you have to you

22:41 you can have access to it immediately with cursor. So, you're always on the cutting edge without switching tools. And then also, the way I like to think about it is like you don't have the risk of picking the wrong horse. Who knows where these models are going to be in a year?

22:57 It's hard to say. So, with some basic familiarity on model selection, you can pick the best model for each specific task and make the most out of your tokens. You want to make sure that you're not overspending when you don't have to. And the way I like to think about this, a sort of an analogy, is you wouldn't use a sledgehammer to hang a picture frame. You know, it's the same idea here. Different models for different jobs. So, let me walk through the landscape a

23:25 little bit here. So, these are the top frontier [clears throat] models right now in the landscape and um Cursor, let's see. You have access Yeah, okay. So, GPT-5.3 Codex. So, that's a coding specific model. It's sitting right there at the top. This is OpenAI's dedicated coding model. It's the most capable agent of coding model available today. It's really, really good at long horizontal tasks, debugging, complex implementation, that sort of thing.

23:59 It's also 25% faster than its predecessor. So, it's it's moving in in the right direction. And so, if you're working on something that's genuinely complicated and genuinely hard, like a deep architectural change or maybe a deep refactor, complex debugging sessions, this is the model I I would recommend you reach for. Next up, you have GPT-5.4.

24:22 Uh 75.1%. This is OpenAI's general purpose flagship. It's a general model. It's strong at coding, but also really great at reasoning and and planning across domains. Uh it's a really good for planning. We use this one to plan our implementation just a moment before. Uh below here you have composer two. Now, uh this is where things get a little interesting, I think. Composer two sits pretty good at 61.7. So, just just above Opus on the this terminal bench

24:57 score, which is a third-party scoring system, by the way. But, what's critical here is that it's dramatically cheaper and faster. So, if you look at the spend efficiency um column here, it costs you 20 times or sorry, 10 times more, a factor of 10, to use Opus than composer to implement code. So, if there's anything to take away here, um make sure that you are getting the most out of your tokens by choosing the right model for the right thing. Um Opus there is still an excellent

25:34 model for reasoning, particularly complex reasoning. And so, if you are trying to think about how to plan an execution, Opus is a really great model to think about. Um but I would think twice before using it to implement code. You know, I would use either the Codex coding specific or composer two depending on the task. >> [clears throat and cough] >> Okay. I want to zoom in just a little bit um on composer two. On the left, you can see the terminal bench like 2.0 scores,

26:11 which is just what we saw there, the uh you know, this section right here, just a quick little uh other view. Bottom left tells you the speed and cost stories. So, you can sort of see how uh composer two is very fast here by wide margin and very cheap. Um Opus 4.4 is fast, but expensive.

26:34 And the chart on the right is one that really matters for day-to-day decisions. This is a performance versus cost on cursor bench, which is cursor's own benchmark that mirrors real-world development tasks. Uh you can see composer two sitting at a pretty good spot there near frontier performance at a fraction of the cost. Um so, again, practically, for most coding work, implementation, refactoring, following a well-defined plan, I would say composer two is the right choice cuz you're just going to

27:04 save a lot of money. Uh if it's a little more complicated, I would use Codex. Um for more reasoning, planning, that sort of thing, you can switch over to um uh either Opus or GPT-5.4. All right, let's check in on our star shape. Let's see how we're doing over here.

27:27 Still hard at work. I mean, if you really think about it, this is quite a lot of of changes. Um Uh Simon, how we doing over there? Any any interesting questions pop up that you that you think is worth sharing? Yeah, we've got one from from Andy, which would be what's the best source to understand best model for use case versus cost for that.

27:56 Yeah, good question. So, we do have these resources. Let's see. Did you answer that one already? I have not, no. That was the next one I was getting to. Okay. So, I recently saw let's see um see if I can find this. Cursor pricing uh models and pricing. Here we go. So, this is a really great Let me post this in the chat. This is a helpful post by cursor here in the docs that helps you navigate and think about it. Um Here's a good model pricing. Uh sort of And again, here like like I

28:36 said before, asking AI is really good. So, you know, you can kind of get more informed, more specific, and granular there. Um Could you repeat the question so I can see if I can answer it more specifically, Simon? Yeah, it's just what's the best source to actually understanding like when to use each model and what the use cases and the costs are for those. And yeah, seems seems like this has it. No, but that's a good question. Um and sure, there are many benchmarks out there that

29:09 measure different things that you could find third-party ones. I don't know of any resource I've seen like groupings of them, but I don't know exactly where to find them and I don't want to go on a rabbit hole right now. But, you could find these benchmarks and see how they score on specific types of tasks.

29:30 And you know, this is kind of a moving target. The space changes very quickly, and I'll add also that there are different types of intelligence. As I'm sure you've used different models, uh certain models are really good at some things and not very good at other things, you know. Some are really great at reasoning, some are great at math, some are great at writing poems and helping you write in general, and others are really good at coding. And being informed is really important uh, for these types of things, and for that

30:03 you just kind of need to keep up with the changes and the new models that are coming out. And resources like this here, uh, this uh, blog or this yeah, documentation on models and pricing will help you keep up to date because this is constantly being updated. So, you can kind of revisit this whenever a new model comes out, and you can kind of use this as your starting point to kind of go from there. Cool. Good good question.

30:30 Um, maybe let's give a shout out. Who who who was that? That was uh, Andy. Andy McPherson. Nice. I've I've got one more question for you if you got time that I I think would be a good one to answer live. Okay, let's let's give it a go. Awesome. So, Stephen asked, "What is the best approach for enabling cross-session awareness for cloud agents? Specifically, how can an agent in one tab be notified of the progress, test results, or way of working established

31:04 by another agent in a separate active session?" I'm going to copy that into the chat because that's a long question. Yeah, and and this this guy sounds like a like an advanced power user um, because these are really great topics for power users. Um, okay. So, there uh, so, these uh, there are these tools that allow uh, agents like MCPs for example right now connected to Linear. So, there are these tools that allow you to kind of integrate and connect with other sources,

31:38 uh, which allows you to basically create these bridges between data sources. So, if you imagine having two parallel agents running at once, and they both have access to GitHub for example, um, and they are updating um, maybe yeah, maybe they're updating the status of a of an issue. So, one guy one of the one of the agents finishes a certain task, and moves that over uh, using the MCP uh, protocol to say doing or done.

32:10 This one over here is going to be able to uh, access through MCP uh, the GitHub issues and will be able to see that uh, status change. And so, that's one way uh, you can think about communication across the uh, different cloud agents. Um, but again, this is sort of a little more arts than science here, and um, you know, you have to get maybe creative and think about what the data source is you want um, you you want to them to be shared. If you're asking more specifically about

32:43 whether these can talk to each other directly, uh, I don't think that that's uh, capability right now. Um, and uh, yeah, not not totally sure about the answer to that. Do you know, Simon? Uh, I can look into it right now, but off the top of my head I would say not currently, no. Yeah.

33:03 Yeah, we'll we'll follow up on that. Um, yeah, but but but good good question and interesting question. Uh, that's definitely uh, I think it's a topic that uh, might sprinkle references to on this call, but a 201, you know, follow up to this might get into some of the more details as to how to set up these systems so that these cloud agents can run more efficiently. Uh, very very powerful tool for sure. Um, also additionally, you know, here you're dealing locally with

33:35 an agent, but you are dealing with an agent. And so, when you're setting up these systems, um, they translate over to the cloud agents as well. Uh, you know, for example, if you're if you're building these things called rules or or adding skills or um, hooks, your uh, cloud agents also will sort of in benefit from that sort of investment in uh, in agents infrastructure that you set up. Uh, all right. Let's see how this agent did with this uh, with the star tool.

34:12 So, let's probably want to rerun it. Uh, let's see if it just worked. It worked. Okay, sweet. So, right here we can see the stars up on the toolbar, pretty good. And we can draw star. Hole in one, not bad. And if you really think about it, this would have taken me when I was a a software engineer not that long ago, like a week of work, or you know, at least many many days. This is a lot of work. I mean, you could see down here 33 files were changed. Um,

34:49 really really incredible just how fast you can you can and and effectively you could run really. And here, if you're wanting to see exactly what it did, you can click at the bottom here by the agent toolbar, click on this button that says 33 files, pops open the list of the change set, and you can hit review. And this will give us a really nice um, uh, diff view where you can see all the changes that it made. And so, it's you know, got all the type definitions. Um, anyways, this is kind of where you

35:24 would spend a little bit of time reviewing and make sure that uh, that it all looks good to you. Okay. Awesome. So, feature shipped, you know, from from idea to working code uh, in a code base that I have never worked in before. Um, and so uh, again, not to hammer this down, but I didn't just throw a prompt in there and pray, you know, we planned, we iterated on the plan, and we chose the right models for each phase, and the agent handled the code base navigation

35:58 implementation. Um, now, this sort of touches a little bit on that cloud agents question, but you might be thinking if you're coming from uh, you know, a software engineering space that that this is a lot of autonomy to be giving an agent. And you know, that's a fair thought, but the reality here is that these agents and LLMs have just gotten so powerful and so capable, and this is just trending up. You know, we're at the very beginning of this curve here.

36:27 Um, and what matters more than anything, and I I really can't stress this enough, matters more than anything is the guidelines and guardrails that you are sort setting in place for these agents to run efficiently. And by that, I mean, was your objective really clear? Um, was the context that you provided very well articulated? Um, does the agent have the signals to self-correct? For example, can it run tests as we talked about to see if it if if if it broke anything or or if it's actually working? Can it Can it run the

37:03 linters, the type type definitions? Um, these are all things that together will lead to a far more powerful, more consistent, and efficient agentic system that will work for you. And again, those cloud agents, you build out that infrastructure, and now these cloud agents benefit from this consistency as well. Um, all right. So, that was kind of a lot.

37:31 Uh, but I want to show you uh, sort of how the MCP side of things work, how to set it up. It's pretty simple, um, but it's the MCP again, just to to kind of bring it back, MCP was how I was able to access Linear. So, I use something called an MCP uh, or model context protocol is what it stands for. Um, it's basically, like I said, a way for to connect the agent to the tools that you already use. So, instead of copying and pasting context between tools, the agent can go get it directly.

38:04 And it can also write to it. Uh, so let me show you where this lives. I'm going to close this cuz this John Lennon mural is a little distracting. All right. So, on the top right here, you could see this little gear icon. I can click this gear icon and click settings.

38:23 And then over here on the left, go down to where it says tools and MCPs. Uh, and I just want to show you guys a different way to get there in case you forget that you can do command shift P and type MCP. Command shift P uh, just to say this again, is a really great way to navigate around here. Uh, helps you find some of the sort of niche little tools or uh, tools and settings that are far down uh, who knows where. All right. So, here you can see uh, a

38:58 few of the um, a few of the MCP servers that that I have. Uh, you can connect to all sorts of all sorts of them. Linear is one example that I had, which is down here. Um, but you know, you can also use Jira, Atlassian to pull tickets and and pull context from Confluence pages. Uh, you also have observability uh, tools like DataDog uh, where you can have an agent pull logs from your runtime environment and automatically uh, sort of investigate logs that have come up. Um, and let's see, there's a Figma one as

39:36 well, which uh, I haven't set up here. So, let me show you how to find that. So, let's say, you know, you heard about a Figma uh, MCP and you wanted to use that. Command shift P again. You can search for marketplace. And so, here you can just search for all sorts of different um um they're they're like little plugins and packages.

40:02 Uh let's see, Figma. So, here you could just add to cursor right then and there and you can see that it comes with this Figma MCP and uh we're not necessarily going to get too much into skills here, but it has the skills as well. Um Great. So, uh one quick note, if you are adding an MCP manually, uh make sure you always go through the official provider's documentation uh for the config. Don't be grabbing config from random third parties. You don't really know what's what's going to be happening under the

40:35 hood there. Uh like I said, for today we can we used um linear and I preconfigured and just so you guys know, when you click this, it'll open up a browser and all you do is sign in. That's it. And once you sign in, you you immediately connect the two. Um okay. How are we doing on time?

40:56 Oh, we're actually getting pretty close there. I wanted to show one more thing. Um maybe I'll speed speed run it. Or should we open up for questions? What do you think, Simon? Uh I say I say we uh speed run it just cuz I I've answered all the questions here now. So, people feel free to keep sending me in some questions and we'll I mean, Lucas will go over them at the end here. All right, I'm going to switch to another branch here. Uh was it um the demo

41:27 follow-up, I think. Okay. Make sure we're stable. Not. Oh, right. Um all right. Hopefully, the environment is where I need it to be. So, All right, I am going to add a comment. So, let's see. Up here in the agent panel, I'm going to write in the prompt, add a comment at the top of at angle. TypeScript that describes the file. Now, real quick to contextualize what I'm doing. Earlier I mentioned guidelines and guardrails and how important those are.

42:16 I'm going to show you what that looks like in practice. So, obviously, this is not a very interesting uh prompt. Just add a comment, whatever. Um but what is interesting is that I laid a booby trap somewhere in this codebase, very very far away from angle.typescript. And so, let's see how the agent handles this. So, it's running. This should be a fairly quick thing. It's just going to be writing a comment at the top of the file. Um and when it's done,

42:49 see, seems like it's done, but something's actually happening here. There it is. Okay. So, it found the issue. Um Oh, it actually found a different issue that I didn't set up and that's because I have must have not set up my environment right. But it did find another issue, which is which is great.

43:09 Um Basically, what happened here, the reason the agent stopped and then woke up again is because I configured something called a hook. And a hook is a deterministic guardrail that runs on agent lifecycles. In other words, it's kind of a mouthful. In other words, the agent doesn't choose when this runs. It will always run no matter what on the agent lifecycle that I decide. Let me show you what I mean. So, if follow my cursor to the left in dot cursor directory, I have this called

43:42 hooks.json. Inside of hooks.json, you can see some of the other lifecycle events that you can configure. Before submitting a prompt, before executing a shell command. So, you know, if you're working at a company and you want to make sure that the agent isn't deleting files uh on a whim and you just want to nip that in the bud completely, you could add something here that will always run before executing a shell command to make sure that there's no dangerous

44:10 uh commands there. And at the bottom here, I have on stop uh I configured something called grind.sh, a bash script. So, let's look at what that looks like. So, over here on the left-hand side, I'm going to open up a directory, grind.sh, and you know, it's nothing too crazy. It's not the Mona Lisa here or anything like that, but it's just going to be running the type check and uh and then the tests. And if it finds anything, it'll log the errors up to the main

44:39 agent, who will then take it from there. Um Okay. So, one last thing here. How are we doing? One last thing. If we go back up to the comment that it made, if you notice, this is a very specific type of comment. Um It's called the TS doc comment. And I didn't explicitly tell it to do this, nor is this the default. So, why did it do this?

45:10 The reason it did this is because I defined something called a rule. Let me show you what a rule looks like. So, if you go here on the left, I'm going to open this directory, rules, and open up documentation standards. So, the way rules work is you commit them and push them up to your GitHub repository. You can also set them specific to your environment if you want it just to be personal.

45:31 But um once it's up there, the agents on the cloud or your teammates can all benefit from it. And on every context, sorry, on in every chat, Cursor under the hood injects the rules that you have defined. And as the agent is working through problems, it's making a decision as to whether or not it thinks that it's a relevant uh rule to to add. And in this context, in this case, I told it to write comments. And I have a rule specifically around the commenting format that I wanted to do.

46:08 Um The teams that get the best out of this, just in terms of best practice, aren't the ones that set up a comprehensive rulebook right out the gate. It's a lot better to start with one, maybe two, coding conventions, maybe key commands. Um then, as you're working over time with the agent, if the agent does something more than once that you don't like, you add it to the rulebook. And over time, this becomes this living, breathing document that um uh that all the agents and and that your

46:41 your teammates can reference and and benefit from. Okay. And we are at time. Around We got a little bit of time for questions. Uh just a couple minutes here, but uh how we doing, Simon? I'm doing good. I've got a I've got a few questions for you though now. I hope I can answer them. If you can answer them, too, I'm happy to let you take a swing.

47:09 Yeah, yeah, for sure. Uh so, I'm going to add this one in the chat. This is from David Herman asking about token management. And specifically, he wants to know how to best manage and use tools {slash} data to learn and inspect token usage. Um an example being if I go to max mode, what will happen and what is actually happening?

47:32 Again, I'll I'll add that into the chat there for you. Yeah. So, max mode is essentially using the uh top reasoning frontier models. It's It's going to If you look at the models, the list of models, there's a little brain icon next to them. Those are kind of the more computationally intensive models that are really doing some extra thinking. Uh there's even, I think, high, medium uh little tags next to them, too. So, high, I think Opus is a is a high.

48:09 That's going to be using a lot of tokens to think deeply about your request. Medium is going to use like a medium amount and, you know, it's our kind of like hand-wavy way of telling you like, you know, expect a lot of usage from from Opus versus the others. Uh so, if you've got max mode turned on, it's going to be choosing for you, but it's going to be choosing among the frontier models that are going to be a little bit more expensive.

48:35 Uh let me see if I can get more specifics on that. So, and just so you guys know what I'm doing, I'm going right now to the documents uh a documentation and typing in max mode. Just so you guys get into that like habit. When you have some questions, you'll learn a lot more. Um Yeah, so uh max mode will consume uh tokens faster than your uh than the default context window because because of what I just said.

49:02 Um So, yeah, what else we got, Simon? Um all right, we have another question. Is there any content available about best practices and how to write rules and hooks specifically? I'll add that in the chat as well. Yeah, good question. So, yes, there are. And um let's see here.

49:28 This blog post is so good for best practices. Uh Here we go. So, also for me, I I you know, I a lot of times um using models and, you know, these these resources like the AI documentation search are really helpful to answer these questions and and follow rabbit holes and threads uh to more specific answers. But, yeah, I would highly recommend uh you read that that best practices blog post that I posted in the chat. Also, um I would recommend going to some of the older workshops uh that uh

50:18 that were posted. I'm not sure if you were here at the beginning, but there are some sessions that you can go on demand that go through a lot of really great topics. And, for example, you mentioned how to write rules and hooks. So, let's see if there's one on rules and hooks.

50:37 There is. So, let me send you this link right now. So, by Nick Miller here, and it's very recent on March 5th it came out. So, um it's going to have some of the the the more modern, you know, the composer model I think came out just before that and um or you know, the the newest version. And, so they'll they'll have good good references there. It'll be up to date. Uh yeah, good question. And, I and I think um I think we should probably call it unless unless you want to answer one,

51:17 Simon. You want to take a swing? Um Sure, I can try, but I might need your I might need your help as well on this one. Yeah. All right. So, Thomas is asking, can you explain how the predium premium model selector works? Will Cursor pick the best frontier model for my prompt based on the prompt's requirements? So, reasoning versus simple coding.

51:43 When would I use it as opposed to picking the model manually? And, I think the answer off the top of my head is that we kind of always recommend um using auto, and then you can use something like a opus 4.6 or like GBT 5.4 if you actually want to plan out like uh the actual like plan.md down whatever you're going to do and build that out with kind of a higher reasoning model, and then actual code execution can be done with like a composer 2.

52:14 Um but, for the most part, I do believe that's basically the logic that auto is already following. Totally. Um Yeah, yeah, that's that's that's a good answer. And, and also, you know, these um it's kind of hard to know what model to use uh before exploring. For example, think about this like uh if you've ever if you've ever popped open a try to fix a bug, and once you're sort of investigating a seemingly very simple bug, all of a sudden you realize that it's

52:48 this crazy race condition. Uh that immediately becomes a way more computationally intensive project to solve than if it was just sort of like a little fix, you know, uh you know, moving the thing to the side or or just a little like logic change. So, basically, it's hard to know how complicated something is until you investigate a lot of times. And, so there is no really good answer to like how do we predict how hard this is going to be before you actually implement it.

53:23 So, auto does its best to make predictions around that. Um but, you're going to definitely not be leaning on those like heavy intensive tools. It's going to be like sort of rotating around some of the uh lighter weight models, the sonnets I think and and composer for sure. Um Last thing I'll say, I know we're over, but last thing I'll say here is is just an idea.

53:48 Um There's something this idea called an agent harness, which basically, when you when you hit enter, when you write a prompt and you hit enter, it's what happens in between that moment and when the model actually receives it. And, Cursor has, you know, its own like secret sauce in there. It's going to an AWS server, and it's and it's being optimized for that specific model. And, so sometimes that's where that um decision is being made, the auto auto uh model

54:19 uh decision is being made. Um and there's also just a lot of other interesting things there, and that's what makes uh Cursor agent different than say a Claude code agent. You know, it's it's the secret sauce. Um and um anyways, and you know, uh Cursor's uh harness uh is is really really powerful. Okay.

54:41 Um you guys everybody joining from all parts of the world, this has been so fun, such a treat. This is my first time doing it. Thank you so much for for uh taking an hour out of your day to do this. Um I can't wait to see some of those projects pop up. Love all the reactions. Make it rain. Yes. I love it.

55:04 Um >> [laughter] >> Cool, guys. Well, I hope everybody enjoys day, night, morning, wherever they are. And, thanks again.