WEBVTT

00:00:00.160 --> 00:00:09.760
Well, hello there. How's it going, everybody? Today, we're gonna go over my 50 Cloud Code tips. I've been working with Cloud Code basically every day for about six months now,

00:00:10.000 --> 00:00:18.385
and I feel like I've learned a ton of things. And, yes, I am one of those engineers that are basically not writing code anymore.

00:00:18.545 --> 00:00:22.545
I'm still in Cloud Code, like, twelve hours a day, actively

00:00:22.545 --> 00:00:51.075
pair programming with Cloud Code, basically, and reviewing a ton of code. I still read every single line of code. That's actually my biggest bottleneck right now, the reviewing of the code. But I thought it would be great to show you kind of the best tips that I've learned along the way, and these are kind of tips that I wish I knew when I was first getting started. We're gonna start off with some foundation stuff like setting up very quick setup stuff, a little bit about, like, Cloud. MD rules, like, what you should put in, what you should think about,

00:00:51.475 --> 00:01:02.160
and kinda some of the advanced stuff for later. But without further ado, let's dive into 50 Cloud Code So I got my terminal here, and I just have some slides behind to

00:01:02.560 --> 00:01:06.080
tell you guys what I'm doing. So here is the foundations

00:01:06.080 --> 00:01:09.600
that I mentioned. We're gonna cover getting started, keyboard shortcuts,

00:01:09.995 --> 00:01:16.795
some essential, like slash commands, and a little bit of a deep dive into the Cloud. Md. So let's get started.

00:01:17.435 --> 00:01:18.075
Alright.

00:01:18.315 --> 00:01:22.875
So for tip number one, you wanna run Cloud Code in your root directory

00:01:22.875 --> 00:01:35.790
of whatever project you're working on. So for example, I have this Pomodoro app that I'm, like, kinda been working on. So I'll type in, like, Claude here, and that's essentially how you get started. And you really wanna do this because

00:01:36.030 --> 00:01:39.710
later we'll talk about this, but if you have rule files or any kind of setup,

00:01:40.305 --> 00:01:59.050
the initial root directory is where Cloud is gonna zip up the context into that first token. So if you ever wonder why you had a bunch of tokens used even though you just opened up Cloud, this is probably the reason why. It's because Cloud's getting your project ready. Alright. So one of the first things that you wanna do is run slash init

00:01:59.290 --> 00:02:11.135
like that. And what this does is cloud will go and look at your code base and do an analysis of your code base and then create that initial cloud dot m d file in the dot cloud directory

00:02:11.135 --> 00:02:12.415
of your code base.

00:02:12.575 --> 00:02:14.735
Now there is, like, different

00:02:14.895 --> 00:02:25.455
directories that you could source from. Like, you could have a global one or, this one. But, yeah, at a high level, what this is doing right now is just is just looking at the code base, looking for the architecture,

00:02:25.970 --> 00:02:28.770
and then, basically, it's creating that Cloud. Md.

00:02:29.010 --> 00:02:33.650
Alright. So it just finished. It does take some time. And as you can see, it's

00:02:33.810 --> 00:02:44.925
kinda going and saying, oh, this is this is like a Next. Js 15 app. It's like a portfolio site. But, yeah, it's just going over high level things about this particular project,

00:02:45.485 --> 00:03:01.550
and then you could just essentially hit yes to commit that to your dot clot. So this is, like, really important for new projects, so I highly recommend you to run it. Alright. So the tip number two is that clot dot m d file that we just created, it kinda runs on a hierarchy.

00:03:01.550 --> 00:03:03.950
So if you go to memory slash memory,

00:03:04.350 --> 00:03:14.295
you could kinda see right here that there is a checked in memory, which is the current root directory, and then there's a user memory. This is like your global one. So that's, like, in your tilde

00:03:14.295 --> 00:03:27.560
dot claud slash claud. So you could kinda choose between it, but it's it's really there so you can know what the core rule that the cloud code is operating on right now. Looking at the cloud.md that Cloud just created,

00:03:27.880 --> 00:03:52.480
like, this is a pretty good one to get started. Right? It just has, like you you don't want it to be too large. It's, like, very small. Right? I I think around 300 lines is about a decent place that you wanna aim for. And to be honest, going larger is fine, but just remember that every time you increase that initial context window, you're gonna use more tokens, first of all, but also the more bloat you have in your context,

00:03:52.800 --> 00:04:04.285
the less likely the AI will do exactly what you're trying to do. Alright. So for structure and what you should be thinking about putting into your Cloud. Md, I just opened another

00:04:04.365 --> 00:04:07.165
project. This one is my Anime Pomodoro.

00:04:07.245 --> 00:04:20.620
This is an iOS app, so I wanted to show you a little bit more examples. But, basically, the things I like to put is, like, high level technical architecture and the requirements, You know? Like, what is the project? Like, that's kind of important.

00:04:21.100 --> 00:04:34.665
And then you wanna give it, like, some domain context. Right? Like, oh, it's using Swift UI, and I probably would add high level architecture and, like, kinda the file path and things like that. And just some of the high level design patterns,

00:04:34.905 --> 00:04:59.580
like, you'll see, like, all of that should go in here. And then one of the important thing is kind of having your build flow, like, your validation flow, and this is, like, kinda where my build and validation is. So you can see that I'll, like, build the Xcode and then build a project, make sure things compile. Just having this loop of validation is so amazing because the AI will just be able to self improve

00:05:00.175 --> 00:05:03.375
and keep going until it fixes itself.

00:05:03.615 --> 00:05:16.140
So, like, if you're ever in that situation where you just, like, ask cursor to do something or ask some AI code agent to do something and it just doesn't work, a lot of that gets resolved when you fix the validation.

00:05:16.220 --> 00:05:17.740
And validation,

00:05:17.740 --> 00:05:29.755
I think, as a side tip is probably one of the most important topics that you should really think about when you're thinking about trying to build good AI agentic, like, coding systems or any workflows

00:05:29.755 --> 00:05:34.875
is really what is the validation loop because that will dramatically improve

00:05:34.955 --> 00:05:39.995
how good your AI will be. Alright. So let's go to some keyboard shortcuts.

00:05:39.995 --> 00:05:48.460
And the reason why I even have this entire section for this is because if you're gonna be in Cloud Code all day, every day,

00:05:48.780 --> 00:05:52.140
like, you're an engineer, you're just gonna be on this workhorse

00:05:52.475 --> 00:06:00.475
for quite a while. So you should learn how to actually use most useful hotkeys, and there's essentially

