Hey guys, Cursor 2.0 just dropped today

and this thing is blowing my mind with

all the new features that they just

released. The Cursor team created new

agent mode. They built a whole new

coding model for us. They've introduced

all sorts of new browser features and

it's just insane all the new features

that they released. And don't worry

because in today's video, I'm going to

be breaking down all of it step by step.

We're going to be covering all the new

features in details, showing you some of

the limitations, what you can and can't

do with some of the new additional

workflows I'd recommend to check out.

And we have some cool model comparisons.

We have some deep dive so you can

actually see all of these different

models in action with using all the new

features. I got you covered right here

in this video. And along the way, at the

very end, I share my recommendation of

using Cursor 2.0 know versus cloud code

and which one you should do going

forward because this new model and this

new editor is just absolutely insane. So

definitely recommend you checking it out

and excited to dive into all the new

features with you. Let's get into it. So

welcome to Cursor 2.0. What I want to do

first is walk you through all the

high-level changes and features and then

don't worry, we're going to go deep into

each one of them right after. So here's

the biggest change that you're going to

notice in this new version of cursor. In

the top left you're going to see two

modes. editor, which is the mode that we

know and love where we get to work right

here in this right screen on any file.

And then over here on the right, we get

to actually talk with AI. But cursor has

introduced a new mode called agents. And

in agent mode, they are doubling down on

the fact that agents are now doing most

of the coding. And it is up to us to

just review the results and make sure

they work. So in this new mode, you get

to kind of just talk and actually just

kick off background workers. You can

kick off the background workers locally

on your machine. You can do work tree.

Don't worry, this is a huge important

feature. We're going to dive deeper into

this later, but basically work trees

allow you to like start working on a

task and it'll actually try to solve it

multiple times and then you get to go

through and say like, hey, actually I

like version three of the code change

that you made. Let's actually apply that

one to my codebase. So they have solved

a lot of complexity for us when working

on code trees. So we don't have to worry

about a bunch of background git issues

and stuff. Super excited to demo that in

just a little bit. Or you can always

kick things off in the cloud. So what

else can we do? Well, one of the major

changes that they've also added inside

of cursor 2.0 is you have a new mic

button. So what you can do now is

actually just click the mic and you can

start talking to different files and

saying like, "Oh, what I would like to

do is to start to work on my page.tsx

tsx file to make sure that it properly

has a header and so forth and so forth.

Now, this is basically like you get a

Whisper Flow subscription. So, if you

haven't heard of Whisper Flow, it's

basically this where you get to go and

say like, "Hey, I would like you to work

on my page.tsx file and make sure it has

a header." So, what's interesting is

whenever I use cursor 2.0 to speak,

you'll notice it just calls out the

file. However, whenever I use Whisper

Flow, it actually does better than

Cursor and understands my codebase and

will actually autoreference the file I'm

talking about. So, definitely like the

direction they're going, but it could

definitely use some more work. And

what's interesting is you can only talk

once you have started a new chat. You

can't do it halfway through, which is

kind of interesting. Hopefully, they'll

fix that. All right, what else do they

have? Well, let's hop over back to

editor mode. And the main thing that

you're going to notice is, let's open

this up a little bit more, is that you

now have a browser, which is crazy. This

is one of, I think, one of the other

cool features that they have inside

here. So, what you can do is click

Google Chrome, which will actually open

up a whole brand new instance of, you

know, whatever browser you're using. So,

I'm going to say, you know, can you

please open up whichever browser tool

you have selected, and we'll kick it

off. And what it'll do is it'll actually

start to figure out, oh, I can see you

have this browser. It'll actually open

up a brand new browser. Like you can see

right here, it's blinding me, but it

works. So, yeah. Boom. It's going to

open up a brand new browser, take a

screenshot to say like, "Hey, we're on a

blank page." What's also pretty cool is

you can click browser tab, and it'll

actually bring in whichever page you're

working on, and it'll do it right here

inside of your editor. And what's super

nice is cuz like I all the time will,

you know, have code in one window and,

you know, it's like this time I'll I'll

usually work on like a page over here.

So I'm like working on the landing page

on the right hand side and then over

here on the left I have the actual page

I'm editing on. And what's nice is like

as you make changes, so we can say like

hello and when as soon as we save, boom.

So it's, you know, it's looking awesome.

I really really love this feature. And

browser has an insane amount of cool

