How I Turned Claude Code Into My Personal Assistant... You can too!

Hey L, can you help me research my next YouTube video? I want it to be about the

YouTube video? I want it to be about the hard one lessons. Let's say like a list of five to 20 lessons that I learned while turning cloud code into my

personal AI assistant that I use every day and how to get the most value out of it.

Okay, so without exaggerating, L, my personal assistant that you're seeing here, is about to perform what would have taken me several hours in hopefully just a few minutes. And we're going to

let her do her thing while we talk about how she works. So all of this is happening in real time. Coding agents

like Cloud Code and Cursor have become really good at performing complex long horizon tasks. These coding agents

horizon tasks. These coding agents really are at the bleeding edge in terms of what's possible and also where value is really being generated in AI and

they're starting to feel more like thought partners, collaborators or even like a technical co-founder more so than

simple chat bots. And the idea here is to adopt this amazing leverage that they give you for non-coding tasks. So things

that you do every day that take up a lot of your time, but could also benefit from having an agent go off and work on

it for 5, 10, 15 minutes at a time and then come back and deliver you a really great output. I do want to set

great output. I do want to set expectations because I hate overhyping things and I'm not trying to sell you on a dream that you can have this real life

Jarvis that can run your whole life. I

just want to show you what's actually working and generating real value for me and then hopefully show you how you can do the same. But just know that it does take a lot of work and optimizing to

build a system that actually works the way you want it to. I'll definitely

follow up in another video on all the things I've learned building this system, which is actually the research that we just kicked off that L is doing

right now. Let's talk about how L works.

right now. Let's talk about how L works.

And I'm not going to go through everything step by step or even share this code because there's a lot of personal data here, but I just want to focus on showing you the chord system

design so that you can see how it works and then use it for yourself. So, first

what you're seeing here is uh me running a custom agent that I built using the cloud agent SDK and it works exactly the same as cloud code because the agent SDK

is literally built on top of cloud code.

So, it's just orchestrating cloud code under the hood. I can run this system both using this custom agent or run L

also just using cloud code. Everything

that you're seeing here, you can run for yourself by just following how I set up Cloud Code.

I wanted to take a second to mention that everything you see and get from me in my videos is always 100% my own. From

the ideas to the notes I write and share with you guys, my learnings, the code, it all comes from me. But of course we

all learn and are influenced by others.

So I wanted to quickly mention that I do take a lot of inspiration from other thought leaders in the space from amazing creators like Daniel Micler and

Indie Devdan and others. And Daniel

Mistler especially had an amazing blog post which he turned into a YouTube video on creating uh AI assistant. So,

if you're interested, definitely go and check out his video and blog post. Give

him some love and support because he has incredible content. But yeah, I just

incredible content. But yeah, I just wanted to acknowledge and credit these other creators that I learned from. Now,

let's get back into it. It all starts with this.claude folder. Let's start

with this.claude folder. Let's start

with the output style. So an output style, if you're not familiar, is just a way to modify the system prompt of Claude. This allows you to define a

Claude. This allows you to define a different personality and identity for the agent and also give it any kind of special instructions that you want to

add to the system prompt. It actually

replaces Claude code's identity as a software developer or software engineer so that you can generalize cloud code to different purposes. So that's all we're

different purposes. So that's all we're doing here with this output style is turning it into a personal assistant named L. And in it we're also giving it

named L. And in it we're also giving it awareness of the context system that it's using. So the next thing to look at

it's using. So the next thing to look at is this context systems and it starts with this claude MD file. So if we look at this, this explains these different

subsystems in the context system. So you

have a memory system, a project system, and a tools system. Each one of these is going to have its own cloud MD file. So

if I open memory, you'll see this has its own cloud MD file that explains how that subsystem works. This context

system is really the brains of the whole operation and it heavily relies on context engineering, which really boils down to giving the right context at the right time. And in my last video, we

right time. And in my last video, we covered skills. So, if you're not

covered skills. So, if you're not familiar with skills, we're going to talk a lot about them today. Go check