00:06:00.475 --> 00:06:12.890
shift tab toggle modes is pretty useful, and that's just like hitting shift and tab. And then you can see right here that we're switching from accept edits to plan mode. I actually use plan mode quite heavily.

00:06:13.210 --> 00:06:16.250
I I think I use plan mode almost exclusively

00:06:16.250 --> 00:06:30.775
whenever I start a new feature. It's rare that I start in edit mode. I always just want to verify and double check that my assumptions about the code base that I'm working on and the the direction that I'm trying to go with is the best option.

00:06:31.095 --> 00:06:38.250
So I usually start in plan mode and spend a decent amount of time before I go to accept and just, like, start execution.

00:06:38.330 --> 00:06:45.370
Alright. Escape interrupts. Let me just get something started here. Tell me a good way to plan a live activity

00:06:45.945 --> 00:06:46.585
for

00:06:46.825 --> 00:06:52.185
when I background the app. Okay. So I'm gonna let this go to show you guys what escaping

00:06:52.185 --> 00:07:09.230
the interrupts is, but you can see that Claude is, like, thinking here, and it's, like, going through and doing things. Sometimes if especially during plan mode, you wanna kinda, like, look at this and look at the thinking and see if it's going off track. If it is, you just hit escape,

00:07:09.390 --> 00:07:10.830
and then it interrupts.

00:07:10.990 --> 00:07:18.005
Now a lot of people might be, like, kind of, like, scared to interrupt it, but you can just, like, hit up and then go right back to where you're doing,

00:07:18.565 --> 00:07:47.010
or you could just interrupt it and tell it something else. The whole point is Cloud Code has a really good way of, like, deducing and entering prompts in a nice queue. It, like, it logically knows what to do. So you don't have to be so scared to, like, enter more than one prompt and also, like, escaping early and interrupting and changing course. Like, it's actually recommended to do that. Tip number eight is if you ever had something, like, really big where you copy paste something

00:07:47.385 --> 00:08:06.130
and you're like, oh, I don't wanna delete everything, a handy shortcut here is just double tap escape, and it'll clear the input. There's also a VIN mode if you're into that, but I use this all the time. Another thing is when you're on an empty input, if you double tap escape, you'll see that you can rewind to, like, a previous point

00:08:06.530 --> 00:08:16.370
and then restore that context point. This is kinda common with clock code, but a lot of the tools, I feel like, is really built to manage your context and context engineering.

00:08:16.965 --> 00:08:18.965
And then there's just, an agent

00:08:19.125 --> 00:08:21.445
that is wrapped around the orchestration.

00:08:21.445 --> 00:08:37.160
But a lot of the, like, slash commands and stuff that we'll be going over, I feel like it's it's really to manage that context window. Alright. Screenshots is obviously a pretty common thing to do. There's a lot of ways to do it, but you can essentially take a screenshot

00:08:37.160 --> 00:08:43.960
and then drag it over and just drop it in. And then, obviously, another good tip is to add context.

00:08:44.465 --> 00:08:47.265
This is a cool picture of the Clockholm mascot.

00:08:47.505 --> 00:08:50.065
Do something with it. I don't know. But

00:08:50.305 --> 00:09:41.260
yeah. So that's a really good example of, like, taking a screenshot and bringing it over. If you are doing any kind of UI work, you'll definitely use this workflow. I also highly recommend finding, like, a Figma MCP or some form of MCP that works really good with the specific validation that you're trying to do. Alright. Moving on to essential commands, and this is slash commands. Before I end on the keyboard shortcuts, there's a lot more keyboard shortcuts, things that I don't use all the time. If you just go to, like, slash help, you'll be able to see a bunch of them. But the ones that I covered, I use all the time every day. So definitely just memorize it. I think it would be really useful. Now essential commands is, like, the slash commands that I think you should know about. There's way more slash commands, and you could, like, make your own slash commands, but these are the ones that I think is useful. Alright. So

00:09:41.795 --> 00:09:45.395
slash clear is basically a way to

00:09:45.635 --> 00:09:53.075
clear the context. Now you could actually do this by just creating another instance of Claude. Right? That's basically the same thing.

00:09:53.555 --> 00:10:12.790
But if you don't wanna, like, do that, you could just clear the context. And this is really good if you wanna start a new feature and you're completely done with the old task, and you don't want the old context to blow up the new context and influence the new project that you're doing. Alright. So I just loaded some stuff. Let's go into slash context.

00:10:13.325 --> 00:10:16.845
What this does is it will give you, like, a visual representation

00:10:16.925 --> 00:10:19.565
of the current context

00:10:19.645 --> 00:10:20.445
that

00:10:20.605 --> 00:10:58.260
Cloud Code is operating in. Now why is this useful? So the main reason why this is useful is because it gives you an opportunity to reason about the context that Cloud Code is making assumptions on on your code base. Now I always say context is best served fresh and condensed, and you really want to take a look at this from time to time. If you ever felt like Cloud Code has regressed and, like, things are not working the way it is or your, like, cost and usage, like, bill is going up, you really wanna look at this and then see which are, like, the most biggest offenders.

00:10:58.260 --> 00:11:07.780
Right? You just wanna, like, audit it. Like, MCPs are one of those very common things that blows up your tokens. I mean, like, look at all of this Xcode related MCPs.

00:11:08.135 --> 00:11:28.680
And every time it runs, they're like I mean, these are not a lot because I haven't been doing that much in this particular workflow, but you could just imagine that once I start doing those iteration cycles, this, like, usage will, like, blow up. But So if you look at this and you're like, oh, this MCP is using so much, then you could remove it or just disable it for this directory.

00:11:28.840 --> 00:11:54.640
So slash context is something that you probably should not ignore. Again, I think Cloud Code, all of the tools is really there to manage a lot of the context and doing really good context engineering, so this is a good slash command. Alright. So in terms of compaction, like, if you use CloudCode at all, if you had a long session, it'll start auto compacting at some point. All auto compaction does is it takes your current context window, like context that you created,

00:11:54.880 --> 00:12:06.485
and then it will just summarize it. And then it does a pretty good job. For my projects, I usually just let the auto compaction work, but if you really want to compact what you have right now, you could just compact.

00:12:06.965 --> 00:12:11.365
But I I rarely use this. The only time I use this is if I wanna save

00:12:11.605 --> 00:12:12.725
some version

00:12:12.965 --> 00:12:34.715
of my context into, like, my local, like, second brain. If you haven't seen that video, go and check it out. But I have the second brain concept when I work on projects, and that's where that goes. So for slash models, this is, like, very useful, I think, if you have unlimited tokens. Like, if you're doing this at work, for me, I usually just default it to Opus 4.5.

