Most recent updates we've seen have been

incremental at best. There have been

some new models, some new feature drops,

lots of hype, but let's be honest, most

of what we've seen recently from Cloud

Code, from codecs, from Gemini, they've

been incremental improvements. Not much

real impact on how we actually build.

That is until Cursor dropped version two

last week, and I can tell you it has

already changed how I actually work. Two

features in particular have

fundamentally changed my day-to-day

workflow as a product builder. And I'm

not even talking about the new built-in

browser or the new voice mode and

cursor. And those are nice to have. But

two features that I'll focus on today

have had an observable meaningful shift

in my entire development workflow. So

the big headline that you may have heard

about cursor 2.0 are the new dual modes,

agent mode and editor mode. Now this UI

change alone wouldn't be revolutionary,

but it does perfectly capture the two

distinct ways that we actually work as

builders. At least it does for me. You

know, sometimes I need to delegate large

features and let agents cook on those

while I go work on something else or

take a break. And other times I want to

be hands-on, directing agents to make

specific changes while I sit here and

watch them work, and then I'll apply my

final polish. The new agent mode and

editor mode nail this paradigm. But

look, cursor has always been a code

editor with agent superpowers. And we've

already had ways to delegate autonomous

work to tools like codecs or cloud code

or even background agents in cursor. So

what's actually different about what

cursor 2.0 introduced and how is it

changing how we work? That's what we'll

get into in today's video. And if you're

new here, I'm Brian Castle. I help

professionals like you and me stay ahead

of the curve when it comes to building

with AI. And every Friday, I send out my

builder briefing. That's my five-minute

read to help you stay sharp. You can get

yours by going to buildermethods.com.

And subscribers are always the first to

know about my next live workshop where

we talk about what's working right now

when building with AI. So, here's how I

actually work. About half the time, I'm

hands-on with my codebase. And that

looks like a continuous cycle where I

give a prompt and then watch the agent

work and then I wait and then I prompt

again. But that waiting has added even

more friction than I realized because

even with how far today's models have

come and their competence with handling

complex multifile changes, it's that

waiting. It's that friction. It's real.

Because when I'm in the flow working

directly in my codebase, speed is

everything. And so in my view, the

killer new feature in Cursor 2.0 is much

larger than just a feature. Cursor

launched Composer 1. That's the first

large language model from the team at

Cursor. And calling this thing fast is

an understatement. It feels 20, 30, 50

times faster than any other model on the

market right now. You really have to

experience the speed to understand the

impact. Now, later in this video, I'll

show you a bigger build, but for now,

here's a taste. All right, so for now,

let's see what the new composer model in

cursor can do. I'll give it a pretty

small change. So, I've been working on

my buildermethods.com site, and uh one

thing that it's been missing is like a

true about page, you know. So, I've got

a lot of information about our free

resources and uh the Builder Methods Pro

membership and everything. I've got this

little letter here, but I wanted like a

dedicated about page that kind of speaks

to what this brand is all about and my

story behind it and everything. So, I

worked on writing that up over the

weekend. And here is the artifact that I

worked with Claude on creating. And I'm

pretty happy with this. I'll probably

edit it a little bit further, but you

know, this is a pretty good start for

what I want to put into like an about

page. So I'm going to just copy that and

let's go into I'm starting in agent mode

here. Notice over here I'm selecting

composer one that is cursors agentic

coding model. Yeah. So let's uh let's

give this a try. So and I also want to

link to it from the footer. It should

probably go in one of these. I'll just

add it under free resources for now.

Okay. So my prompt is pretty simple.

Like I want to add an about page. This

is the route. This is the controller I

want to use. I'm asking it to use the

same uh layout conventions that I've

used on other pages. I want to add a

link to it in the footer. And then here

is the content for this page. And so I

just pasted in the the markdown from uh

from the cloud artifact. All right. So

let's go ahead and uh kick this off.

So it's reading and it's going. Look at

look at this thing. Wow. Done. Wow. I

mean let's let's take a look. You know

what? I'm going to use the new built-in

browser. So I'm going to do uh command

shiftB. Oops. This is one thing that's

not so great about cursor so far. I'm

sure they're going to smooth this out.

Is like every time I use keyboard

shortcuts to change the panels, my

panels layout gets all out of whack. So,

I hope that that improves. So, anyway,

here we are. If I scroll down. Okay, so

here is my link to about. And yeah, it

looks uh looks pretty good. I I didn't

want to have my face there. And these

