In this video, I'm going to be showing

you how to set up self-improving skills

within cloud code. Now, one of the

issues with LLMs right now is they don't

actually learn from us. Just to run

through an example of this, let's say

you're working on a web application.

There might be a mistake that the coding

harness or the model that you're using

makes within the first iteration of what

it's trying to do. Let's say you want to

add a new feature and then it has a

button as a part of that feature. Just a

simple but relatively common mistake

could be that an LLM doesn't actually

know the particular button that you

might want to leverage. Generally

speaking, you can tell from certain

inputs and buttons what is actually

generated from an LLM. Now, you might

correct that mistake and say, "Okay, I

actually want you to reference this

button." But the issue with this is when

you actually correct it within that

session, when you pick up in a second

session, it's going to make that same

mistake again. And you're going to have

to correct it or remember to actually

specify to reference that particular

button. Same thing for the next session.

And this loop will continue. Every

conversation effectively starts from

zero. And the thing with this problem is

it touches every single model that is

out there as well as every single coding

harness. Not having a good effective

memory mechanism within the harness in

my opinion can definitely lead to a lot

of different frustrations. Now this

frustration can come up in a number of

different ways. It might not follow

naming conventions. Use the proper

logging convention. It might not

validate inputs the proper way that you

did within other components. Had that

experience where you're just thinking, I

just told you this yesterday or I told

you this last week. The issue with this

is there's no memory. your preferences

aren't persisted and effectively without

some form of memory is you're going to

be repeating yourself forever. The

solution to this is relatively simple.

We can actually set up a reflex skill to

analyze the session, extract corrections

and update the skill file. One thing

that I've been playing around with is

for my global skills that I use across

my machine is I have all of those

different skills versioned on GitHub as

I have them reflect and iterate on those

particular skills. I can see all of

those different memories over time and

if there are regressions and if I want

to roll it back, it makes it easy to

have it all within the version control

within git. So now the way that I've set

this up is there's a few different

mechanisms to this and it's relatively

simple. I have the ability to turn

reflect on, reflect off, and then

reflect status. There's two different

ways that we can do this. There's a

manual way, and then there's also an

automatic way. First, let's touch on the

manual flow. There's a skill called

reflect, and then there's a slash

command. As soon as you go through a

conversation and if there's something

that you want to have it remember, you

can simply call that slash command and

it will have the context of the

conversation and then it will reference

the particular skills and then it can go

and update those accordingly. And the

nice thing with the manual update is

you're going to have a lot more control

in terms of what is actually being

updated within the skill file. Just to

go through a hypothetical example, so

you might leverage the skill, it might

say here's my review of the O module and

you might realize, oh, it's actually not

looking for SQL injections. we could go

and specify always check for SQL

injections and then from there cloud

will go in the current session check for

SQL injections similar to the button

example that I had and then ideally it

will come back and show you that it's

done and the really nice thing with this

is corrections are all signals that

could be good memories approvals are

further confirmations and the reflect

command and skill will extract both of

these and then after that process all

that we need to do is actually run the

command to reflect we have two different

ways that we can do this we can run the

reflect command And or we can also

explicitly pass in the skill name as

well. But if you just pass in reflect,

it will have the contextual awareness

since it is within that thread to know

when that skill was actually invoked.

Effectively, Claude will analyze and

scan the conversation for corrections.

It will identify success patterns, post

skill updates, and the way that this is

set up is it will give you a breakdown

of different confidence levels. There

will be high, medium, as well as low. If

I say never do X, like never come up

with a button style on your own within

this project, you can go ahead and

specify something like that. Medium are

going to be patterns that worked well.

And low are going to be observations to

review later. And all of this works is

just through this skill file. You're

going to be able to edit this, tweak it

if you want to have version control, or

if you don't, you can go ahead add in a

G integration. Additionally, you can

just remove that if you don't want to

leverage it. I'll link all of this

within the description of the video

before it actually updates through

respective skill. This is what the

review and approval process looks like.

We have the signals that were detected.

We have the proposed changes. And then

we have the commit message that it's

going to add if we go and accept those.

Additionally, what we can do within here

is we can just change and we can change

with natural language. That's one of the