00:12:34.715 --> 00:12:43.435
But if you're very, like, cost sensitive and you know certain workflows work well in Sonnet or, like, Haiku, then you could just go and change that.

00:12:43.915 --> 00:13:05.855
Keeping at default is fine too, but I would try to use Opus as much as possible. Alright. So slash resume is really useful if you accidentally, like, lost your instance. Let's say you created another one and then you accidentally killed it or something like that. Right? Oh, you killed the wrong one or something. Then when you go back into ClawCode, you could just slash resume

00:13:06.655 --> 00:13:07.535
like so,

00:13:08.015 --> 00:13:21.930
and then it'll give you kind of the old context, and then you could, like, recover your context so that you don't lose the all the work that you did in building up that context window. Alright. Slash m c p is really about

00:13:22.410 --> 00:13:25.050
showing the MCPs that you have installed.

00:13:25.610 --> 00:13:30.785
If I have to be honest, I try very, very hard to not use MCPs

00:13:30.945 --> 00:13:38.625
because I think they blow up your context window. So I only install ones that are needed for that very specific project,

00:13:38.785 --> 00:13:45.440
and I try to just leverage Cloud Code and write scripts and, like, these kind of things manually, like myself,

00:13:45.600 --> 00:13:50.560
to do the validations and things like that. But some projects, you just do need MCPs.

00:13:50.560 --> 00:14:02.405
Like, this Xcode one, you kinda need it. And for other projects like my Next. Js apps, I have, like, a whole set of MCPs for that. But just be careful with MCPs, but it's a really fantastic way

00:14:02.565 --> 00:14:07.765
to teach Claude how to do certain things, especially with, like, third party software

00:14:07.765 --> 00:14:35.185
and things like that. You know, it's a protocol. Right? Model context protocol. So it's basically used everywhere, but, again, it's known to blow up your token usage and your context window. So just be careful. Alright. So slash help is the last thing I'm gonna teach you, you know, teach a man how to fish. So this, like, little wizard here will just teach you what they are and give you, like, descriptions of everything. So just go ahead and, like, try these out and just take a look and, you know, explore. Alright. So the next thing is around git. So

00:14:35.530 --> 00:15:12.690
you could ask Cloud Code to manage your Git. I think there's a bunch of, like, skills you could download to Cloud Code to manage all your Git, and I think that's something that you should do. Like, I write a lot of my summaries and test plans all using, like, Cloud Code now. Obviously, I have my own templates that I wrote, so Cloud kind of sounds more like me and is not too verbose and things like that. So I highly recommend you to use Git as a safety net. There is actually a rewind feature, like I think I told you, where you could restore the code in the conversation, but this is a little confusing to me. Like, Git is just better. I use this as, like, a last resort if I didn't have Git

00:15:13.010 --> 00:15:33.785
for a certain checkpoint. So now that you know how to just navigate around Cloud Code and things like that and just kinda high level important, like, commands and things like that, I think it's a good time to deep dive into the cloud dot m d file. I think for most people, most users, like, 80% of users,

00:15:34.410 --> 00:15:54.285
if you just have a really good cloud dot m d file for your project, you could get really, really far without learning, like, all the advanced stuff. Just having a really good rules file will save you a lot of headaches. Let's kinda dive a little bit deep into this. Okay. So one of the most important things in

00:15:54.605 --> 00:16:11.710
the claw dot m d files is first of all, it's like, it actually reads top to bottom, and it keeps the priority from top to bottom. I think that's, like, a very small nuance. I'm pretty sure that's true. I think I read that somewhere. But So you wanna go top to bottom as, like, important to least important.

00:16:12.030 --> 00:16:26.295
And you wanna add things that are, like, never do something, but always do this. And then have, like, clear snippets of examples, I think, is really good. And I don't have that many on this particular project because it's stock SwiftUI,

00:16:26.295 --> 00:16:44.440
but the context here is that you should really think about how unique is your project, how many things about your project is, like, homegrown and, essentially, like, the AI may have never seen. Like, remember, a lot of this code is, like basically, a lot of the AI, like, coding is basically just

00:16:44.555 --> 00:16:45.835
an accumulation

00:16:45.835 --> 00:16:53.515
of, like, the best code that the AI is trained on. So it might not know your, like, super special

00:16:53.835 --> 00:16:54.715
DSL

00:16:54.715 --> 00:16:58.395
language that you created or, like, some random archaic

00:16:58.780 --> 00:17:00.940
patterns that your company has,

00:17:01.180 --> 00:17:08.060
and that's where you'll be like, oh, why is the AI never doing this? So whenever you run into something like that, you wanna fix it manually,

00:17:08.220 --> 00:17:09.180
and then you just

00:17:09.500 --> 00:17:11.340
update your cloud.md

00:17:11.655 --> 00:17:22.135
rules so that it never does that mistake again. Think of it as, like, Lint files kind of. And then when you ask Cloud to update the rules, you shouldn't ever do it manually.

00:17:22.135 --> 00:17:34.590
You should just go here into Cloud and and say, hey. Can you update that rule for me so we never do it again? Something like that. Like, as simple as that, we'll go and update the your Cloud dot m d files.

00:17:35.150 --> 00:17:48.165
You see how it's trying to do it? Obviously, there's nothing that I just did, so it says nothing to add. But yeah. Okay. It it added something that I thought, but you get the point. Alright. So this next one is really around

00:17:48.245 --> 00:17:49.925
using, like, keywords

00:17:49.925 --> 00:18:05.330
to trigger your skills. So, basically, I have these, like, build commands inside of my rules. So when I say, hey. Use my Xcode MCP to build, it'll try to build the app, for example. Use my Xcode MCP to build the app.

00:18:06.770 --> 00:18:31.610
Okay. My whisper stuff is, like, failing a little bit, but maybe you'll get the gist of it from build the app. And as you can see, it's it's asking if I can use the Xcode Build MCP. So that's kind of the high level of, like, using skills and, like, trigger words to be able to trigger a certain behavior. This next one is something called, like, compound engineering. That's, like, kind of a new term that is being discussed, but

00:18:32.250 --> 00:18:36.810
it's essentially to take your Cloud. M d and start,

00:18:37.450 --> 00:18:54.235
like, committing it into the code base. Now, obviously, you need to get rid of anything that's, like, generic for your code, like file paths and things like that, and you also wanna be mindful of how large this file becomes. Right? Because, like I said, every time someone hits