probably shouldn't be centered. All

right. So, not bad. I now one of the

really cool features of the new browser

feature is this select element. So I can

select an entire div and I can just

refer to it. So I want to make all

sections on the page the same width as

this div and it's just going to point to

that and it's sort of covered up there.

But you can see it sort of references

that that particular div. All right. So

I'm asking it to make a couple tweaks on

that. So you know I gave it a bunch of

tweaks that hit like multiple spots and

uh it's already done with them. the

content a little thinner. Uh, I'm going

to change the colors on this. I might

move this up into the hero, but I'll

handle that that like layout stuff a

little bit later. So, let's get on with

the video. Now, that was a simple

example, of course, but yesterday,

Composer refactored hundreds of lines in

my codebase, made perfect UI changes,

and it was done in under 20 seconds. And

later yesterday, I needed to add a

search feature across multiple models in

my app. Again, Composer knocked it out

in 20 seconds. One shot. Now, before

today, those are examples of tasks that

I would have spent time specking out and

delegating to an autonomous agent while

I go grab coffee or take a walk. But

now, given this new speed, I'm able to

pull those tasks into my more active

workflow when I'm sitting here crafting

my product. Now, what's really

interesting to me is that Cursor, a

tools company, is getting into the model

game. And I think that this could be the

start of a trend where toolm makers

develop purpose-built models that are

far superior at their job to be done.

And in the case of Curser releasing

their first LLM, Composer 1, it makes

perfect sense. They have unique training

data from their massive user base of

developers. And they can build a model

that's optimized for only one thing,

writing code really fast. And so Cursor

doesn't have to handle all the other use

cases that the models from OpenAI,

Anthropic, Google need to serve. And I

have to think that that's a big reason

why Cursor's Composer model is just

about as competent as Claude Sonnet 4.5,

but way faster. Now, like I said, only

about half my time is spent actually

looking at my codebase while my agents

are working on it. The rest of the time,

I want to give my agents a big new

feature to build and have them go off

and work autonomously while I work on

other things or call it a day and come

back in the morning. In Cursor 2.0,

agent mode isn't just a UI update. I

mean, it is, but it introduces something

that I think is an even bigger deal.

Now, we've had autonomous agents for

some time now. Cloud code led the way

when it pulled us away from our actual

code, and we started trusting our coding

agent to do more work on its own. Then

cursor launched background agents. Open

AAI launched codecs. And so we've been

trending into this era of letting agents

do the work while we interface with the

agents. But that only sticks if agents

can actually deliver on what we ask of

them. And that success rate is what

drives our own adoption and our team's

adoption of this more hands-off style of

working. The truth is, no matter how

great our specs are or how well we

prompt, the more complex the task is,

the more variation we see in the success

rate from our agents because we know

that we can give the same exact prompt

to the same exact model multiple times

and you can get very different results.

And so, Cursor 2.0 introduced parallel

agents and it solves this problem

beautifully. It's the easiest way to

give the same prompt to multiple agents

and have them work in parallel and then

compare their work and decide which one

is best. All right, so let's run a demo

where I'll show you how we can run

multiple agents in parallel to build out

the same thing. So for this demo, I am

in cursor 2.0. I'm in agent mode and

we're going to be building out a simple

weather app. I have prepared a a prompt.

I'm going to pop that in here. Now, now

since this is a new app and a bunch of

new features and it's, you know, not

super small. Now, when we're building

something that's like a medium to large

size build, I do like to start uh with a

plan. You know, uh spec driven

development. The whole value of that is

to make sure that the agents and our

plan are in full alignment. And that's

really important especially when we're

going to be spinning up multiple agents

because of course that's going to come

with some added costs and we don't want

to, you know, spin our wheels and waste

our time and waste our money on having

an incorrect plan from the outset. In

this case, we'll be using cursors plan

mode, which I I think has gotten

actually a lot better. I like it a lot.

So, I'm going to switch this to plan

mode. And of course, you could use

something like agent OS that does a

really good job of developing even more

in-depth specs and task lists. But

cursors, plan mode works works pretty

well. And I also find that sonnet 4.5 is

a little bit better at planning big bu

build builds and also uh asking really

uh smart clarifying questions. Composer

is okay with that but not quite as good

as sonnet. I think that's sort of the

case in general across the board. Sonnet

4.5 is still my go-to model for most

things but man that that speed from

composer is unreal. Okay, so we're going

to start with just one one single agent

creating a plan and then we'll get into

spinning up three agents to build out

