Okay, today's the day. Three things will

get you to level 20 with cloud code

faster than anything else. And I'm going

to show you how to do this while

building a new feature on a live

application and deploying it to the

public. Let's get in there. I have an

application that I wrote last time in a

video called the one hour builds that is

a little prompt kind of management

system that you can pull forward like

Spotlight. What I want to do to that

application is I want to put on a

welcome screen for the first launch. So,

there's a couple features that I have to

ask for. I am going to talk to Chad GPT

about that and get these requirements

pulled together. We'll talk about that

in just a bit. All right. Excellent. PRD

prompt like welcome screen. Let's go.

Okay. Here in clawed code, what we're

going to do is I'm going to move into

what they call plan mode. I'm using Opus

45. I'm going to give it this PRD and

let it think about that for a bit. One

of the excellent things about Claude

Code is its plan mode. It's kind of a

superpower that it has, and they've

really upped it recently where it goes

off and spins off multiple planners at

once, combines information, and brings

back questions that it doesn't know the

answers to to the user before continuing

on. You can see here that it's setting

up multiple explorers to kind of start

looking through the PRD that I've given

it. Okay, so this is one of the secret

sauces of using Claude code to its

maximum. you're actually going to start

moving towards something that's like

objective-based development. So, you're

really looking for outcomes. You're

trying to define outcomes. You'll hear

spec kit or specd driven development or

PRDS. You'll hear a lot of these terms

being kicked around. Claude code and

other terminal systems like this, these

tightly agentic driven systems that are

trying to take as much of the work as

possible on their shoulders will work

for hours at times, but they really need

very clean definitions. And this is the

place that our work is moving to. And

you'll be most successful the moment you

say, "Okay, I need to take on an active

role of definition. I need to very

clearly say what I want, not the how."

We have to get better at defining the

what. And that's what this is all about.

So the best thing you can do is be able

to very clearly say what you want to the

model before you get started. Okay, here

we are. Take a look at this. This is the

end of the planning stage. It went

through and did the planning and it has

a couple questions and you can see them

here. One is do I have the asset ready

and I do. So I'm going to hit enter

there and then it's asking me do I want

a separate window or do I want it in the

same launcher? Once we get through those

it says excellent. Do you want to submit

the answers? At this point it's going

through the application itself and

figuring out the how. We gave it all the

what and that was outside of clawed code

and outside of the project intentionally

so that what we ended up with is a very

clean requirements document describing

what behaviors we're looking for. That's

incredibly important in this new

paradigm. Now you put it back into the

system, go back into planning mode and

say here is what I want. Can you go

figure out how to pull this off? And so

it choose a way to try to figure out how

am I going to go about this with the

structures that we already have here and

the technologies that are being used.

That's why this works so well. Our goal

here is to get it right at the very

beginning as much as we can. I can't

describe how much this has changed

recently. I was not using plan mode at

all at one point and very very recently

I've come to a point because of Opus 45

and some of the changes they've put into

Claude Code. This is a complete unlock

in the way that I work now. So, this is

the readout of the entire plan. This is

a moment that I still advise, take a

look at this. This is the moment to go

back and say, "Oh, wait a second. I saw

you're using X library." I really

personally just don't like X library.

I'd rather write it with Y. This is that

moment. You just select this bottom

item. But I'm going to say, "Yep, looks

pretty good. Get to cooking." Okay. And

so, Claude is off and running. It's got

it task list here and will work as long

as it needs to work to get this done.

I'm free to go. Okay. So, you can see

this is the window that got created.

There's one glaring oversight. I did not

provide the image to Claude when I told

him to go build. I gave him the PRD and

I gave the image to ChatGpt to get the

PRD from it. That all worked just fine.

But Claude had no idea what the visual

look was supposed to be. So, this came

out of just text and description and

some of its inference of what I might

want from a new window. So, what I need

to do is I need to go and give Claude

code the image that was what we want

kind of the design of the system and

say, "I'm sorry, it doesn't quite look

the way we need here. Can you make it

look like that?" So, let's drop down

into the system and make some of those

changes ourselves. Hey, if this kind of

content is clicking with you, please do

subscribe. So, I've said if I hit 25,000

subscribers by the time Christmas comes

around, 25 by 25, then I will dress up,

which I've said previously, I'm very

nervous about doing. So, it's okay if

you don't subscribe for the rest of the

month, but if you do, it really does

help the channel. But do subscribe

because I have another video coming out

that's similar to this. It's actually

the next step. It is really my next

video, I believe, that's going to

release. It is the workflow that I use.

This is a very small sample of the

workflow I use. I want to go a bit

deeper in it so you really understand

what the unlocks are and how I use them.

All right, let's get back to the video.

Okay, so we've reached the the other big

item. First one was planning. That's a

major one to understand. The second one