00:18:54.640 --> 00:19:25.100
Claude in that directory or Claude is trying to read that directory, it will load that Claude dot m d file. So you don't wanna blow up other people's context windows, so you really wanna be have this be, like, a high bar when you're committing it. But the nice thing is once that's in, you essentially make that AI coding experience better for your teammates. But you just need to make sure that whatever you're landing is actually helping. There's a lot of school of thoughts around this right now. I don't think it's, like, completely solved, but there's gotta be some form of evaluations

00:19:25.100 --> 00:19:34.300
here. And a lot of people are just using, like, Vibes. So you just, like, test it for, like, a few weeks, and then you just try to land it aft and then ask for feedback, essentially.

00:19:34.540 --> 00:19:42.055
So dangerously skip is essentially like claw code in YOLO mode. You know? Like, just basically,

00:19:42.215 --> 00:19:52.090
if you use claw code, it'll ask you to accept a bunch of stuff. It could get really annoying. So a lot of people, they use, you know, clawed and then dash dash dangerously

00:19:52.650 --> 00:19:53.210
skip.

00:19:53.530 --> 00:19:55.450
Okay. So it's

00:19:55.770 --> 00:19:58.410
dash dash dangerously skip permissions.

00:19:58.810 --> 00:20:00.650
And when you run this,

00:20:01.050 --> 00:20:12.485
Claude code will no longer ask you essentially to accept that. I think it will completely just ignore it except for, like, anything you put into your slash permissions, which we'll talk about. But

00:20:12.805 --> 00:20:15.365
you only really wanna do this in in

00:20:15.525 --> 00:20:18.565
environments that you can kinda throw away

00:20:18.890 --> 00:20:34.925
and you're doing specific work that is not, like, super dangerous. Like, if you're gonna start touching the OS and stuff like that, you could really mess it up. I've messed up some of my Linux machines because I was just going too aggressive, and I was just testing it out, and I was trying to set up some of my Linux stuff using ClockCode,

00:20:35.005 --> 00:20:40.045
and then, like, I had to reflash the entire thing. Like I said, you can use slash permissions

00:20:40.045 --> 00:20:42.045
here to kind of, like,

00:20:43.005 --> 00:20:51.980
tell which ones are like, you still want to accept. So it does you know, like, r m dash r f or something, like, don't do that. Or

00:20:52.300 --> 00:20:57.660
yeah. Just like mutations. Like, just be careful with mutations, like, deletion mutations. Right?

00:20:58.540 --> 00:20:58.940
Alright.

00:20:59.445 --> 00:21:07.445
The next big one, I think, now that we talked a little bit about the CloudNMD rule of files, I think we should talk about workflows

00:21:07.445 --> 00:21:08.245
because

00:21:08.325 --> 00:21:13.365
I have a very specific way I'd like to work, and I've actually refactored

00:21:13.365 --> 00:21:14.805
my entire work

00:21:15.400 --> 00:21:28.920
so that it's works with Cloud Code. You know, I used to use Cursor or, like, Android Studios mostly and Versus Code to do a lot of coding and stuff like that, but I dropped basically all of that, and I use just iTerms now.

00:21:29.905 --> 00:21:37.265
Some people use, obviously, Vim, but I think iTerms is fine. So I'm gonna show you guys a few things. So

00:21:38.145 --> 00:21:39.185
like I said,

00:21:39.425 --> 00:21:58.775
I always start with plan mode. Let's go in, like, plan, like, a little feature for this Pomodoro app that I've been, like, kinda working on. I don't know. I actually need to remove a bunch of audio stuff. So let's just say, audit my code base and make sure that we're removing all of the audio playback and references to the audio

00:21:59.095 --> 00:22:06.375
of part of the Pomodoro app. I'll always start with plan mode, and I'm, like, iterating with Cloud Code.

00:22:06.695 --> 00:22:12.880
I'm arguing with it. I'm having a conversation with it. You know, Clocko, you're so beautiful. You're so amazing.

00:22:13.840 --> 00:22:21.840
No. But, like, I'm really treating it as, like, another, like, just good engineer that I'm, like, working with, and I'd never just, like, purely accept

00:22:22.495 --> 00:22:32.335
the first answers that it gives to me. I'm always kinda challenging it, and I spend a lot of time and put a lot of effort at this stage of the development.

00:22:32.735 --> 00:22:37.775
Because I feel like once CloudCode builds up that context and have good execution

00:22:38.300 --> 00:22:39.100
specs,

00:22:39.100 --> 00:22:47.500
the generation of the code is actually the easy part. And I I do wanna take a moment and talk about, like, kinda the news cycle about people saying,

00:22:47.820 --> 00:22:52.455
oh, like, people are no longer writing code. I think, like, the

00:22:52.855 --> 00:23:13.580
creator of Node. Js said, like, the era of, like, people writing code by hand is essentially over, and I actually truly believe that. And the thing is I love, like, being in the zone and writing code. At least I used to. The thing is it's really hard to get back into that mode. It's, like, very different levels of abstractions of the way you're working.

00:23:14.060 --> 00:23:18.620
And right now, I'm just doing one instance of it, but you could imagine

00:23:19.020 --> 00:23:21.660
just having, like, multiple cloud instances

00:23:22.085 --> 00:23:31.205
like this, and and and then you're just actively working on a bunch of different things at the same time. Because you have this, like, new superpower,

00:23:31.525 --> 00:23:35.845
the new next level of engineering is really, like, jumping between

00:23:36.085 --> 00:23:37.445
cloud instances

00:23:37.640 --> 00:23:40.120
and and really context engineering

00:23:40.680 --> 00:23:51.135
that instance and then getting it good enough to start executing. And I keep talking about this, like, context. Right? And this tip is really around, like, fresh context

00:23:51.135 --> 00:23:55.055
beats, like, bloated context. I think I kinda cover this throughout this,

00:23:55.455 --> 00:24:26.425
but that's why you wanna start with plan mode, make sure it's good, and then just go and execute. Instead of, like, having a bunch of, like, try this and then try that and then try this and then try that. Like, that will just bloat that context and then the AI will get really confused at some point because it it can't remember what what part of what was good and not good. So that's why you wanna spend the time in the beginning building up the good context, have a good plan doc. So it always has something that initially was good to reference,

00:24:26.505 --> 00:24:31.865
and then it builds little by little. Alright. So this next one is really around persisting

00:24:31.865 --> 00:24:32.665
that context.

00:24:33.520 --> 00:24:36.080
I have a full video on this about,

00:24:36.400 --> 00:24:46.560
like, the second brain concept, so I'll link it here. But the idea here is that, let's say, you've finished something. You could just say, save this to my local cloud.md

00:24:46.560 --> 00:24:48.125
in my project's directory.