features if you're using it inside of

cursor. So this is just a quick

reminder. We're in browser tab mode. And

what you can do is you can actually

select elements. So whenever you click

select element, you can say like click

this H1 and it'll auto reference the

underlying code. It'll click the

element. So it'll have context about

what you're trying to change. And then

you can say like, hey, can you please

change this to say super fast and

affordable? And what it'll do is cuz it

auto has reference to like, oh, you're

talking about this element. Fantastic. I

will go update the necessary code to

make it happen. So that's really cool

that you can now just point and click on

the website and say like, I want to

change this. And that auto gets added as

context to cursor. This feature right

here is genuinely insane. And it's going

to make solving some of those hard UI

bugs when you're like passing in

screenshots and doing everything else

and you're like, "Please fix this." And

it doesn't do it. Well, now you just

click it and it works perfectly. So,

love this browser feature. All right,

what else do they have set up for us?

So, now that we're back in editor mode,

let's cover one of the next obvious

changes that they've made, which is

there's a whole I will set it there's a

whole brand new model in here where you

can actually use composer 1. And don't

worry, we're going to go deep into

Composer 1 in just a second. But so far,

initial testing of Composer 1, this

thing is an absolute speed demon at how

quick it can actually crank out code.

And I've actually done a few tests that

I'll show you here in a little bit. It's

performing pretty darn close to the

Sonnet models. Like they have a blog

post where they actually showcase like

they're like this close to being the

exact same as Sonnet. And so far from

what I've seen, like that's definitely

seems to be true. So this is a brand new

model. Now, what else can we do inside

of editor mode? So let's open up a new

instance. So, when you're in editor

mode, one of the other new cool features

that they have is you can actually click

whenever you're trying to work on a new

task, you can not only just pick the new

model that they've released, but they've

released a brand new mode called use

multiple modes. And whenever you click

use multiple modes, you get to come in

here and actually, sorry, I hate the

little pop-ups, but you get to actually

click what are the different models you

want to use. And kind of like what we

talked about earlier with the agent get

workflows over here. So like the work

tree, it's basically doing that exact

same approach where it's like, oh yeah,

what I'm going to do is I'm going to try

and solve this problem that you're

giving me twice. I'm going to use

composer twice and then I'm going to use

set 4 twice. So that's really cool that

they're going to be able to spin up all

those different instances of solving the

task and then we get to pick like, oh,

you know, composer one was the best or

you know, set 4.5 was the best and we

get to pick. Obviously, we're going to

burn through some tokens whenever we do

this, but we're going to have a ton of

different variation on picking the one

that works the best. So, if you're going

speed mode, man, there's nothing that's

going to compare to, you know, building

out these different task in parallel.

And I'm going to show you some really

cool examples of this in here in just a

little bit. All right. Outside of that,

I just want to show you one other cool

thing that I noticed inside the new

update. So, what you'll see is up in the

top of my browser. It's super super hard

to see, but they've actually added what

looks like a new little menu on

navigation bar of your actual computer

where you can see all of the recent

agents that were implemented. And

whenever you click on one of these

different completed agents, it'll take

you into cursor, take you to that chat.

So, it's a really cool way to like

actually see whenever your agents are

done, you can actually just on any

window, you'll always get like small

alerts of like, hey, cursor. Now that

cursor is more of a background worker,

go off and solve complex task. you get a

nice little notification that it's done.

And if you want to actually add that on

your computer, it's super super

straightforward. So, let's actually

close out of these and I'll show you how

to do it. So, all you have to do is in

your instance of cursor, you can just

type in the fact that you want

notifications. And whenever you go to

notifications, you're just going to say,

"Yep, I would like all of these turned

on. I want the menu bar so I can see as

soon as cursor is done and notify me.

Also, I'd like a little sound every time

when my background agents finishes." So,

that's another cool little feature that

I think they've added that I really have

loved. So, with that out of the way,

let's go ahead and take this bad boy for

a spin, and I'm going to show you

exactly how powerful some of the new

features such as the parallel task and

the new agent really are. All right, so

the first thing I want to show you guys

is how you can start to use the new

parallel agents workflow inside of

Cursor 2.0 to start working on cranking

out tasks so much faster. So, here's a

quick overview of what we're trying to

do for this test. I'm working on a new

project in my startup Shipkit where I

help developers launch AI applications

in days instead of weeks. And in this

