Cursor 2.0 is game changer

Cursor just dropped Cursor 2.0 and

Composer 1, their very first model. In

today's video, we're going to check out

both Cursor 2.0, all the changes they

made, and we're going to test out their

new model. Sit back, relax, let's get

into this video. Now, this update is a

huge one, not only because cursors

entered the model arena, meaning they're

going to be competing with both

Anthropic and Open AAI. And this is a

very interesting decision on their half

because they get so much data from all

the code changes you and I accept. It

was only a matter of time before they

started creating their own models. And

composer is a pretty good model. I would

say it's under 4.5 and GPT5 codecs in

terms of intelligence. But what it lacks

in intelligence, it makes up for speed.

It is incredibly fast. And I'm going to

show you how fast it is. And then they

share that they've built a new

multi-agent interface. And this is sort

of given me a glimpse of the future of

what it means to be a developer, an

engineer. And there's no better way than

to show you how these things work. Now,

the first thing I want to show you is

Composer 1. Like I said before, it is a

really fast model. Let's just do a

sample prompt. Please summarize all the

features that exist in this codebase.

All right. And I just want you to see

how fast the file reading happens. Look

at all that. Now, let's compare how fast

this and this is a pretty large

codebase, by the way. I'm going to

compare how fast this summary was to uh

GPT5

uh codec. So, we're going to use GPT5

codeex and hit enter. And you're just

going to see the the difference is night

and day, right? Composer is a really

fast model and I find that fast is fun.

So, when vibe coding or just building

simple features, the fact that it can

move so fast is pretty um you know, it

just hits the dopamine. Um, Composer is

a pretty fast model. Not as capable as

GBT5, Codeex, and Sonnet 45, but it's

really close. It's pretty up there. Um,

I threw at it some pretty big tasks and

it was able to do it. And it's great

because it's fast. Now, this agents tab,

I don't know if you noticed it, there's

a split between agents and editor. and

agents feels like a more clawed

codeesque uh feature where obviously

this is not in the CLI but they're

almost telling us you don't need the

code you don't need to look at the code

and could this be the slow execution of

getting as far away from the code as

possible maybe but here's what's cool

about the multi- aent interface I don't

know if you see this 1x uh button right

here but if I click on it I can deploy

four composer one instances but here's

where it gets That's even cooler. I can

have one composer one. I can have one

sonnet 45. I can have GPT5 codeex. And

then I can have a prompt, a task, a bug

fix. And guess what? Composer is going

to take a stab at it. Sonnet 45 is going

to take a stab at it. And GBT5 codeex is

going to take a stab at it. But if I'm

running it on local, I can only have one

model running. in order for me to run

multiple models and to not have merge

conflicts and any of those issues and

files being deleted and models working

on top of each other. Basically, for

every instance, it splits the work tree.

It makes the changes there and then I

can merge those changes into the main

working branch. And this is pretty

awesome. So, let's actually run a test

where I'm going to have composer,

sonnet, and gpt codecs. We'll just have

one of each. and we'll say, "Please

change the design of this app. Make it

feel more futuristic. Use the monospace

font. And it needs to feel like this is

a hacker dashboard, a trader dashboard,

something like Bloomberg terminal." So,

we have our prompt. I'm going to hit

enter. And here's what's cool. We now

have three agents working on this

particular problem, three different

models. And you can see the speed

differential. Composer has already

started to write code. GPT5 is still

thinking. Sonnet 45 is still reading.

Right? So you can see the speed between

composer GPT5 codeex and Sonnet 45. And

this is also a cool way to see which

model is better, which model solves that

problem. Instead of copy pasting each

problem to a different model, trying to

figure out which one's going to solve

it, you can now have all three, four,

five, even seven running, I think, all

at the same time. So you can see

composer one is done. GBT5 codeex still

not writing code. Uh Sonnet 45 just

started writing code. So I can click on

review and I can see the changes it's

made. I can see the diffs here. I can

choose to apply these changes if I want.

I can also have a unified view if I

want. I'll have a split view here. Just

makes more sense for me. And here's

another cool feature that they launched.

I don't know if you've seen this browser

icon, but I can click this and I can

click browser tab and it opens up a

browser. So, I can have a browser

running in my cursor IDE. So, I can go

to localhost 3001 and I have my project

running. Now, let's say I want to apply

all these changes cuz I trust composer.

I don't know if you noticed the button

change, but it's more square now. The

signin button. Now, I would have to log

in. For the sake of time, I'm just going

to go to a logged in version of my app

and I can see the changes composer one

has made with the border radiuses and

all that good stuff. Now I can go to

sonnet and it's still working. GPT5

codeex is still working. If I like the

change that composer made, I can create

a PR and then again opens up on my

GitHub repo. I have a PR in. I can click

this pull request. I can merge this.

This is really the future of product

development. And in one case, I don't

like this future because I like writing

code. But in another case, we can't deny

if the models get good, if they get

better, the difference in time that

you're going to save from writing this

stuff manually is night and day. So,

just to summarize, the multi- aent

changes they've made. I can now spin up

multiple agents. I can get them to work

on the same task. I can even spin up a

new agent instance, get that working as

well. I can now view my project on a

browser. I can even click Google Chrome

and it will spin up a Google Chrome

instance. I can use the browser tab,

have it right on the browser. Here's

what's cool about the browser. I can

select DOM elements. So, I can select

this right here and say change this to

Burr terminal. And because it has that

DOM element selected, that context

selected, I should see this change.

Sonnet 45, not the fastest model

compared to composer. and we see the

change made live and I don't have to go

on my browser because there's a browser

in my IDE. This is another project I'm

working on and and this to me is just

crazy. The fact that I can work on my

IDE, spin up a couple agents working on

a separate work tree so it doesn't

conflict with the changes I'm making on

the main branch and I have the browser

instance running. I can select a

particular DOM element. Oh, here's

what's cool. I can even have Chrome

DevTools in the browser that runs in my

IDE. One thing we can all agree on, the

cursor team knows how to build for

developers, knows how to build product

because I have just been enjoying this.

And that is pretty much it for the

composer and cursor 2.0 update. Let me

know if I missed anything. Let me know

if you have any questions. Is it your

go-to IDE? Are you using something else?

I would love to know your thoughts in

the comments down below. Thank you so

much for watching this video. Like,

comment, subscribe. I will see you in

the next one. Peace.