00:24:48.125 --> 00:24:58.685
Save the work that we just did. So you you could say something like that, and then, um, I I essentially have a full workflow for this to manage this. But, yeah, you you could do that.

00:24:59.485 --> 00:25:01.005
Load my context

00:25:01.005 --> 00:25:01.725
from

00:25:02.125 --> 00:25:02.365
my

00:25:03.030 --> 00:25:08.790
local projects. So once you have that second brain concept, you could say a command like this,

00:25:09.110 --> 00:25:11.990
and it will pull that context

00:25:12.150 --> 00:25:30.235
and then load it for your new session. So here's a good example. I like to do a lot of my to dos inside of Cloud Code itself. These are kind of the high level things that I still need to do for this next feature that I'm working on. So I'm, like, working on a widget for this Pomodoro app, and I have, like, a live activity, for example.

00:25:30.890 --> 00:25:35.050
And I'm also, like, deleting all the music stuff because I don't think it adds value.

00:25:35.290 --> 00:25:40.650
So I have a bunch of stuff that I'm tracking, but because I keep all the to dos in my local

00:25:40.730 --> 00:26:04.060
index, like, that I'm lazy loading, I don't always load it. I only lazy load it when I ask for it. It allows me to, like, context switch from project to project without, like, carrying around, like, complex, I don't know, Asana boards or whatever. I just keep it all in here, and it's this is this works because it's my own project. But you can technically do this with, like, an MCP with Asana or, I don't know, Jira or whatever

00:26:04.220 --> 00:26:15.315
as long as you can whatever project management that you can think of. Alright. So I think we covered this a little bit, but really think about the build cycle. Like, obviously, if you're mobile,

00:26:15.555 --> 00:26:34.340
think about x code building the x code. But there's a lot of other workflows that you could think of. Like, for example, you could ask Cloud Code to like, let's say you're debugging something that's, like, kinda tricky, has, like, race conditions or things like that. You could ask Cloud Code to, like, add debug logs, for example, and then run the app and then

00:26:34.660 --> 00:26:52.865
have Cloud Code control the emulator. You could just ask it to do that and then, like, do the actions that you're trying to do and then read the logs through a tail log or something and then debug that way. Or you could use, like, Perfetto or something like that for kind of performance things. You could hook into Perfetto MCPs,

00:26:53.410 --> 00:27:20.525
do a run, and then have it read the traces, and then see if it can find jank just from, like, the timings. Right? There's just so many validation loops that you could think of. Like, for web, you could do, like, Puppeteer and have Claude navigate it using a slash Chrome command and then just actually do the navigation or have it write just test or have, like, integration end to end integration test. You know, there's there's a lot of things that Cloud Code could do, and it really is up to your imagination.

00:27:20.525 --> 00:27:25.400
But it's the single most important thing in my opinion if you wanna have a more

00:27:25.800 --> 00:27:32.520
automated loop that, like, generates good code on, like, the first try. So going back to the slash models,

00:27:32.600 --> 00:27:44.605
really just consider using Opus if you can afford it. It's just the best way. All of these are a little bit slower, but because the way I work is I have multiple cloud instances, obviously,

00:27:44.925 --> 00:27:50.765
it's, like, very small, right, in here, but I have multiple cloud instances running at all times.

00:27:51.370 --> 00:28:00.250
And then the way I work is basically just juggling these cloud instances. So even if one of them takes a long time, it doesn't matter because I'm

00:28:00.410 --> 00:28:00.970
like,

00:28:01.210 --> 00:28:08.405
I gave the command, and I go to the next one. I'm building the context. I give a command, and I go to the other one, and then I give a command.

00:28:09.045 --> 00:28:11.605
So so, like, you end up, like, still

00:28:12.165 --> 00:28:17.685
can get into the zone, but it's, a different style. So I talked a little bit about interrupting

00:28:17.685 --> 00:28:18.405
earlier,

00:28:18.725 --> 00:28:20.325
but you really want to,

00:28:21.050 --> 00:28:23.210
like, look out for, like, assumptions

00:28:23.210 --> 00:28:28.010
or the keywords are like, oh, I'm not really sure, or you'll see, like, errors happening.

00:28:28.250 --> 00:28:32.490
I'm having a hard time, like, getting it to do this in this example, but

00:28:33.210 --> 00:28:36.170
just just know that, like, when you

00:28:36.995 --> 00:28:38.995
go and look for the

00:28:39.235 --> 00:28:42.355
best ways to delete an app. I don't know.

00:28:43.395 --> 00:28:48.115
I I'm just giving it a random prompt to try to make it go off course,

00:28:48.515 --> 00:29:28.760
but if you see it going and making assumptions about certain things okay. This time, it didn't even because it's just new. But you should just interrupt it like that. You know? And then and then just course correct it. So don't worry about course correcting. Okay. So the next section is around power users. I I don't really like to say power users, but most people that I've talked to don't really know, like, the differences between a slash command or a skill. They're they're kinda interchangeable now. And MCPs, sub agents, you know, post hooks, pre hooks, like, these kind of primitives that ClockCode is, like, known for and kind of, like, invented. And we're gonna cover some of that and and how this

00:29:28.920 --> 00:29:39.675
these are all, like, composable in nature. Okay. So I call it the composability framework, but it's I just really wanted to highlight that these are composable more than anything. But there's

00:29:39.835 --> 00:29:48.150
four primitive, like, composable things. All the slash commands are technically composable with each other, not directly each other, but anyways.

00:29:48.230 --> 00:29:50.790
So we're gonna just go over the fact that, like,

00:29:51.270 --> 00:29:53.030
how these are composable.

00:29:53.030 --> 00:29:55.830
Okay? So let's first talk about skills.

00:29:56.150 --> 00:30:01.355
All a skill is is is, like, you do a workflow. So let's say that

00:30:01.835 --> 00:30:06.955
I tell Claude, go and fetch Hacker News for latest iOS news.

00:30:08.555 --> 00:30:13.275
So let's say I tell it to go and fetch Hacker News for the latest iOS news,

00:30:13.910 --> 00:30:14.710
and then

00:30:15.030 --> 00:30:17.110
and then I tell it to save that.

00:30:17.430 --> 00:30:18.070
Okay.

00:30:18.470 --> 00:30:19.990
And then save

00:30:20.390 --> 00:30:21.590
a summary

00:30:21.590 --> 00:30:22.870
to my

00:30:23.510 --> 00:30:24.230
local

00:30:25.670 --> 00:30:27.110
claud.md.

00:30:28.165 --> 00:30:29.685
Claud directory.