example project, I want the ability to

have admin users have unlimited usage

when they're using this new project I'm

adding to Shipkit. So, here's what we're

going to do to get the most out of

working with the new feature inside of

Cursor. What we want to do is before we

kick off multiple background agents to

start working on adding in this new

functionality, we need to come up with a

plan because background agents, they're

not really made to be interactive where

they're talking to you every 2 seconds.

They're background. They give you give

them all the information, then they go

off and do the work. So what we're doing

is we're passing in a you know some

instructions to say like hey please

create a task and under the hood I have

this task template which is you know

specialized on making sure that it has

all the proper instructions on how to

create task. So, you know, this document

included in Shipkit is a huge document

that is a specialist at coding real

world nex.js applications. And I'm like,

hey, go make a task that makes sure

admins are automatically registered,

have unlimited uploads, you know, go

ahead and look at the database, make

sure that all components that normally

would block administrators, go ahead and

let them through. If you have any

questions, let me know. Outside of that,

I want you to make sure that we update

everything, including everything on the

sidebar and all these different pictures

that I have uploaded. So anywhere that I

have the word upgrade, hey, if I'm an

admin on the platform, just go ahead and

actually let me use the underlying

feature. So that's what we're trying to

do. I recommend you to do as well is to

run something like this. Maybe go into

plan mode or use something like a task

template to actually come up with a huge

monster task that clarifies exactly what

we need to do. So hey, admins have

unlimited access. Now, you have two

options at this point. Option one, if

you want to actually start working on

implementing it, what you can do is one

of two options. A, you can come right in

here and actually paste in the like,

hey, I want you to go ahead and work on

this new task document that was created.

And what I would like you to do is

actually kick off multiple models. So in

this case, what we're going to do is

say, hey, I would like to kick off one

instance of composer. I would like to

kick off one instance of Sonet 4.5. And

I would like both of these models to

compete in implementing this task.

That's option one. Or if you hop over to

the agents tab, I mean, it's basically

the exact same thing. You can pick both.

You know, it's the exact same thing. So,

we'll go ahead and click enter to send

it off. And what this is going to do is

it's going to work on kicking off the

project twice. So, you know, in instance

one, we can see which model we're using.

And behind the scenes, you can see it's

actually made like a new git tree to

where it's actually working on this. So,

this thing is an absolute beast. And

right now you can see like we're done

with three out of 10 task. Sonnet 4.5

just figured out what task it even needs

to work on. So as you can see, I'll zoom

out just a little bit so you can see how

much the thing is absolutely flying. And

we'll close out of everything. So yeah,

you can see this composer, they are not

lying. It is an absolute beast at

cranking through projects. And at this

point, it's almost done with building

out the entire functionality. If we hop

over to Sonnet, you can see it's like,

well, I'm going to work on quotas. Okay,

I'm going to add a comment. I'm gonna

plan my next move. We're not even done

with a single task yet. And the other

project, Composer, going back over

there. Composer is done at this point.

That's crazy. So, I hope you guys got to

see the sideby-side comparison of speed

cuz this thing is stupid fast. Like, I

am heavily impressed with Composer. So,

well done, Cursor. You guys have

absolutely crushed it. Now, here's what

we get to do as developers. We can at

this point if we want to check it out,

what we can do is we'll open back up our

browser tab. And what's really cool is I

know this is a little hard to see like

they've just kind of compacted

everything in, but what you can do as

soon as we're done with the task, you

can click apply. So what we're going to

do is make this as big as possible while

Sonnet is still thinking and it's 33%

done where the other one's 100% which is

crazy. We're going to go ahead and click

apply and it's going to apply all the

changes made by this one branch. So, we

can go ahead and click apply and we

should see this completely change now to

say, "Oh, you're an admin." And as an

admin, you have unlimited usage. So, it

completely changed everything. And

what's also really nice is whenever I go

click on a transcript page, it was

supposed to also ungate this. So, in the

past, this used to have a little thing

that says like, "Hey, upgrade." And now

it's going to actually generate AI

summaries. This part is not fully done

yet, but I'm working on it. And if you

ever are like, "Oh my god, I did not

like what was finished in this task."

You can always come back over here.

Let's close out and make this a little

bit bigger. And yeah, you'll have to

maybe make your screen a little bit

bigger. So don't panic. If you apply it

and it breaks everything, the undo