is kind of context and environment.

We're going to cover that very briefly

here. It's very easy, but I want to call

out just how important it is. This is

another one of those majors. So, here we

are. We have a change that needs to be

made, but we're sitting inside of a

bunch of information here that we can

scroll up and see that it's already

done, right? The system's been working

for a while. If I go and tell it to do

something else, when I say, "Hey, do you

mind doing X?" All of this other

information is going to the model. And

so, it's in its brain at the same time

as if I'm kind of asking about that to

some degree. So, we don't really want to

mix these contexts together. And it's

something that you'll hear us talk about

contexts or kind of number of tokens,

those sorts of things. So if we look in

here in claude code, the slashes are

where all the the actions like you might

see on a menu bar or something

something. If you type in slash, you'll

get the actions. And if we look at the

context, then we can take a look at what

our context currently looks like and how

it's being utilized. And they give us a

nice little graph here that you can see

the Claude Opus uh system here. the

system prompt there you go is uh 1.5%.

The tools that claude code knows about

itself all of this this kind of harness

that I was talking about those are those

two MCP tools are listed memory files

are listed and that one we will cover in

just a second the memory file is kind of

important but you can see we're at 1.6%

6% for the memory file. And then all of

the messages that I was just scrolling

up to show you are these purple ones. So

we're eating up a fair bit of space

already with the previous messages of

this context. So what we really want to

do is just do a clear. And that's the

second simple thing that I'm sharing.

Make sure you clear when you start a new

task. When you're starting any new

context, try a clear. And if I'm going

to hit the up arrow now to goes back in

my message history or my action history.

And then I'm going to go to context.

Take a look at our context again. You'll

see all that purple is gone. So that's

all we did is we cleared how much

context we're using with previous

information. And now I want to be able

to drag in that image. Hey Claude, sorry

about that. This is the image. This is

the target of what we want the window to

look like. The other than the button and

the radio or the the checkbox at the

bottom with the text, everything else is

really on the core image. So we don't

need any other information added to the

window. We just need the image, the

button, and the checkbox and label set

up kind of like you're seeing here if

you don't mind. And this, I think, might

even be the resolution of the window.

So, this aspect ratio is something that

we're shooting for as well. Can you

change what we've got for the welcome

window to look more like this, please?

And that's it. So, I'm going to kick

that off. This I don't need to do a full

PRD. I don't need to do planning. It's a

small enough request, and I'm focusing

it in on a specific item, which is the

welcome window. I told it that I'm

looking at the welcome window. You'll

see it will drive itself all the way

down into researching welcome

information, and it'll hit it just fine.

Okay. So, while this thing's working

away to change that welcome screen that

we were looking at, I am going to hit an

exclamation point here. This is a a

secret tip. This is not one of the power

move. It is a power move. You don't need

to know about it. But if you like shell,

this is something that you'll

understand. I can type in uh just kind

of shell commands here and they'll be

executed and that information will be

returned uh in in the messaging above in

the same place that you're seeing all

this action happening. So, that's

something that we can take on to

actually take a look at the memory file,

which is something that we're interested

in. Holy cow, look at that hit. It's

great to see. [laughter]

Let's go. Okay, so let me come back here

and we will run a shell command. Let's

run the ls so that we can see what's

inside of the environment that we're in.

And you'll see control uh control O to

see all of the information. That's the

ls. This clawed MD file is something

that I want to show you. So what I will

do is I'm going to leave Claude for a

second and I'll just cat claude MD. And

so this is a very big file in this

repository because I've run init file.

It's one of these features that will

autoload all of this information. And

what you're seeing is all of this

information talking about what are the

scripts, what is the layout, what

folders might you look in, what are the

languages that we prefer in the

different layers, what's the

architecture. It's a pretty complicated

build in this little application. Um, so

this this this memory file is what we

call this. The clawed file is kind of

complicated. Frankly, it's bigger than I

would like it. But there are quite a few

things of concern in here that I want it

to know about. Now, why do I show you

that? We can jump back into Claude. And

that is the thing that when we do

context, that is this memory file. And

so every time you start a new chat,

which we just did because we just came

in, we are going to be eating up a

certain amount of space with that memory

information. Now, it is critical. This

is a place where you're going to put the

instructions that you want to not have

to say every time or you want to

opinionate the system with. This is just

the last one of those things that I

wanted to point out that is a really

major feature that if you understand

what it's doing, you can get some really

val big value out of using it and just

kind of putting in the hints that you

want. So, I wanted to point out this one

and the very last one that I'll just

show you at the very end in case you're

worried about your tokens or your tokens

start to uh kind of run out. There's a

status/comand that you can see where you

are with current session, the week, and

uh with the different models, those

kinds of things. And there's also a

model selection system that you can come

in here and change between the different

models if you have to start down