00:30:31.125 --> 00:30:36.805
Okay. I misspelled that. But, basically, let's say that it went and found some, and then it's

00:30:36.805 --> 00:30:52.000
save it into my local directory. Let's say I wanted to build a skill around that. So you just saw me do two things. One is fetch something from a source like Hacker News and then save that thing to my local directory. That's technically a workflow.

00:30:52.400 --> 00:31:01.875
So all you have to say do is save what we just did into a new skill called fetch hacker news. And that's basically it to create a skill.

00:31:02.115 --> 00:31:05.395
It's basically a recurring workflow that you can

00:31:05.715 --> 00:31:08.915
just tell Claude to remember. And behind the scenes,

00:31:09.155 --> 00:31:18.970
it's actually just an MD file, as you can see right here. Oops. And as you can see here, it's literally just a system prompt. It's an MD file.

00:31:19.290 --> 00:31:20.490
But Claude

00:31:20.890 --> 00:31:32.555
has specific directories that is looking for skills, and it will be able to infer this next time I say, go fetch something from Hacker News or use my Hacker News skill to fetch articles.

00:31:32.555 --> 00:31:35.675
Yeah. And then commands is basically now interchangeable.

00:31:35.675 --> 00:31:38.635
It's it's a pretty recent change, but you can see that

00:31:39.675 --> 00:31:40.475
skills

00:31:40.475 --> 00:31:42.715
is written into the skills documentary,

00:31:42.715 --> 00:31:51.890
and it there's also now a slash command called slash fetch hacker news. This is a very recent change from Anthropic where they kind of, like, combined

00:31:52.050 --> 00:32:16.100
commands and skills. But yeah. So now you can just do slash hacker news, and then now it'll rerun that system prompt, for example. It added, like, an additional, like, assumption thing. That's pretty cool. It's not exactly what I did, but it kind of inferred that I would probably want that. So those are the little cool things. And and the thing is you could update these anytime you want. You know? You could just ask Claude to do do something else.

00:32:17.460 --> 00:32:24.420
Alright. So like I said, you never wanna manually create these kind of stuff. You wanna get in the habit of

00:32:24.660 --> 00:32:27.300
asking Claude to update and manage

00:32:27.925 --> 00:32:35.685
these skills. So we could say, why don't you extend this fetch hacker news to fetch Twitter or Apple news, for example.

00:32:35.765 --> 00:32:37.045
Now sometimes

00:32:37.205 --> 00:32:39.045
it won't work 100%

00:32:39.045 --> 00:32:43.525
exactly. Right? Okay. So you see this? It doesn't have Twitter authentication access,

00:32:44.380 --> 00:32:45.820
so it's

00:32:46.140 --> 00:32:48.380
trying to just do some other ways.

00:32:48.540 --> 00:32:52.380
Yeah. Multiple sources. So you can see how it's all updating

00:32:52.540 --> 00:32:57.100
that system problem that we wrote. Right? And then fetch hacker news

00:32:57.340 --> 00:32:58.060
and so forth.

00:32:58.725 --> 00:33:02.165
You you get the idea. Alright. So MCPs,

00:33:02.325 --> 00:33:08.645
I think we covered it a little bit during the the rules, but, basically, MCPs,

00:33:08.965 --> 00:33:10.885
you just wanna find MCPs

00:33:10.885 --> 00:33:13.845
like this. Right? Like, they're just model contexts.

00:33:14.540 --> 00:33:23.100
But kind of a hack is, like, you don't actually need to search the web for an MCP. You could just be like, find me a good Figma

00:33:23.100 --> 00:33:23.980
MCP.

00:33:23.980 --> 00:33:30.915
You could just ask Claude to find it for you, and then most of the time, it does a good job. The only thing is, like,

00:33:31.475 --> 00:33:32.275
sometimes

00:33:32.595 --> 00:33:34.035
it's outdated,

00:33:34.275 --> 00:33:44.595
so it'll it'll, like, know of one that's was popular a little while ago rather than doing a web search. So you just have to be mindful. And that's why I'm saying, like, for certain actions, you wanna read

00:33:45.130 --> 00:33:56.090
how what it's doing and look at the thinking and then cancel it if you want to. And you could have Claude also install the MCPs, so you don't have to, like, manage, like, the configs and stuff yourself

00:33:56.250 --> 00:34:01.155
like you had to with cursor. Yeah. So you could ask Claude to install the MCPs.

00:34:01.155 --> 00:34:07.475
So, like, right here, it says, go and do this. Right? But instead, I could just be like, why don't you just install this for me,

00:34:08.515 --> 00:34:11.635
for example? And then it will just go and install it for you.

00:34:12.300 --> 00:34:18.300
Alright. So in terms of sub agents, I don't know if I have one for this. I might have, like,

00:34:19.020 --> 00:34:20.300
an iOS

00:34:21.020 --> 00:34:24.380
I might have one, like, an iOS, like, context gathering

00:34:24.380 --> 00:34:25.580
or, like, architecture

00:34:26.135 --> 00:34:30.935
agent. Let me try it. So spawn a iOS architecture

00:34:32.295 --> 00:34:33.015
agent

00:34:33.335 --> 00:34:35.895
sub agent and do some investigation

00:34:35.895 --> 00:34:39.975
on and on my code base and see if it's actually good or not.

00:34:42.220 --> 00:34:45.580
So you can build subagents just like you can with

00:34:45.980 --> 00:34:50.620
slash commands and skills. All you do is just ask it to make a subagent

00:34:50.620 --> 00:34:53.020
after you do the work once.

00:34:53.765 --> 00:35:00.645
The main reason why you want to create a subagent is really to do parallel work,

00:35:00.805 --> 00:35:04.085
but also it's to protect your context window.

00:35:04.405 --> 00:35:10.500
So like I said, one of the key features of Cloud Code is to manage your context and do context engineering,

00:35:10.660 --> 00:35:16.500
and subagent is a huge way. And I think a lot of people are using subagents incorrectly

00:35:16.500 --> 00:35:30.155
because they do things like this where you have, like, an iOS subagent. Right? By the way, it's not triggering the subagent. I'll just make one after it creates it and show you guys what it looks like. It, like, highlights it in, like, a different color.

00:35:30.475 --> 00:35:37.080
But a lot of them have this, like, workflow where they'll tell it to go do something that does the context gathering,

00:35:38.200 --> 00:35:50.395
and then they ask to, like, bring it back. But that part that portion of the context that's bring brings back from the sub agent, it's only, like, the output. It's not, like, how it got there, so it doesn't have the full context.