apply, you know, kind of goes away on

smaller screens. So we can always click

undo apply. And as soon as we do that,

it's going to revert us back to our old

changes, which is crazy that it is that

easy to swap between different models

and different attempts at solving the

problem. And guys, Sonnet is still

going. That is crazy. It makes me upset

with how much I didn't even know how

long I was waiting to actually do work.

I thought I was going fast, but you

know, Composer has allowed us to go 10

times faster. So, we'll we'll give

Sonnet a few more seconds to see if it

does the exact same things. So far, you

know, Composer, it's working perfectly.

So, we're going to let Sonnet finish

this up and then we'll move on to the

next comparison. All right. So, I just

switched up from the agent view to the

editor view. And as you can see in the

editor view, we finally finished up in

Sonnet land. And it took roughly an

additional two whole minutes to actually

finish this up, which is kind of crazy.

Now, whenever we actually go to apply

the changes, we'll expect it to update

this and our sidebar. So, actually take

this for a spin. It'll refresh. And

tada. That's working great. And that's

working great. What is crazy though is

if you actually like kind of look at the

difference between both of these, it's

actually the same. If we compare both of

these side by side. So, let's do apply.

And once again for Composer. Yeah, like

it did the exact same thing and it did

it faster and it did it way cheaper. So,

let's actually go ahead and hop over to

look at how the actual cost compared to

do both of these different tests. So you

can actually see like, man, which one

should I be using for day-to-day

development if I'm, you know, exceeding

my current usage limits and I'm having

to pay for these tokens myself. So,

let's hop over and check it out. Oh, and

if you're looking to build AI

applications in days instead of months,

you're definitely going to want to check

out shipkit.ai.

We have a bunch of pre-built

productionready AI templates for the

most common real world AI application

types such as chat, rag, and agents.

Inside Shipkit, we have courses that

walk you through everything from helping

you come up with your idea, building a

development plan, launching your

application, and more. And along the

way, we have videos and we actually have

AI scripts that do most of the work for

you. So, you don't even have to do

anything. You just tell the AI what you

want, and it'll walk you through the

entire process end to end. And we're

continually adding in new projects such

as the one you're seeing in this video,

which is teaching people how to build

background worker applications where

they can kick off AI workflows in the

background or just regular coding tasks

in the background. So, we're constantly

adding more. And if you want $50 off, I

definitely recommend using code cursor

2.0 to get a discount. I'll have a link

down description below. But enough of

that, back to the video. So, now it's

time for us to dive into the numbers and

compare our Claude 4.5 sonnet thinking

instance where it was solving the task

versus composer 1. Now, here's what's

crazy. When it comes to Claude, it

actually took, you know, almost an

additional 500,000 tokens to generate

the output. And as you saw, they were

basically the exact same thing. Then

when it comes to composer, you what's

also the craziest thing that I'm

noticing is that it is way cheaper when

you actually go in and dig into some of

the math behind the scenes. It averages

out to be close to $1 per 1 million

tokens. So this is like a blended input

output rate. But you can see it's

roughly a dollar per 1 million tokens

that we put into clawed 4.5 sonnet

versus if you do a little bit of math

and say hey how much does it cost to run

a million tokens with composer you know

one it actually takes you know roughly

33 cents. So there is a drastic three

times more cost effective to use

composer versus claude 4.5 which is

insane when you actually look at the

numbers behind the scenes because they

got the exact same result and that was

like a you know small medium task and it

crushed it not only faster if you

actually go and we're going to check out

the report in a second it's four times

faster. So four times faster and three

times cheaper like you can't beat that.

So I am blown away with this new model

from cursor 2.0. So, now that we've dug

into the actual cost, let's actually go

dig in deeper to what they announced in

their most recent blog report on this

new composer model that they just

released. All right, so let's dive into

the new blog post that was just released

by the cursor team breaking down how

they built the new composer model. Now,

the most important screen that you need

to see in this whole section is that

composer is an absolute beast when it

comes to intelligence. It's at the same

level basically as the best Frontier

model. So, I'm guessing they're using

4.5 from Claude Sonnet for an actual

comparison. And as you can see, they are

basically identical. Like that's such a

small gap, especially when you compare

speed. Like this is a four times three

times speed up when you actually compare

them against the best Frontier model.

So, you're getting basically the same

level of intelligence, but you're

getting it three to four times faster,

which is just it's insane that they were