out that video if you want to get a beginner to expert rundown of skills.

But in that video, we talked about this idea of progressive disclosure. That

same idea of progressive disclosure is how this entire context system is designed. So whether it's specific

designed. So whether it's specific memories about me as a person or my user preferences or it's specific details

about one of my projects, whether it's a finance project or a research project or a YouTube project, all of that context that's in these folders is only pulled

or read by Claude as needed. So Cloud is deciding on the fly whether it needs to get more context to complete its next

step. And so that makes this file-based

step. And so that makes this file-based context system really efficient too because it's just using again this idea

of context engineering.

And that's still running. So you can see how long this agent can go off and run for. It's already been like 10 minutes.

for. It's already been like 10 minutes.

But anyway, coming back to the context system. So, and it literally just

system. So, and it literally just finished. So, let's see where we're at.

finished. So, let's see where we're at.

L has performed the research. Let's see

what we got. So, we have our video concept, which is hard one lessons from building and using cloud code as a daily personal AI assistant. I'll quickly flip

over so that we can check out the research doc together. So, you can see hard one lessons from building a cloud code personal assistant. Here are my

last two videos that are kind of related to this. And then you have the top

to this. And then you have the top competing videos and kind of a breakdown for each one of these videos including what channel it came from, etc. So this

is all being generated using one of the skills as we'll see in a bit. So I have all of these skills that I've added to L and one of them is researching new

videos. So in there we're describing

videos. So in there we're describing everything we want in this research as well as leveraging these other tools to generate thumbnails to generate

optimized titles to generate video hooks etc. So these are like skills leveraging other skills or compound skills if you will. And if we keep scrolling down, we

will. And if we keep scrolling down, we see um patterns that it identified from our competitor research, uh the content gaps, and then down here, we can see all of

the actual options that it generated.

So, we have several titles that it proposed. I used Cloud Code as my

proposed. I used Cloud Code as my assistant for 3 months. Big mistakes

were made. So, that's option number one.

That's the one we saw. The Cloud Code personal assistant lessons nobody tells you. I built my AI assistant wrong.

you. I built my AI assistant wrong.

Here's what actually works. 3 months of cloud code assistant mistakes so you don't have to. The personal assistant setup that took me weeks to get right.

And then here's the recommendation along with the thumbnail concept.

So it has a few thumbnail concepts for each of the titles that it came up with along with its overall recommendation here.

And then we have our hook including how the scene should play out. So my screen should be showing cloud code assistant interface quick cuts of three to four visual mistakes and then a voice over.

This cost me 10 hours. This broke my entire workflow and this almost made me give up completely.

Okay, that's pretty good.

So you can see how detailed and high quality this research document is because we are leveraging those skills.

And in those skills, we're progressively disclosing these really detailed and highquality design requirement documents that guide the agent in creating these

uh really high quality outputs. So just

as an example, if we go into the YouTube title skill, then you can see we have this mandatory reading where it has to look at these design requirements. And

here we're just giving a highle summary of the steps it should take to accomplish this skill. But if we look at the design requirements, this is really where we're guiding the agent in how to

create this highquality output. So, it

has to meet all of these design requirements when creating a YouTube title that is going to be optimized for SEO, for click-through rate, for

generating curiosity, etc. And it's the same thing for generating thumbnails and video hooks. So, that's how we're

video hooks. So, that's how we're getting these really high quality outputs. Normally, I would go through

outputs. Normally, I would go through the entire research stock a little more carefully and kind of choose which option I like more, but we'll just go with this recommendation for now. This

sounds good, L. Uh, let's move forward with the suggested title and let's generate all of the thumbnail options that you came up with for that title.

And make sure to save everything and update the research dock.

Okay. So, we're going to let her continue working there. So, you see that how she'll go off and, you know, work for like 10 minutes at a time and then follow up and then ask if she needs any

additional input. So, it really is just

additional input. So, it really is just like how cloud code works on your coding projects except you can see how long horizon this is for a non-coding task.

So really that's the goal is to automate as much as possible and make the assistant as autonomous as possible. Now