00:35:50.715 --> 00:36:00.780
So for those kinda works, I usually just keep it within the context window because those are the things that are really good. Use what we just did to create

00:36:01.420 --> 00:36:09.180
a iOS architecture sub agent. But yeah. So so oftentimes, people mistake that you wanna, like, have a

00:36:09.740 --> 00:36:18.925
validator agent. You wanna have, like, a testing agent and all these kind of things, but I try to keep the all the things that need that context

00:36:19.245 --> 00:36:26.125
to do its work within the same CloudCall session. Because, like, a good testing agent needs to know about the code that I wrote

00:36:26.650 --> 00:36:27.770
most of the time,

00:36:28.170 --> 00:36:31.610
in my opinion. Of course, sometimes things could live in isolation.

00:36:31.850 --> 00:36:34.410
So what are really good things for

00:36:34.810 --> 00:37:04.340
sub agents is really just, like, things that are atomic in nature that you wanna just have it run as side effects and just go and do. But, yeah, so that's what I use sub agents for. I don't use sub agents that often. I know some people, like, love using them. But one of the most common, like, clowny kinda use cases that I've seen is, like, CEO agent, product agent, design agent, and stuff like that, and I don't really believe in that particular workflow. Like, you really wanna have this concept of bringing the work to the context

00:37:04.340 --> 00:37:11.620
rather than trying to spread out the context that gets created. Alright. So and this kinda ties into it. Like, you wanna avoid,

00:37:12.235 --> 00:37:15.675
like, having a lot of instructions and overloading

00:37:15.675 --> 00:37:19.355
the context all the time. You wanna keep your context condensed

00:37:19.355 --> 00:37:20.555
and fresh.

00:37:20.875 --> 00:37:33.980
So that watch my video on the second brain, and you like, that's it'll teach you a lot about, like, lazy loading and then having this, like, ongoing project domain thing that builds over time, and you wanna essentially

00:37:33.980 --> 00:37:35.820
use that as your rag system

00:37:35.980 --> 00:37:38.540
to build, like, a good context

00:37:38.620 --> 00:37:48.105
and then be able to just have fresh and good context all the time for your AI to execute on. Alright. So here is some interesting, like,

00:37:48.585 --> 00:37:50.025
advanced workflows,

00:37:50.025 --> 00:37:51.625
and I really think that

00:37:52.025 --> 00:37:59.040
the big game changer, in my opinion, for Cloud Code and why I think Cloud Code is just so amazing

00:37:59.200 --> 00:38:02.320
is that you can do a lot of parallel development.

00:38:02.320 --> 00:38:04.400
This is why I had to, like, fully change

00:38:04.960 --> 00:38:11.995
how I work using, like, terminal and stuff because you could run multiple instances. And I already kinda showed you guys this,

00:38:12.475 --> 00:38:22.720
but you could just swap between these and just have, like, multiple things running at the same time. So I could say, start working on my live

00:38:22.720 --> 00:38:30.320
activities feature. So I could just have that. Obviously, I would do it in plan mode, but I'm just showing you guys. And then over here, I could just say,

00:38:30.560 --> 00:38:33.040
alright. Let's test out this iOS architecture

00:38:33.040 --> 00:38:46.625
and and then just spawn a sub agent. So as you can see, I'm doing some investigation on one side, and then I'm doing live code editing. But the thing is, I could always just create another one, go to, like, a different project like this,

00:38:47.185 --> 00:38:51.590
and then now I could be saying, hey. I wanna work on a new newsletter,

00:38:52.790 --> 00:38:53.670
for example.

00:38:53.990 --> 00:39:02.630
So I could be doing a bunch of stuff all at the same time. So that's like a really so understanding how to juggle this and doing it effectively,

00:39:02.630 --> 00:39:05.725
I think, is, like, the next step function change.

00:39:05.805 --> 00:39:11.085
And I just wanna kinda shout out iTerms. I think it's, like, really good

00:39:11.565 --> 00:39:12.365
because,

00:39:12.685 --> 00:39:18.660
you know, you could do command d to create new instances like this. Right? And then you could juggle between

00:39:18.980 --> 00:39:20.980
the terminals using command

00:39:22.500 --> 00:39:29.540
the left bracket and right bracket. Like, ignore this, like, slash. It's like I'm just saying, oh, it's left bracket or

00:39:29.540 --> 00:39:30.180
right bracket,

00:39:30.635 --> 00:39:40.475
like slash. Right? But yeah. So and you could do that. You could also if you have multiple tabs like this, you can actually swap between it. And at work, what I do is I

00:39:40.635 --> 00:39:41.515
rename,

00:39:41.515 --> 00:39:55.310
like, what I'm doing in here. Like, I'll say local, and maybe here, I'll say, like, remote SSH or something like that. And then from the remote SSH, I could have Cloud, like, running like this, and I could spawn them more.

00:39:55.470 --> 00:39:55.790
You know?

00:39:56.465 --> 00:40:04.385
And then and then I could just be going back and forth here. So it really feels like I'm playing Starcraft to some degree.

00:40:04.705 --> 00:40:10.545
Right? And all of these, I'm just doing with my keyboard. And when I'm home, I'll just, like, be in Whisper

00:40:11.140 --> 00:40:16.740
using Whisper, which is, like, this voice little thing that you see right here, and it just translates

00:40:16.740 --> 00:40:35.495
speech to text really quickly. Sometimes it's not that accurate, but so I'm just, like, switching, switching, and I'm just basically talking to it, you know, just literally working as in multiple projects all at the same time. I think my bottleneck right now is really how much context switching I can do in my head. So, yeah, another thing is enabling notifications.

00:40:35.495 --> 00:40:37.895
You could tell Cloud Code to change the notifications.

00:40:37.895 --> 00:40:38.375
Right?

00:40:38.775 --> 00:40:43.890
You could just say, the notification to ring a little sound when you finish execution,

00:40:43.970 --> 00:40:44.770
for example.

00:40:45.090 --> 00:40:46.610
And then when it's now,

00:40:46.930 --> 00:40:48.050
it'll basically

00:40:48.210 --> 00:40:48.930
ring,

00:40:49.330 --> 00:40:50.610
like, a little notification.

00:40:50.610 --> 00:40:53.410
And and you could do a lot of things. At one point, I had, like,

00:40:54.050 --> 00:40:55.250
text to speech

00:40:55.490 --> 00:40:58.415
where it, like, reads a summary of

00:40:59.695 --> 00:41:06.255
one of wherever it finishes, it will read the summary. So I could be like, okay. I gotta go back to tab two and then go do something.

00:41:06.895 --> 00:41:10.015
But that was too much, so I disabled it. Gig Worktrees