really nice things with this in terms of

actually applying these to our skills

directory as well as pushing them to

get. We can either click Y and or we can

type with natural language the different

changes that we want to have within

Cloud Code. And then once you've either

made those changes or you've accepted

what Claude has proposed, it's going to

edit the particular skill and then it's

going to go ahead and commit that within

Git. And then it's going to go ahead and

push that up. And one thing about this

process that I did want to have within

at least my setup is for all of those

different changes that it makes within

the skill, make sure you're actually

versioning all of those as Next up, you

can actually take the same flow and you

can automate it. You can have hooks

trigger reflections automatically. Now,

if you haven't used hooks before,

effectively what they are commands that

run on different events. Now, there is a

stop hook, and this is something that I

covered in an earlier video on the Ralph

Wigums loop where what you can do is to

have Claude persist and run

automatically. You can actually bind a

shell script to invoke and have Claude

continue whenever that stop hook is run.

But it can also be perfect for end of

session analysis just like this. Now the

syntax is broken within this example

here, but effectively what this is going

to do is on the stop hook, we're going

to go and trigger that shell script to

reflect. If you are going to be running

this automatically, you do want to have

a lot of confidence in terms of that

reflect mechanism and what it's actually

doing. But what it will do is you will

go through the process just like before.

And then once the session ends, the hook

is going to analyze and automatically

update all of those different learnings.

This is going to be that continual

self-improving loop that you can have

within cloud code. You can very well

also leverage the same strategy of

continual learning within other agentic

systems as well. And so what it will do

is in that button example, it will go

ahead, it will learn from the session.

Then what it will look like within cloud

code is we'll see learn from session and

it will have the skill that it updated.

So it's effectively more of a silent

notification, but just like this

indication like you see on the screen

here that it actually updated that

particular skill. And then in terms of

the reflect shell script that gets

invoked on the stop hook, we can turn it

on. There's a mechanism to reflect on,

reflect off, and this is effectively

going to work the same way as the

reflect pattern that we had, though just

being automatic. The one thing that I

find exciting about this is you can

leverage skills for a ton of different

things. This can be for code review, API

design testing documentation amongst

a ton of other use cases. And having

skills actually be able to learn from

your conversation, I think, can be

something that is pretty powerful. and

also having it within skills. You don't

have to worry about embeddings and

memory and all of the complexity that

comes with typical memory systems that

we see out there. This is going to all

be within a markdown file that you can

simply read with natural language. And

now the other thing that I like about

this is actually having it within git

cuz you can see how the system learns

over time. If you have a front-end

skill, you can see all of the different

things that are learned as it goes

through instead of actually having to

start from blank every single time. But

I think the more interesting aspect of

this is you can see how those skills

evolve over time and how your system

gets smarter over time as you have

conversations with it. You're going to

be able to see all of the different

learnings for the particular skills if

you are to leverage this within Git as

well. And just to wrap up, if you aren't

as familiar with agent skills, I'll put

a couple links within the description of

the video. I'll also do some other

videos probably over the course of the

month on this type of topic as well. So

feel free to subscribe if you're

interested in this type of content.

Okay. Okay, last but not least, just to

sum up what we've touched on, there's a

couple different ways to do this. You

can do it through the autodetect method,

you can do it through the manual method,

or you can toggle on and off and do a

little bit of both. If you do want to

leverage the auto detect method, see how

it works for a little bit. You can try

that. Additionally, I'd encourage you

just get familiar with the actual

reflect mechanism. I'll put a link to

the working copy of the one that I'm

leveraging within the description of the

video if you're interested. And then we

also have the toggle mechanism. So, if

you want to use a combination of manual

as well as automatic, you have to turn

on that auto detect mechanism when it's

triggered within the hook. Okay. So, all

in all, the goal with this is to correct

once and then never again. This is a

start. I'm not saying this is definitely

the end solution, but hopefully it

inspires some ideas in terms of how you

can leverage skills, self-improvement,

as well as continual learning.

Otherwise, if you're interested in this

type of stuff, follow the channel. I'll

be covering some more ideas in and

around this type of stuff over the

coming weeks. But otherwise, if you

found this video useful, please comment,

share, and subscribe.