Cursor just allows you to remain in flow for so much longer during your coding sessions, and for real power users

out there who are building complex applications, especially with AI agents that have to integrate with a lot of different systems, it helps you with

three key things. The first one being design decisions. If you're trying to make decisions around your code base or

your architecture, you know that you have to constantly look up things, constantly reference other material just to make one choice. But this kind of goes away

when you're able to reference your entire code base in a single one-line command and also the web at the same

time, plus your documentation. So Cursor really helps with this, like, information retrieval step that a lot of technical folks have to do when they're

building out these products. And so if you don't have to spend a lot of time looking up and triaging information, you

can spend more time on the core functionality of what you're building. So overall, it's just the time saving that

kind of piles up day after day. And we've seen this with a couple of folks here; people with literally not that much

experience are able to build full-stack applications with Cursor, and I think that is one of the powerful bits of this

IDE. It really hones in on your skill set and magnifies it. If you are someone who is really good at coding, you're able to

already build full-stack applications; using this is only going to make you better. If you're someone who is just

starting out, using this is going to accelerate your learning journey. And all of these smaller features are building

up to something a bit larger. I think Cursor is introducing to a lot of folks, which is meta-coding, and I've been

playing around with this idea for about a year. I've been using Cursor for a while now to build out a lot of my agent

projects, especially on this YouTube channel, and there are a couple of key components to this meta-coding we've

moved from coding everything manually to more of a prompt-review workflow. And now, some might not want to do this because

AI sometimes generates really bad code, but the idea is, as it gets better at code generation, we move more into a

review role. So, similar to how engineers work today, there might be a head engineer, and they're just reviewing PRs

from junior engineers. Essentially, Cursor gives you a small team of engineers at your fingertips, where you're constantly

reviewing PRs—not in a day or two, but like literally in a few minutes, you're reviewing a PR. And from that perspective,

you can move way quicker than a whole team of engineers if you know what you're doing with Cursor. Right? So you do

have to be a power user to really get the most out of this. I wouldn't say that someone who has no experience coding is

going to outperform someone who has 10 years of experience and is using this tool as well. And we're getting away from

this copy-and-paste workflow, which gives you really disjointed code; you end up having a lot of spaghetti everywhere, and

it's more that, instead of going to ChatGPT or Claude or Stack Overflow—I'm not

judging if—if you still go to Stack Overflow, absolutely not; there's some good answers there—but we're getting

away from doing that and more staying within the editor and doing it right there. So there are a couple of key

features that allow you to not have to switch tabs but get the information you need immediately, instead of wasting a

lot of time trying to find docs, trying to synthesize all that information, which, at this point, is getting to be a lot.

Especially if you're building AI agents, there's just so much stuff to learn; there are so many frameworks. At some point,

it just becomes too much for one person to soak in all that information and make sense of it. I just talked about this a

bit, but it depends on your skill set. Really, if you are someone who is very skilled, it might just be an intern for

you, where it generates the code and you give it really specific instructions on how to generate that code. Whereas if

you're not as experienced in the project that you're doing—for example, for me, if a project that I wouldn't be well-

experienced in is like maybe building something for a Raspberry Pi, I don't know, or like building components for a

front end—I'm not the best at that. I can use Cursor as my design partner, as my little CTO, to help me really put

together good components. Whereas if I'm building a backend in Python or I'm stubbing out an API, I need Cursor to

act more as like the intern, just generating the files and creating things for me. I like to think about it from

the perspective of a head chef. Right? So head chefs usually work in a brigade system, and they have other chefs

working behind them. The chefs are using their recipes; they're using the same tools, but the head chef's job is just

to taste what's going on and then make sure that the final product that goes out to the customers and goes out to the table

is really good. That's your role, too, when you're using Cursor. You can think about you having a bunch of little mini-chefs;

they're making meals for you, and all you need to do is make sure you taste and approve how things are going out and

make sure the final product is really good for the customer. Let's think about it from the perspective of like concrete

steps that we want to take to make sure this workflow is good. One of the first things you need to do is start with a

template. If you want Cursor to generate a project for you, that can go pretty well in certain cases if it's like a

really known problem space, really known libraries, then yeah, sure, maybe Cursor can generate the entire thing for you. But what I found more often than not is

people have more complex problems and it's not going to get it; it's also going to give you a lot of spaghetti code, so