00:41:10.015 --> 00:41:23.440
is another way to do multiple code execution. So one of the bottlenecks that you'll see is if you have these kind of, like, bunch of multiple instances, you'll soon realize if you're doing local development, you won't be able to make code edits to the same project

00:41:23.600 --> 00:41:35.035
unless you use Git work trees. And I'll add some descriptions on how to use git work trees, but, basically, it's it's a way to, like, clone multiple instances of your code base and have, like, different forking branches.

00:41:35.195 --> 00:41:39.675
So you could have, like you could work on, like, code, like, executions in the same project.

00:41:40.290 --> 00:41:44.130
Slash Chrome is actually a really cool tool in my opinion.

00:41:44.370 --> 00:41:48.130
So the way you get to it is by just doing slash

00:41:48.130 --> 00:41:58.285
Chrome like this, and then it'll go to, like, slash Chrome. And then it'll open this thing. You can't see it here, but there's, like, a little button. And it just opens it, and you could actually

00:41:58.605 --> 00:42:00.925
navigate the browser. So

00:42:01.565 --> 00:42:02.845
go to

00:42:03.005 --> 00:42:04.365
tip number

00:42:04.685 --> 00:42:05.405
46.

00:42:07.020 --> 00:42:15.340
So what it does is it will look at the website, and it'll and you can approve the plan. You can allow the action. So, basically, it'll create the plan, and then it will, like,

00:42:15.740 --> 00:42:20.460
do it. Okay. It doesn't it doesn't really know how to do it. So

00:42:21.565 --> 00:42:22.605
I'll say

00:42:23.405 --> 00:42:24.205
hit

00:42:24.605 --> 00:42:27.805
let let's just try YouTube. I think YouTube might be easier.

00:42:28.845 --> 00:42:32.285
Okay? So we'll we'll open YouTube and then say,

00:42:32.685 --> 00:42:33.805
find a video

00:42:34.045 --> 00:42:34.685
on

00:42:35.645 --> 00:42:36.045
cooking,

00:42:37.510 --> 00:42:38.550
for example.

00:42:39.510 --> 00:42:40.310
Yep.

00:42:43.430 --> 00:42:48.470
So you can see that it, like, takes a screenshot. It will, like, click. It'll type cooking,

00:42:48.710 --> 00:42:49.510
and then it will, like,

00:42:50.345 --> 00:42:57.385
find cooking videos, for example. And then so I use this whenever I don't have API access to certain things,

00:42:57.785 --> 00:43:04.825
but I can get there via my web. And and because you could control it via slash Chrome, you can have it

00:43:05.170 --> 00:43:09.330
as part like I mentioned, that all of these are composable,

00:43:09.330 --> 00:43:12.290
you can have a command that goes to Chrome,

00:43:12.530 --> 00:43:23.475
scrapes bunch of stuff, and comes back to you with the data. Okay. So moving on. Like I mentioned, it's really good for a power for, like, debugging. Right? You can navigate the web with it.

00:43:23.715 --> 00:43:34.195
That's also part of the validation thing that I was talking about. You can fill out forms and stuff. Alright. Hooks and automation is really just, like, kind of the cherry on top, and this is very similar to, like,

00:43:34.900 --> 00:43:36.260
GitHub's prehooks

00:43:36.260 --> 00:43:38.260
and GitHub's, like, post,

00:43:38.500 --> 00:43:41.780
like, commit stuff, like, recommit stuff. So,

00:43:42.020 --> 00:43:47.620
basically, these are hooks. And as you can tell, it's just, like, something to do before

00:43:48.185 --> 00:43:50.745
you start executing or after executing

00:43:51.065 --> 00:43:58.185
and after executing fails. Like, there's all these things that you can do, and you shouldn't manually do this. You should just ask Claude to,

00:43:58.505 --> 00:44:05.120
like, add these for you. You know? Like, go back to that principle that you're no longer main manually maintaining

00:44:05.200 --> 00:44:10.160
your work environment. And a good example on what to put here for the post

00:44:10.560 --> 00:44:13.920
tool use is, like, you know, things like

00:44:14.880 --> 00:44:21.635
art like linting and and formatting your code and things like that. And I'm not really using this yet, but, basically,

00:44:21.955 --> 00:44:24.755
uh, this is really good if you wanna block, like,

00:44:25.075 --> 00:44:30.915
removing your entire, like, database or something like that. It's it's just, like, good good to prevent

00:44:31.075 --> 00:44:32.515
very disruptive things.

00:44:32.835 --> 00:44:49.280
I haven't really set it up because, you know, I have, like, remote backups, and, also, this is, like, side projects. But for real world, you probably want something. And finally, with that, I think you got the vast majority of, like, the best tips that I know for ClockCode.

00:44:49.775 --> 00:44:54.255
The last thing I'll leave with you is to explore the, like, the plug in ecosystem.

00:44:54.575 --> 00:44:57.775
All a plug in is is a just a combination

00:44:57.855 --> 00:45:09.380
of any of these composable things that I talked about, like a skill that triggers an MCP that triggers, like, sub agents or something like that, or maybe there's, like, a bash script that's attached to a skill,

00:45:09.620 --> 00:45:14.740
that can all be turned into a plug in. And then a lot of people share their plug ins online.

00:45:14.900 --> 00:45:20.495
So this is, like, a really good example. You know, Anthropic has their own, like, plug ins, like, structure,

00:45:20.495 --> 00:45:24.415
and they have a bunch of plugins here that you could download, for example,

00:45:25.135 --> 00:45:25.695
um,

00:45:26.015 --> 00:45:34.330
like, colon ISP and things like that. So that's basically it. And the last thing I wanna say is context is king.

00:45:34.330 --> 00:45:37.050
You gotta keep it fresh, keep it relevant.

00:45:37.370 --> 00:45:39.610
You essentially need to give Claude

00:45:40.010 --> 00:45:43.370
the context that it needs and nothing more.

00:45:44.810 --> 00:45:45.850
But yeah. So

00:45:46.170 --> 00:45:53.135
go and build something amazing. I hope this was valuable to you. I hope you learned something. Go and build something amazing.

00:45:53.455 --> 00:45:57.215
And if you're interested in this kind of video on CloudClode,

00:45:57.295 --> 00:46:00.815
I did a whole video on, like, kind of the high level thought process

00:46:01.055 --> 00:46:02.975
of, like, AI coding

00:46:03.055 --> 00:46:11.750
and and also talked a little bit about my second brain thing. Those two videos are right here, so go and check it out. But, yeah, until I see you guys on the next video.