able to accomplish this. Now, the next

thing that they break down is just like,

hey, how did they do it? And what

they're trying to showcase in this next

section is that they started off with a

base open model and through a bunch of

reinforcement learning with a ton of,

you know, comparisons of like real world

code development environments. Over

time, they were able to get to that

super high level quality of

intelligence. So, how did they do that?

I mean, I'm guessing they probably just

get a ton of information. You know,

think probably as we're using cursor,

they're probably getting a lot of

training data. They're using that

training data to then make their model

smarter and smarter. So, as time goes

on, this thing is probably just going to

get infinitely more intelligent. Very

excited to see where they take this in

the second iteration of this model. The

next thing that they focused on was

making sure that this new composer model

was more effective and properly used all

the tools available to be a better

model. So what does that actually mean?

Well, instead of doing a bunch of

sequential calls back to back to back,

which slows things down, they really

really focus on doing things in

parallel. So you can see the base model

that they started off with really wasn't

the most efficient at using parallel

tool calls, but through reinforcement

learning, they really really bumped up

the way that the agent used tools in

parallel to make sure that it moves

faster for us. The next thing that they

did, which I really like, is the fact

that Composer uses way more search and

file read tool calls, which is great

because instead of the AI just going off

and actually just guessing at what it

needs to do next, it's actually going to

be going through your code a lot more to

try to be more intelligent at coming up

with, you know, a proper solution to the

problem it's working on. So, yeah, as

you can see, it's doing a lot more

reading and a lot more searching in

parallel to get better results compared

to other models. So all around Composer,

they've absolutely crushed it. And yeah,

that's pretty much the report in a

nutshell. So, you know, hats off to the

the Crusher team. They are crushing it.

All right, so that out of the way, I

want to show you one or two more cool

things that you need to know about the

browser agent that we didn't get to dive

into, but I want to go deeper so you can

understand the limitations of the new

browser agent that you're getting inside

Cursor 2.0. Okay, so let's dive deeper

into the browser tool inside of Cursor

2.0 0 so you can understand some of the

limitations, what it's great at and see

some of the cool workflows that you can

use inside of cursor. Now, first things

first, how do you get this open? Well,

you need to make sure in order to use

the browser tab, you have browser tab

turned on and make sure your little

globe is blue. Now, if for whatever

reason you don't see your tab, what you

can always do is say, "Hey, can you

please open up?" Then make sure you call

out the word browser tab, like that is

the tool call, and then just go ahead

and give it a URL where you want it to

navigate. And then boom, it'll actually

go ahead navigate. and you can actually

see the website that you wanted it to go

to. Now, here's where one of the first

limitations that come in too using this

new browser tool. If you go to a website

that you're normally logged into on your

browser, well, hey, this is a brand new

agent browser. It doesn't know that

you're logged into your email or

everything else that normally works

inside of your computer. You'll have to

manually log in. But once you're logged

in, you can use it just like you were

using the computer. Now, what else is

awesome about this platform though is

it's great at finding elements on the

page and clicking them. So, what we can

do is just say like, "Hey, can you

please click on the calendar and tell me

which days this month we had coaching

calls?" Now, what this is going to do,

I'll kick it off in just a second, but

just quick heads up. This is my AI

developer accelerator school. We have

over 10,000 members. We have it's free

to join. We have weekly free coaching

calls like you're about to see.

Definitely would love for you guys to

join and get to meet a bunch of

like-minded AI developers. But you can

see it's going to take a screenshot of

the page. As soon as it takes a

screenshot of the page, it finds the

element. It clicks it. Then it's going

to go ahead and scrape the page and

figure out like, oh yeah, you had

coaching calls pretty much on all the

Tuesdays and Wednesdays this month. Here

are some of the key dates. And it did a

great job of actually finding everything

out. Now, here is just a cool tip of

what I would recommend to use this for.

So, one way I like to use browser

agentic browsers like this is to do

workflows for me. So if you ever find

yourself in the process of like, man,

every day I have to do my time sheet or

every day I have to go to this page, get

this information and take these actions.

Well, what you could do is just here in

your browser chat, you can just go

through the process of doing it one time

and then say at the very end to say

like, hey, can you please record all the

actions we took and turn it into a set

of instructions, save it as a file.

Usually what I like to do is I like to

save it inside my AI docs folder in my

computer and just basically say like hey