coming back to the context systems. So we kind of already saw how in each of these subsystems we have another cloud MD that explains how this subsystem

works. And then for example uh in the

works. And then for example uh in the projects um this would be our cloud MD.

So we're explaining you know each of the projects that we have in here. And then

if we click into the YouTube project, this is where we're going to have a lot more detail about my YouTube and

specifically pointing it to where these different directories that are relevant to this project are. So here we're pointing it to this episode research

directory where is where we generate all of our research documents but we're also pointing it to my YouTube project directory which is on a totally

different folder on my file system and we're explaining how you know what are all the different files that are in those episode directories.

So again it's just getting this deeper and deeper context as needed. If we look at the memory system, this one's really important. Here we have again another

important. Here we have again another cloud MD that explains how the memory system works. And we're kind of breaking

system works. And we're kind of breaking down these core memory files. So we've

instructed it to create memories in these markdown files which will be organized for example learnings, user preferences, user projects and even work

status which is going to correspond to the work that it's doing now. So, this

is kind of a a way for it to keep a status update on what it's accomplished so far. And so, L is completely

so far. And so, L is completely responsible for not only using her memories, but also writing to memories

and keeping really this whole context folder up to date. So, anytime L uh learns something new about me, about my

projects, L will come into this uh folder and update the necessary files.

And this works really closely with the hook system, which we'll talk about in a bit. But we basically use hooks to steer

bit. But we basically use hooks to steer L and give her reminders on when she should be updating her memories, as we'll see in a bit. So, just got the

sound that she finished uh something again. Okay. So, L just updated the

again. Okay. So, L just updated the research doc and it looks like she went ahead and generated several thumbnails for these different concepts. We had

one, two, and three. So, she updated the research doc, saved the thumbnails to this folder, and then updated her work status. Cool. So, here are the thumbnail

status. Cool. So, here are the thumbnail concepts and she updated the file locations here as you can see. Okay, big

mistakes were made.

I'm not sure maybe this will make more sense with the title. So, I forgot what the title was. Let's check this out.

Yeah, so the option one title was I used Cloud Code as my assistant for 3 months.

Big mistakes were made. Okay, so now that we have that context, okay, you can see that it's progressively getting worse from month one to month two to month three is like

a complete biohazard meltdown. So this

is not bad when you actually look at what the title was. Let's check out these other ones. So that was concept one, time evolution with mistakes. Here

we have concept 1B of a before and after disaster.

Okay, this is actually really good except for the fact that that's not me on the left. But here's the thing, right? Like the system is not going to

right? Like the system is not going to be perfect, but this is everything that's happening right now is like getting me like 95% there, right? I

could easily take this thumbnail, pop it into Nano Banana, which is actually what L is using to generate these thumbnails in the first place. We can pop this into

Nano Banana and just face swap me and this thing is good to go. So this is actually really impressive. You can even see the VS Code loaded on the desktop

back there which is so awesome. Let's

check out finally the last concept 1 C which is single mistake moment and this was the recommended.

Oops. Okay, this one's this one's not bad either. Actually, they're all not

bad either. Actually, they're all not bad. I really, if I was going to pick a

bad. I really, if I was going to pick a favorite, it's probably either this one or this one. But honestly, they're all not bad.

[Music] Nice. I want to go forward with concept

Nice. I want to go forward with concept 1B, the before and after disaster. So,

let's do that and uh update the dock with the final decision. Okay. So, I'm

just going to let her go update the dock. So coming back to the context

dock. So coming back to the context system, hopefully that gives you a good idea of how memory and projects work here. Ultimately, this is all context

here. Ultimately, this is all context for L that again she's going to be leveraging to really give us the most personalized and relevant output that

she can and she's also responsible for managing it. The projects are especially

managing it. The projects are especially important, you know, like as L learns new details about, for example, who are my YouTube competitors, what is even my

definition of a competitor, you know, like what subscriber range should they be in, for example. So, as she learns all of that, she's constantly updating these files. And then finally, you also

these files. And then finally, you also have uh the tools here, which is going to have really extensive documentation.