the plan. Okay, so I'm going to answer

these uh clarifying questions. Okay, so

I'm just going to review this plan

before we get started. And again, this

is a really important step to make sure

that we're on the same page and that

we're going to give all three agents uh

the right instructions uh to kind of try

to set them up for success. We're going

to build this out on the homepage. We're

going to display some weather data.

We'll have a responsive layout. I think

this is looking good. And we have a

pretty simple uh to-do list that cursor

uh set up for us. Okay, so that is good.

Now, let's go ahead and start building

this. I'm going to start a new agent.

And so, now here is where we're going to

spin up multiple agents to build the

same thing. So, first of all, let's just

mention this this plan. I'll just say

build this. That's probably not even

necessary, but just sort of a habit. So,

I am referencing this plan in the prompt

itself. And then we're going to come

here and select the model and we'll go

to use multiple models. So this is how

we can start to uh spin up multiple

agents. As you can see, I have three

models checked here. We have one for

composer one. That is cursor's new

model. We're going to use that as one of

them. We'll use Sonnet 4.5. That's

really my go-to in general for for most

things. Uh, I still think it's just

slightly better in terms of quality and

capability than all the all the rest of

the models right now, but composer one

is just so much faster that that adds a

lot of value as well. And it's very

close in in quality in my experience so

far. And then in the third agent, we'll

try GPT5 codeex, which I also think is

pretty good, and I go to that sometimes.

Yeah. And also, you know, we have one X

set for each of these. I could go in

here and multiply it and have like two

different set 4.5s and and two composer

ones and every single agent is going to

have a slightly different uh result, a

different take on this prompt. That's

the nature of large language models. Uh

but they all will be working off of the

same plan and we're going to start them

off all at the same time and we're going

to see how they work uh side by side.

Let's go ahead and do that now. Okay. So

now we have uh this nice interface here.

You know, one, two, three. I can easily

tab between them. I do wish that cursor

would have a little bit better keyboard

navigation with these. I I hope that

that comes along because I like to have

everything available on the keyboard and

so far I haven't found an easy way to

bind these to a key mapping. Wow. I mean

composer one is is already actually

finished and uh in set 4.5 is still uh

zero of three to-dos. Looks like codeex

is sort of asking for permission to

proceed and I'm just going to say

proceed. Now, by the way, before we

start uh reviewing the code, let me just

show you exactly what's going on because

it could be really confusing when we're

using git work trees. Like where are all

these agents actually making edits to

which files and where do they actually

live on our system? So, to make this

clear, I always like to open up finder

and just sort of like get oriented with

what we're actually looking at here. So,

on the left side, I'm looking at my

actual project. That's we called it

weatheroo. And here is the rails app.

these files. If I go back in here and I

go into editor mode, these files right

here, that is the like the Rails

application that I've already spun up

for this project. But none of these

three agents actually have made any

edits on our core Rails app. So for

example, if I look at it in the browser

right now, I still see my default hello

world root page. So I'm not yet seeing

any of the work from any of the agents,

right? So where is that that work

actually being done? Well, if I open up

Finder again over here on the right

side, I go into my system level and then

I'll go into the cursor folder. That's a

hidden folder on your system. Then go

into work trees and then you'll see a

folder that was automatically created

matching the same name as the project.

In this case, it's weatheroo. And then

in there, I have three folders with

these sort of like random code names.

Each of these is a work tree. So, a git

work tree is a complete replica. It's a

complete copy of your entire codebase.

All the files, all the folders, they get

copied into their own respective folders

here. So each of these folders

corresponds to each of these agents. So

in agent mode, I can toggle between them

here. And that's exactly the same as in

editor mode. Now, running multiple

agents with git work trees isn't new.

And I did a video on this with Claude

Code months ago, but the process was

complicated, unintuitive, and I had to

whip up a script to make it easier. It

was kind of a pain. Cursor 2.0 makes it

simple. Multiple agents working

simultaneously on different branches all

managed through a clean interface. Okay,

so uh let's see how we did. So here is

how you can actually preview the work of

each of the individual agents and

compare the results one by one. So you

can do this in either mode, agent mode

or editor mode. Let's go into editor

mode here. And we can pick an agent.

Let's start with Sonnet 4.5. So it looks

like all three of them are complete now.

And again, by default, the main branch

is still showing our default uh hello

world page. So I'm going to go ahead and

apply all from the sonnet 4.5 agent. And

I can see that I have because now it

says reapply. So if I refresh here.