this was my do time sheet task. Can you

make sure to receive the save this as a

set of instructions so tomorrow I can

just tell you to do my time sheet and

you'll go fill it out for me. You'll

open up the browser, you'll click

around, you'll do it all. So that's one

way I really recommend checking out and

using these new agentic browser tools.

Okay, so that's doing it as a workflow.

And then one of the other things I like

to do is to actually use it to help me

make my websites mobile responsive. Now

this is where a big limitation of this

browser tool comes in. So we can say hey

what are all the tool calls you have

available for browser tool. Now what

you're going to find this works

sometimes doesn't others but what you

can see is it has the ability to do a

bunch of things. So it can navigate as

you just saw. It can click on stuff like

you just saw like it can drag and drop.

It can wait for stuff. It can look at

your console. But here's what it can't

do. It can't resize your editor. So,

this is a huge like I think this is a

big drawback that you can't resize your

screen because if I'm trying to make a

site mobile responsive, what I like to

do, and I'll have a video coming out on

this soon, but what I like to do is I

like to make my page, you know, to

resize it and have AI take a bunch of

screenshots at different, you know,

break points to see like, hey, is this

page actually mobile responsive? Are we

breaking anything? and you know by just

analyzing all these different screenshot

sizes it'll say like oh yeah things are

definitely broken on mobile view here's

what's going wrong and here's how we can

fix it. So that's one major drawback. It

doesn't it's browser tool is you know

it's brand new. It doesn't have a ton of

extra custom features yet. So hopefully

soon they'll have those incorporated.

But yeah that is the browser tool a

little bit deeper. And now what I want

to do is cover a few more awesome

features about cursor 2.0. And the final

few features that I want to share with

you guys is that inside of Cursor 2.0,

they have made it a lot easier to do

code reviews. So, you can now see

everything's a little bit more toggable.

So, I love that they're always improving

the UI to make it easier to develop

with. One of the other cool features

that they have is that you can now use

custom commands and actually share them

with your team. So, this is great if

you're working at a company or you have

a few developers under you. It's really

easy to get things shared. I will say

though that obviously most of the time

people are working inside the same

codebase. So it's you know normally like

when working on my own projects I always

just have it shared so all developers

get the same cursor rules and we're in

the same project. So pretty cool that

they did this but I'm not sure how

that's different than normal mode.

Outside of that you can see that they're

doing a few different things to make

sure that cursor itself is more

performative. This I think is super

important cuz like I don't know about

you guys but cursor hangs up a lot for

me. So fingers crossed in this new

instance it's not going to get stuck as

much and actually just continually crank

out code instead of you know making you

wait every time you open up a new

project. Then outside of that they have

a really cool feature. I believe this

was launched maybe in a combination of

previous release and now but they have

they obviously have plan mode but now

they allow you to do plan mode in the

background. So if you were to go off and

kick multiple projects off at the same

time. So like you know Claude Sonet 4

and Composer one at the same time. You

can actually kick off plans for both

chat with both plans in the background

and then have it go off and actually do

the task itself. So these are some of

the most important updates that I found

and obviously they've made the UI

prettier. But yeah, those are some of

the other big changes that they released

in version 2.0. And at this point I do

want to go ahead and give you guys my

like final verdict on what I think about

cursor 2.0 know versus like a clawed

code just so you guys can feel my

current recommendation as of new

release. All right, so let's dive into

comparing what tool I'm going to be

using now that we've covered all the

amazing new features inside of Cursor

2.0 and figure out what tool I'm going

to be using for AI development going

forward. Am I going to be using cursor

or claw code? And just for a bit of

background in case you've missed it, I

actually did a video on this exact topic

the other day comparing cursor compared

to cla code. But obviously that was

before the amazing update that we got to

watch today. So definitely recommend

checking out that video cuz I actually

break down price which in my opinion is

one of the most important topics when

working on these different coding tools.

And the main takeaway that you'll see in

that video is cursor roughly cost4 cent

per request if you're on your

subscription. after your subscription,

your $20 a month, $60 a month, you know,

you're paying per use, which is we did

the math and we found out that it was

roughly 33 cent per 1 million tokens

using the new model provided by Cursor.

Claude Code, on the other hand,

depending, you know, on the usage and

time of day, you're roughly going to pay

1 to 2 cent per request. So, Claude Code

definitely more cost-effective. However,

here's my current thought on the