So for example, I have this local MCP that I developed for translating subtitle files for my videos into different languages as well as the

descriptions and titles for my videos.

So So this has complete documentation on how to use this server, all the different tools that it has. This is a little bit less necessary for MCPs

because when you connect MCP servers to Claude, all of the tool schemas for the server are automatically injected into the system prompt. So, it's actually already going to know all of this as

long as you had good documentation and doc strings in your MCP server. But the

reason why I have this documentation here is cuz I'm in the process of changing out these MCP servers for CLI

tools where we can leverage skills and just have Claude read this documentation whenever it actually needs to rather than using an MCP server and having to

inject all of that context into the system prompt every time even though we might not be using all of those tools.

So, I'll show you what I mean by that in a bit, but just notice how you can create these really dense documentations that go into a lot of detail and are

really comprehensive, but the system can still be super token efficient to access this data because cloud can use tools

like Glob to find specific documentation that it needs and even use the tool GP to do a specific search within this

document for just the documentation for the specific tool that it needs to use.

So it doesn't even need to read this whole document if it's just looking for one tool for example. So that's the context system and really that's uh one

of the biggest pieces that makes this whole thing work. So we talked about the system prompt, we talked about managing the context. The final piece is the

the context. The final piece is the action system or the actions that the agent is able to take. And a lot of that happens through tools that are built

into cloud also MCP servers. More

importantly, now that we have skills, you can see all of the skills that I've added to L. So, the really cool thing about skills is ultimately they're just

packaged instructions in this skill.md

file on what to do with additional context which you know you can include inside of this skills folder. Like here

I have a CLI reference. And more

importantly, since Cloud can run bash commands, you can also have a skill that runs uh Python scripts or bash scripts or even CLI tools. And this is huge

because I used to have several local MCPs that I developed for specific tool sets like working with my YouTube analytics, interacting with Obsidian for

my notes. And what I've started doing is

my notes. And what I've started doing is just vibe coding really lightweight CLI tools and then using them with UV tools so that they can be accessed from any

terminal. And then once I vibe code it,

terminal. And then once I vibe code it, I have Claude actually come up with a reference documentation or a usage

documentation on how to use that CLI tool. So this one, for example, is for

tool. So this one, for example, is for using Obsidian, which is a note-taking app where I have a ton of my brain dumps

and where I take a lot of notes when I'm learning something new. So, for example, in here is where I kind of took all of my notes for cloud agent skills. So,

this was the comprehensive doc that I created for the last episode and which I shared with you guys. So, you can see there's so much context that I have in

Obsidian. And with the CLI tool, it can

Obsidian. And with the CLI tool, it can interact with Obsidian just like you would with an MCP server, but with the benefit of that progressive disclosure

where I don't have to actually connect an MCP server and take up all of that space in the context window for the system prompt. So then in the skill all

system prompt. So then in the skill all we have to do is really point it to this CLI reference and just give it short um examples of how to use the CLI but then

telling it you know if it does need more information if it runs into errors whatever then go see the full documentation.

The last thing to cover is hooks and this is really the infrastructure that facilitates uh the context engineering

tracing debugging steering the agent at the right time. So it's a powerful control mechanism for the whole system.

And these different trace hooks are just to capture all of the different actions that are happening so that we can see what's going on under the hood as L

works. And it's all being recorded to

works. And it's all being recorded to Langfuse, which in a bit I'll show you the full trace of all of the work that L did in this session. So that's all the

trace hooks are. The most important ones are these two. First, you have load context, which is just going to load this claude MD file in the context

directory, and it's going to dump that into the context for Claude every single time the user submits a prompt. And this

is really important because we don't want to rely on claude deciding whether it wants to read this particular file because this is part of what actually

makes the personal assistant run, right?

Is this this context system and so we want to trigger that every single time the user submits a prompt. And then the other one that's really important is the memory reminder. So this hook also

memory reminder. So this hook also triggers every time a user submits a prompt. And this is going to inject a