sampling. I don't advise coming off of

Opus if you can help it. I understand

that's going to eat a lot of tokens for

a lot of you. If you have to down

sample, at the very least use Opus for

planning. It's very, very good at

planning or anything else. Refactors or

something intense. It's going to be

great at that. Sonnet is still a

fantastic model, but Opus 45 just

happens to be something kind of brand

new. Okay, we're into the last phase and

frankly this is the most exciting and

the most fun and I love doing it every

time I do it. So what I'm going to do

here is I'm going to ask Claude to run

the test cases. That's the first thing I

want to do. I don't know anything about

how it runs all the different test

cases. There's a lot of different

layers. So it does test casing different

ways. So I'm going to let it do the test

cases itself and let's see what it comes

back with. Hey Cloud, can you run the

test cases? And if you run any visual ed

type of test cases, make sure that they

are uh with headed mode or something

like that so that we can see the browser

doing its work. All right. So, it's

saying it's going to run some ED tests.

There we go. The browser's popping up

doing all the tests that it needs to do.

You know, of course, no hands. I don't

even know all of the tests that it's

running, but you can see it just going

bananas with all of the Chrome instances

that it's bringing up to do this kind of

test casing. And when you are not in

headed mode, headed means you can see it

that it kind of has a visual

representation, you can run in unheaded

mode or headless mode, and you won't see

any of that. and it goes by blazingly

fast. It also works on distributed

systems as well. Some of these tools are

just brilliant and you can see it did

have a couple failed tests that we need

to go address. I'll get those addressed

and then take you on to the next very

exciting part. Oh goodness. Can you uh

address these tests? Okay, so we're done

with all of the test case stuff. So, let

me hit it clear and say, "Okay, Claude,

uh this is this has really been great

work. I really appreciate it. Do you

mind uh doing a PR for this? I'd love to

create a new PR for this." Okay, so it

created the new feature branch for us,

gave it a name, um, did all the work

that it needed to to create the commits

that it felt like it needed to make,

pushed everything up, and created a pull

request for us. Let's take a look at

that. Okay, here's the pull request. Uh,

it's got a good definition of the

changes that are in it. Um, it is out

there currently running tests. And then

once it is finished running tests, we

will merge this and move on to the next

step. but kind of fantastic. Let me

point out I didn't do anything with

GitHub. I've just come here to show you

this and I just asked Claude to do all

of this. Now admittedly I am being kind

of very permissive with the changes that

I make here. You can see I'm in bypass

permissions on in this repository and

this uh this application and I'm very

careful about this. But that is

something that I would say be cautious

about. It will ask you to accept these.

I would do that for a long time until

you really gain a lot of confidence in

the things you're letting it do. But

it's really fascinating that I can just

say, "Run the tests. Let me see the

browser. Do something in GitHub. Create

a PR for me. Now it's a feature branch.

What am I supposed to do?" Okay. And

here these changes have succeeded. And

normally I would come out here and check

things out and squash and merge myself

and then delete the branch. But what the

heck? We're having fun today. Hey, it

looks like everything passed on that PR.

Um, can you merge it and uh let's do a

release so that everybody out in the

world can uh get this really cool new

feature. Really? You can see back here

that it has successfully merged. I will

delete the branch. It pulls back to

main. So, it puts us back on the main

branch because that branch is no longer

needed. It takes a look at how to do a

version. And it's saying, uh, since this

is a new feature, I'll bump to one two

and it was at 1.1.3. It'll go to 1.2

since it's a minor release with a new

feature. Very, very smart. Excellent.

Okay. And it did everything it needed to

do. It bumped everything. It built

everything. It built a release out here

on GitHub, which is how if you want to

go by Prompt Light itself, I'll leave

this in the show notes so that you can

get the application if you like it. Um,

and this is how you'll come by if you're

on a Mac and get it for the universal

build. That's what it did. It also

installed it onto my system. It's

another part of its release process. So,

we should be able to run Prompt light.

And boom. There we go. This is our new

one. Let's go. That was awesome. Okay,

so we covered a lot of ground and you

saw me actually build and release a

feature from scratch all the way to the

end out to production within building

this video. So this was a lot. I hope

you saw some of the major elements that

are important working with a process.

That next video is coming once again.

That one will give you a little bit more

about the workflow itself and the

process that I use. That's a major major

unlock, but we did see quite a bit of it

today. And then how I work through some

of the bugs, how we can use something

like clawed code as not just for code. I

mean we did releases, we did

descriptions of the uh system itself. We

are using for anything. I use it to do

this for my notes as well. I take

meeting notes. I put them in folders and

then I work with claude code to have

conversations and understandings of

what's going on. It can do one heck of a

lot more than you might imagine it can

do. But if you're just trying to get

started with code, hopefully this showed

you something.