situation. Claude Code is the pioneer.

they have created and done all of the

git work trees like everything you saw

today with doing multiple tasks at the

same time with testing one model versus

the other. You could already do that

inside of claw code. However, you

manually had to set it up. You manually

had to create the work trees. You had to

manually copy and create the projects.

Obviously, you could use AI to help

automate some of the process, but it's

still nowhere as near as beautiful as

this. This thing is absolutely amazing

what they've just set up inside of

cursor 2.0. So cloud code already had

these features. However, it was

obviously more developer focused who

were very experienced could already do

most of the features that you just saw

today inside of Cursor 2.0. Now, here is

my takeaway. Here's how I'm going to be

using these features. I already have a

$20 a month subscription to Cursor. So,

I'm going to be using that and a lot

more now that this is out. I at this

point already have a $100 a month

subscription to Claude Code. Now, going

forward, what I'm going to do is I'm

still going to be doubling down on

Claude Code to do all of my cranking out

of all of my different code projects.

So, you know, when I'm in cursor, I just

spin up my Claude Code and I have it

absolutely go to town and whip around

and I just open up as many different

instances of cloud code as I possibly

can to crank out all the different

features. and I have it, you know, pop

up to right here inside the terminal.

So, it feels just like the normal chat

session that you would get inside of

Cursor. I'm doing this strictly because

I don't mind the additional complexity

and I've spent thousands of dollars over

the past few months inside of Cursor.

So, at this point, my wallet is begging

me to find stuff a little bit more

cost-sensitive. So, at this point, I'm

going to be trying out Clawude Code a

little bit more and I'm going to be

trying out the new model a lot more when

it comes to using Composer One and

actually see, you know, I'll do a bunch

more sidebyside comparisons to see which

one actually saves me more money and

actually gives me better quality

results. So, at this point, the jury is

still out on which one is the best at

being most cost-effective. And I'll keep

you guys posted in a future video on

which one I think is the best, but at

this point, I could see myself w going

back and forth constantly between

Composer cuz I'm paying for it at this

point. Like, there's no I'm way past my

budget this month and between Cloud

Code. Now, here's what I would do if I

was you guys. If you are a more

technical engineer, you don't you fully

understand get work trees, you know,

like you're just you got this together.

You love the terminal. Claude code at

this point looks to be a little bit more

cost-effective if you're paying for

tokens. Now, if you are a more vibe

coder, you are more of the type of

developer who's just like, I really I

don't care about the cost at this point.

I just want to be as user friendly as

possible. I mean, at this point, nothing

beats cursor. So, if you know, depending

on which bucket you fall in, hopefully

that gives you some clarity. I mean, at

this point, both of these tools are

insanely powerful, and cursor at this

point is definitely the most UI. It is

the most effective. You're just paying a

little bit more money to get all these

nicer features. So, you know, hopefully

that helps. But can't go wrong with

either of them. I mean, at this point,

cursor, I think 80% of the population

should probably use. And if you're one

of the big power users who's very

cost-sensitive, it might make sense to

go to cloud code. But yeah, let me know

if you have any questions. I would love

to hear which one of these AI coding

tools you're using and why. Just drop a

comment down below. Always love seeing

what you guys are working on. But yeah,

hopefully you guys loved watching

everything about Cursor 2.0. So, that's

a wrap for this video, guys. I hope you

enjoyed seeing this Cursor 2.0 first

impression/ deep dive video. I had a ton

of fun playing around with this new

editor and their new model. I can't wait

to see all of your comments down below

of what you think about this new tool.

And with that out of the way, few quick

shoutouts. We have that free school

community for you guys. We have over

10,000 developers in there of all skill

levels and we have free weekly coaching

calls where you get to hop on a call

with me and a bunch of other developers

inside the community. Can't wait to see

you over there. And quick reminder, if

you are interested in bringing your

projects to life in days instead of

months, I have shipkit.ai for you guys.

Bunch of pre-built projects courses. We

have weekly coaching calls to help you

guys get moving on bringing your ideas

to life and making money with AI

development. But outside of that, I have

a ton of other AI related content right

here on this channel. Everything from

cloud code to AI development workflows

and a bunch more crash courses on all

different AI coding topics. So, I

definitely recommend checking out

whichever video is popping up right now.

And if you have any questions, drop it

down below. But if not, I'll see you

guys in the next one. See you.

[Music]