Okay, so we're getting a failed to fetch

location name and I'm seeing some some

errors in the console there. So, that's

an issue and maybe we'll we'll work

through that. But before we do, let's

see how the other agents did. Let's

undo. Now, what that did was it it sort

of pulled those changes back and now

we're back to our our original state.

So, now let's flip over to the middle

agent composer one. So, here let's apply

that. And this one's having trouble as

well. If we retry. Okay, so we're

getting some looks like some corores

errors. Okay, maybe third time is a

charm. Let's see uh how we did with uh

GPT5 codeex. I'm going to apply that

one. By the way, I I undid the composer

one first. Went over to GPT5 and I

applied that. And so now, okay, so this

is actually loading. Okay, so this is

actually working. This is um this is my

actual temperature and weather at my

current location. I see my next 24

hours. That's pretty good. I've got a

7-day forecast. I actually really like

the design. It's nice and clean. Let's

see how we did with like a mobile layout

if we collapse it down. Okay, not bad. I

don't love like the current location

coordinates. I'd like it to actually

show my city name. So, maybe that could

be like an edit that we would that we

would roll with. But GPT5 Codeex, I I

would not have guessed that that one had

the best first draft out of uh out of

these three. But you know what? I bet

it's something probably sort of simple

to fix these errors. So, let's go undo

that. Let's go back to the composer one

version and I will apply that one. So,

now we're back on this version which is

showing an error. Let's see if we can

get this working. So, I'm going to

screenshot all of this and I'm using

CleanShot for that on the Mac which I

love. Drop that in here and you know we

have the composer agent activated and uh

let's just you know give it that and see

if we can get this working. Okay. So,

there we go. Uh, it was able to to fix

that. So, now we have this is the

version from Composer 1, which is very

nice. I like it. Uh, a lot lighter. Um,

this one is actually showing my town. I

live here in in Orange, Connecticut.

This is uh the weather here. This is the

24hour forecast. I've got my 7-day

forecast. Let's see how we did on the

responsive layout. Okay, not bad. Yeah,

that works. I didn't ask it to do a dark

mode, but let's see if it handled that.

No, it did not. Okay. Yeah. Uh it, you

know, it basically built everything that

I wanted it. Okay. So, now over on

Sonnet, I actually did uh have it, you

know, fix the error there and uh I

reloaded and now Sonnet 4.5. This is

what it came up with. This is now

working. Although, I must say I'm not as

happy with the overall design. And it

has that very typical sort of vibe

coded, you know, big rounded corners,

lots of drop shadows kind of kind of

vibe. So, uh, yeah, but it it does work.

It's got the weather. It's got my my

hourly forecast. 7-day. Let's see.

Refresh weather. Nice little loading

animation. It doesn't have my actual

location name, so that's probably

something that could be fixed. Yeah. So,

I reapplied the composer agents work,

and I think I like this the best. It has

all the functionality that I would need.

Although I must say I did like the

design work from the GPT5 codeex one. So

that was pretty nice. My next step at

this stage would be to choose one and

then keep working off of that. So for

example, I think that this one with

composer one actually ended up being,

you know, like the the best one to work

with. You know, just as an example, my

next step might be to add like a dark

mode. So let's go ahead and see if it

can uh see if it can do that. Please

automatically support both light mode

and dark mode. and include a toggle

switch at the top for the user to switch

between them.

I'm just having so much fun watching the

composer one agent work. I mean, just

look at how fast it is actually

implementing these changes. It's

unbelievable to me.

Done. Okay, so we have our little uh

switcher up there. Nice. We've got dark

mode and light mode. That works. I like

it. Now, running parallel agents

multiplies your costs, of course, and

that's why I tend to be more selective

in using this feature. I use it for more

complex critical builds where the

productivity gain justifies the costs.

So, the team at Cursor clearly

understands our two different modes of

working and they built that right into

their product, which I love. So, I

really do think that this Cursor 2.0

update represents a real turning point

in how we build. And it's been quite a

year when it comes to how our workflow

as builders keeps evolving. And you

know, specdriven development is one of

those new paradigms that I've talked a

lot about on this channel, and I think

it's still relevant, especially in agent

mode in cursor 2.0. So, if you're not

familiar with spec driven development,

then I want you to see my other video on

how spec driven development works in the

real world. But before you head there,

hit subscribe so you don't miss my next

video on building with AI. So, thanks

for watching. Let me know what you think

and I'll see you over there next. Let's

keep building.