prompt. And this is going to inject a system reminder telling L every single conversation turn she should reflect on what's been done and then update the

work status document as well as create any new memories. So this is what allows her to continuously be updating the context system. And I first learned

context system. And I first learned about this actually just working with cloud code a lot because when you're using cloud code sometimes you'll notice in the tool outputs that there are these

system reminders that get injected where the harness is reminding Claude after using a certain tool to take a certain action. So that's where I got this idea

action. So that's where I got this idea and it works amazingly to steer the agent and get more reliable repeatable behavior. I'm just going to quickly make

behavior. I'm just going to quickly make sure that we finished this. So, yeah, L updated the research dock and then got

our final selections in there. Now, I

want to show you all the work that L actually did. So, using the hook system,

actually did. So, using the hook system, we record all of the actions that L takes in each session using Langfuse, which is an open- source library. So,

here was our initial message that we kicked off. Uh, hey El, can you help me

kicked off. Uh, hey El, can you help me research my next YouTube video, etc., etc. And then here is the final output for this conversation turn. But if we

click into this trace, you can see this actually ran for 8 minutes. So this was a really long running task where L was taking all of these tool calls where it

was searching for different files. Here

it's looking into her memory to see if she has any prior memories about research that was already done or my YouTube or whatever. And then just looking through my YouTube project.

Since I mentioned YouTube, it's going to read a ton of different files here. And

you can see there's just a lot of actions that it's taking. Eventually,

she starts using the YouTube Analytics MCP server to get information on my channel. it looks like. And then she's

channel. it looks like. And then she's updating her her to-dos constantly to track all of the work that she's doing.

Then you get a ton more calls to the YouTube Analytics MCP server. So here is where she's probably doing the competitive research. So yeah, here's a

competitive research. So yeah, here's a competitor video. Stop using cloud code

competitor video. Stop using cloud code wrong. So she continues to work and that

wrong. So she continues to work and that eventually ends uh 8 minutes later with this output that we got here. We already

saw this in the terminal when we were running L. But if we continue scrolling

running L. But if we continue scrolling down. So this was the second input that

down. So this was the second input that we made. So this was our second

we made. So this was our second conversation turns where we said that sounds good. Let's move forward with

sounds good. Let's move forward with this and go ahead and generate all of the thumbnail options. And so if we click into this, you can see this ran for another 3 minutes. And again, this

is where she was running bash commands to call Gemini CLI and actually generate these thumbnails using Nano Banana.

Finally, we had one more conversation turn where we chose our final concept that we wanted to move forward with and then told her to go ahead and update the final document. That took about a

final document. That took about a minute. So, all in all, it took L maybe

minute. So, all in all, it took L maybe 12 or so minutes to do all of the competitive research, find similar

videos to mine, extract the patterns for titles, thumbnails, uh, video ideas that were working, identified content gaps, did all of that, even generated using

best practices the most likely title plus thumbnail concepts that would work for this video, and then generated those thumbnails, those beautiful thumbnails

as we saw with Nano Banana.

Now, L can help with other things like financial analysis. She has other tools

financial analysis. She has other tools and skills, but I really wanted to showcase this more comprehensive and complex task where this used to be an

entire workflow that again would take me hours to complete from start to finish.

From doing all the research myself to, as you saw, coming up with uh ideas, brainstorming, and then eventually finding that optimal combination of

title, thumbnail, and hook. So, I spent a lot of time getting this system to work how you see it here with the outputs uh pretty much exactly how I

want. But again, that took me a decent

want. But again, that took me a decent amount of optimizing. But it's all worth it because this now saves me hours every

single week. So hopefully that was

single week. So hopefully that was insightful of how this system works and how you can potentially build one for yourself to start generating some real

value and time savings for your own work. Thank you guys so much for

work. Thank you guys so much for watching. Give this video a like if you

watching. Give this video a like if you learned something, if you enjoyed it, and subscribe to check out my next video on where I'll be sharing the highest

lever hard one lessons that I've learned in making this system. Thanks so much for watching and I'll see you in the

next one. Bye.

next one. Bye.

[Music]