you're better off not doing that and having to clean up that mess and start with a template you know well. Now the

reason you want to start with a template is because the entire code base now becomes context, and when this entire

code base is context, you can use the code base to generate more parts of the code base. It's almost like agents

building themselves. The second part here is you want to have your deployment path pretty much baked in. You don't want to

be trying to have Cursor figure out how to deploy your solution because it may get a lot wrong and also might break an

environment that you're deploying to, so you should still be in charge of that deployment step, and you want to have it

in the template.  It follows some type of software engineering conventions. Now you may throw your hands up and be like, I

don't like clean code, I don't like domain-driven design and all that, but the fact is a lot of AI has been trained

on data that has a lot of that stuff baked in. So when you talk to an AI model

and you say, 'Hey, use hexagonal architecture,' it knows exactly what you're talking about and where you might

have to struggle to explain that to another engineer who's not familiar with it. The AI is going to pretty much be

able to spit out those types of components that will illustrate this example. Here, I do have my own template

as well. This is something I've been using to generate agents in AWS using Amazon Bedrock, which is not the most

complex thing, but it's definitely not as trivial as using a couple of frameworks. So you do want to have this templated

out. And basically what I've done here is I've given Cursor the opportunity to just review my README. In my README,

I have a ton of instructions. I actually went over this process in my last video where I built out an agent that actually

codes; does a lot of the things Cursor does, but I did it in Python. And I gave it a couple of instructions and it could

build out an API. You can check that out over here. And so I've taken the same approach, but this time I just threw in a

README that explains exactly how this project works: it goes through the prerequisites, the development environment, how to install things, the

deployment, the project structure itself, how to configure the agents and their infrastructure, and then how to do the

runtime as well. And then I throw in a little license there, so if this gets trained in the future, anyone can go

ahead and use it. It is under the MIT license. The main point I want to make here is that before you start jumping

into all the Cursor features, before you start working with it, make sure that you have some type of template that you're

starting with. This is just going to increase your chances of success at whatever coding session you have, and I

want to make sure your expectations are realistic. A lot of people are showing you very tiny use cases that are simple,

where I think anyone can generate them, maybe like a front-end component, a landing page; those are really cool and

really great because it's going to save people a lot of work, but those are the most known cases, the most likely we know

that path already. There's a million examples online on how to do it. When you're working with AI agents, it's going

to be different. AI agents are pretty new, so you're not going to have a lot of examples in the training data of the AI

on how to build these agents, so you're going to have to do a lot more work up

front to provide Cursor with some context on how to do this. And it helps if you know how to do this without

Cursor. Next up is you're going to want to index your docs. Your docs are going to be the baseline of how Cursor can

make up for the gaps in its training data. So if you're using libraries like React or Stripe, indexing them and then

having them during your coding session just to reference really quickly is going to help you, because often times it's

just you literally forget how to do it per the library. And so the more familiar you are with the framework, the more

you're able to avoid really steep learning curves and just use Cursor to fill in the gaps for you when you don't

know the library. You can run into this problem I call recency bias because the LLMs are trained on data that's, I think,

2023 or 2024. If a library literally just came out yesterday, it's not in the

training data, so it's going to be on you to spot-check and understand what is going on, where the issues are, and when

it makes a mistake because it's not going to clearly tell you that it's made a mistake. And in Cursor, that's just

available here in the features. If you go over to the codebase indexing, you're going to want to see that your codebase

is indexed, and then you can have a couple of libraries here that I have. A couple libraries that I like to use

control flow, SST, ion, Dagger, Palumi. And so these are the tools I use, and I've chosen to index here. It also comes with

some out-of-the-box—I think you can have things like React; that's already here. So React is already here, and if you want

to use something like Stripe as well, it's already in there. So they've done a lot of work to get the popular libraries

in there. But of course, if you are not seeing your library, just simply add a new doc and index it for yourself. Number

three is actually extending the template. This is why I found most people give up with Cursor. They've generated the

project; they've seen a demo online; it's worked really well in the demo, but then when they go to actually do the

work, it's failing. Of course, it's going to fail. Uh, nothing really works on the first try. Again, Cursor is a powerful

user tool; it's not really meant for just the casual programmer. You're going to need to pick up after it; you're going to

need to understand where it's making a miss and also where it's really strong at. I put together this little table here

Building AI Agents FAST with Cursor and Claude Sonnet 3.5

Scripts