[00:00] (0.16s)
I've been using Claude Code for a month
[00:02] (2.40s)
solidly now, like really using it, not
[00:05] (5.04s)
just testing it. This video is not about
[00:07] (7.52s)
the features. I made that video and I
[00:09] (9.92s)
would really advise you go check it out.
[00:11] (11.60s)
It's got some really interesting little
[00:13] (13.20s)
patterns and little techniques that you
[00:14] (14.88s)
might use. This one is actually about
[00:17] (17.36s)
the patterns techniques that really have
[00:19] (19.52s)
stuck with me and make an enormous
[00:21] (21.68s)
difference when I use them. And I think
[00:23] (23.76s)
they'll make a difference for you as
[00:25] (25.20s)
well. Hang in there. I'm gonna go
[00:27] (27.28s)
through seven big patterns that I use
[00:30] (30.00s)
that honestly make a difference. Let's
[00:32] (32.80s)
get right in. Okay, I have to jump in
[00:34] (34.80s)
here. While editing, I noticed something
[00:38] (38.56s)
pretty horrible and I apologize for it.
[00:41] (41.20s)
Uh it's really embarrassing how many
[00:43] (43.12s)
times I mention other videos in this
[00:44] (44.80s)
video. You'll notice. Uh but honestly, I
[00:48] (48.16s)
also find it a little bit hilarious how
[00:50] (50.56s)
many times this came out of my mouth. I
[00:52] (52.88s)
noticed. I'm embarrassed. I'm sorry.
[00:54] (54.72s)
I'll do better. Let's get back in. Okay,
[00:57] (57.04s)
I'm going to push very quickly through
[00:58] (58.88s)
some of these and certainly through
[01:00] (60.24s)
these little bits at the beginning. The
[01:02] (62.08s)
first one which is little bits is just
[01:04] (64.32s)
little pieces that still actually are
[01:06] (66.64s)
very very useful and I enjoy quite a
[01:08] (68.56s)
bit. One of them is I always run Claude
[01:11] (71.44s)
code inside of cursor or Visual Studio
[01:14] (74.08s)
Code or something so that I have access
[01:16] (76.00s)
to the files that I want to touch while
[01:18] (78.16s)
Claude is touching them or changing
[01:19] (79.84s)
them. That's actually really really
[01:21] (81.60s)
helpful to me. You can also drag them in
[01:23] (83.36s)
from here to here. That's easy to do as
[01:25] (85.44s)
well. Very worth it. Another one is
[01:27] (87.44s)
hooks. So if I say h hello here, maybe
[01:30] (90.56s)
you heard the sounds go off. I use hooks
[01:32] (92.56s)
in that way. If I look inside of my
[01:34] (94.72s)
clawed settings file, you can do hooks
[01:36] (96.96s)
with a slash command. Go check my
[01:38] (98.64s)
previous uh video about this. But I'm
[01:41] (101.04s)
just using AF play to play specific
[01:43] (103.68s)
sound files when uh the thing returns to
[01:46] (106.24s)
me so that I can tell the difference
[01:47] (107.52s)
between my projects. All right, got to
[01:49] (109.12s)
move on. All right, the next one is YOLO
[01:51] (111.44s)
mode. So yolo mode is running clawed
[01:54] (114.32s)
with dangerously skip permissions. This
[01:56] (116.32s)
is something that quite frankly I always
[01:58] (118.72s)
do. This is 100% of the time these days
[02:01] (121.12s)
I run this. I have had no problems with
[02:03] (123.76s)
it. I have said this in the past. I
[02:05] (125.84s)
don't advise you do it. Use it at your
[02:08] (128.00s)
own trust level. So kind of keep an eye
[02:10] (130.64s)
on things while you're using it in the
[02:12] (132.24s)
beginning until you gain some level of
[02:13] (133.76s)
confidence. But you'll see this down at
[02:15] (135.60s)
the bottom that says bypassing
[02:16] (136.96s)
permissions. That's when you know you're
[02:18] (138.48s)
into that mode. All right. Another one
[02:20] (140.24s)
is the rapid updates by the anthropic
[02:22] (142.56s)
team. Can't say enough about this. They
[02:24] (144.48s)
update this thing multiple times a day
[02:27] (147.12s)
sometimes and they're usually quite
[02:29] (149.28s)
valuable updates that they're putting
[02:30] (150.72s)
in. The end of the last week they put in
[02:32] (152.72s)
a way to load settings from a JSON file
[02:35] (155.28s)
externally and the agents mechanism that
[02:38] (158.00s)
they dropped which is just kind of earth
[02:39] (159.92s)
shaking. So these are just in two days
[02:42] (162.24s)
they dropped those two items which
[02:44] (164.00s)
really changed the way that you can use
[02:45] (165.60s)
the product in substantial ways. All
[02:48] (168.00s)
right, sorry. Gotta move on. Another one
[02:50] (170.00s)
is screenshots. All right, if you take a
[02:52] (172.32s)
screenshot, this is a little utility
[02:53] (173.92s)
that has a screenshot. You can drag it
[02:55] (175.52s)
in. You'll see when I'm in cursor,
[02:57] (177.68s)
you'll get this hold shift to drop into
[02:59] (179.68s)
editor. When I drop it in, it'll just do
[03:01] (181.92s)
the whole uh path to the file itself. Or
[03:05] (185.28s)
if you hit control and V, that's how you
[03:08] (188.16s)
paste in images. I cannot tell you
[03:10] (190.72s)
enough, get a good system that you can
[03:13] (193.76s)
take quick screenshots that go directly
[03:15] (195.84s)
to your clipboard. command V or controlV
[03:18] (198.08s)
I'm in. It's heaven. So, you really need
[03:20] (200.16s)
to take that one on. All right, enough
[03:21] (201.52s)
for these little bits. Go check the
[03:23] (203.12s)
previous video if you want to see those.
[03:24] (204.88s)
Let's move on to the next. Okay, number
[03:26] (206.72s)
two is context. Context. Context, of
[03:29] (209.60s)
course, is everything. So, imagine
[03:31] (211.92s)
trying to solve a jigsaw puzzle while
[03:34] (214.16s)
people keep adding pieces from different
[03:36] (216.64s)
jigsaw boxes. That's kind of what you're
[03:38] (218.80s)
doing when you're letting your context
[03:40] (220.80s)
grow too big and that information keeps
[03:43] (223.52s)
going in while you're trying to solve
[03:45] (225.20s)
new parts of the problem. So, we're
[03:47] (227.04s)
going to work backwards here just for a
[03:48] (228.56s)
second so that I can show you something.
[03:50] (230.24s)
If you're using Claude Code, there is a
[03:52] (232.56s)
command to resume a conversation. When
[03:55] (235.76s)
you select this, it will give you the
[03:57] (237.44s)
different conversations that you've had.
[03:59] (239.20s)
So, if I open one up from 6 minutes ago,
[04:01] (241.68s)
that will load the previous conversation
[04:03] (243.60s)
into my context window. And now I have a
[04:06] (246.32s)
lot more presumably in this context
[04:09] (249.20s)
window. And really, you don't know what
[04:11] (251.84s)
you necessarily have in here. So if I
[04:13] (253.68s)
start asking for something new, I want a
[04:16] (256.16s)
new button added or something else, all
[04:18] (258.16s)
of the rest that's in this context is
[04:19] (259.92s)
actually going with it. And so you're
[04:21] (261.44s)
you're actually asking the LLM to be
[04:23] (263.92s)
able to see the difference between what
[04:25] (265.76s)
you're asking for. It is going to get
[04:27] (267.92s)
confused and be less performant. So what
[04:29] (269.92s)
we want to do is always clear our
[04:32] (272.00s)
context. It's super easy. It's just a
[04:34] (274.00s)
slash command that you can use clear. So
[04:36] (276.00s)
this is the other half. First you can
[04:37] (277.44s)
resume at any time if you fall out of
[04:39] (279.44s)
claw. Don't feel like you've lost your
[04:41] (281.04s)
conversation. Just use resume. That is a
[04:43] (283.36s)
tip in and of itself. The other one is
[04:45] (285.04s)
clear. Always clear. Whenever you get to
[04:46] (286.96s)
a point that you feel like, oh, okay,
[04:48] (288.64s)
we're at a spot. I'm about to start
[04:50] (290.32s)
talking about something new. You want to
[04:52] (292.16s)
clear. You want your context to be
[04:53] (293.84s)
smaller. It needs to be tighter. It's
[04:55] (295.84s)
very important that you get it quite
[04:58] (298.00s)
tight. All right. On top of this, if you
[05:00] (300.56s)
can't clear and you're a little worried
[05:02] (302.08s)
about it and you think, I do want to
[05:04] (304.24s)
move on to talking about the button, but
[05:06] (306.72s)
some of the concerns that we have in
[05:08] (308.64s)
this context are important, even though
[05:10] (310.72s)
we've done a whole bunch of work working
[05:12] (312.32s)
on many other things. Toward the end
[05:14] (314.32s)
here, we started talking about the
[05:15] (315.44s)
button and and this context is so
[05:17] (317.36s)
filled, I don't want to just lose it.
[05:18] (318.72s)
It's hard for me to move on. You can ask
[05:20] (320.72s)
the model, create a prompt for me to
[05:22] (322.80s)
move on. I call this context handoff. So
[05:25] (325.04s)
you can ask it about the concerns that
[05:27] (327.28s)
you're dealing with at that moment and
[05:28] (328.80s)
say, "Write a detailed prompt with the
[05:30] (330.64s)
nuances that are dealing with the button
[05:32] (332.64s)
and the theming and the styling that
[05:34] (334.32s)
we've recently been talking about so
[05:35] (335.92s)
that I can start another conversation
[05:37] (337.36s)
with you." That will still simplify
[05:39] (339.04s)
things. You don't always have to do
[05:40] (340.40s)
this. Don't worry too much about this,
[05:42] (342.32s)
but the more frequently that you do
[05:44] (344.32s)
this, the happier you'll be. It will
[05:46] (346.16s)
really perform better in a lot of cases.
[05:48] (348.16s)
All right. And the last one, and this
[05:49] (349.68s)
one is, I think, pretty obvious to a lot
[05:51] (351.84s)
of people, so I'll go through it pretty
[05:53] (353.12s)
quickly. There's this clawed MD file.
[05:55] (355.12s)
Now, they have a slash command that will
[05:56] (356.72s)
get you there. It's init. If you use the
[05:58] (358.72s)
init command, what it's going to do is
[06:00] (360.40s)
look through your entire application or
[06:02] (362.32s)
what project you're in and try to
[06:04] (364.32s)
understand all of the concerns and write
[06:06] (366.48s)
things down in this cloud MD file. Okay,
[06:08] (368.72s)
not a bad idea. However, it's going to
[06:10] (370.96s)
get humongous. What is this cloud MD
[06:13] (373.12s)
file doing? Well, once I hit this clear,
[06:15] (375.84s)
so this is another command that resets
[06:18] (378.24s)
my context history that we're talking
[06:19] (379.84s)
about. This is like hitting new window
[06:21] (381.44s)
in some other tool. So, or new chat. So,
[06:23] (383.92s)
here we are in a new chat, no context.
[06:25] (385.92s)
This Claude MD file, everything in here
[06:28] (388.72s)
actually flopped down into this context.
[06:31] (391.60s)
So, it might say no context, but this is
[06:34] (394.00s)
the the memory file essentially for
[06:36] (396.24s)
Claude. And the way that it works is
[06:38] (398.00s)
whenever you start a new chat, if you
[06:39] (399.92s)
will, that goes and sneaks in there as a
[06:42] (402.24s)
background. So it kind of wants to carry
[06:44] (404.32s)
the memory along so that every
[06:46] (406.48s)
conversation you have everything all
[06:48] (408.48s)
LLMs understand what's going on inside
[06:50] (410.40s)
of this project and some of the concerns
[06:52] (412.00s)
you have. Okay. So two things about
[06:54] (414.00s)
that. This one is enormous. I would say
[06:56] (416.24s)
this is a miss. This is my mistake. I
[06:58] (418.40s)
probably did a slash andit early on. And
[07:00] (420.72s)
this is what they look like when you do
[07:02] (422.16s)
slash andit. It's just too much stuff.
[07:04] (424.32s)
I'm talking about all the different ways
[07:06] (426.16s)
start scripts and end scripts and build
[07:08] (428.00s)
scripts and everything else. I don't
[07:09] (429.36s)
need that for almost all of the things
[07:11] (431.12s)
that I do. Right? So, this does not need
[07:13] (433.44s)
to be in this memory file. I need to
[07:15] (435.36s)
come in here and slim this down quite a
[07:17] (437.44s)
bit. This is the place that you want to
[07:19] (439.60s)
be able to tell Claude, hey, remember do
[07:22] (442.32s)
this this way or stop doing this or my
[07:25] (445.04s)
gosh, don't forget to write tests or my
[07:27] (447.44s)
you always have to write it in
[07:28] (448.80s)
Typescript, not in JavaScript. This is
[07:30] (450.64s)
your file to do that kind of thing.
[07:32] (452.64s)
There is a way inside of Cloud Code that
[07:34] (454.64s)
if you use a hash, you'll see it says
[07:36] (456.32s)
add to memory. This will actually just
[07:38] (458.32s)
write a line to that file. But you can
[07:40] (460.64s)
just go directly into this file. It's
[07:42] (462.40s)
one of the reasons that I use a file
[07:44] (464.00s)
editor with this like cursor or
[07:45] (465.92s)
something else. I can just come in here,
[07:47] (467.60s)
write another line, and say, "Oh, don't
[07:49] (469.44s)
forget to XYZ or I prefer capitalization
[07:53] (473.28s)
XYZ." So, this is a really important
[07:55] (475.52s)
file. It's really critical to your value
[07:58] (478.32s)
of your project going forward. Take a
[08:00] (480.40s)
look at it, learn about it. But I've got
[08:02] (482.32s)
to move on. Okay. Number three is about
[08:05] (485.12s)
voice. This is the voice revolution. So,
[08:08] (488.32s)
if you haven't seen this one or you
[08:10] (490.16s)
haven't experienced this one yet
[08:11] (491.36s)
yourself or you're reticent to it or
[08:13] (493.44s)
your environment doesn't quite
[08:14] (494.72s)
facilitate it, I highly advise you try
[08:17] (497.04s)
to lean into it. The hard truth is if
[08:19] (499.36s)
you're still typing, you're almost
[08:21] (501.20s)
certainly not giving enough context in
[08:23] (503.76s)
many cases. If you're typing and you're
[08:26] (506.24s)
tired of typing when you put things in,
[08:28] (508.64s)
you might be reaching the right amount
[08:30] (510.16s)
of context. So, it's not a hard and fast
[08:32] (512.32s)
rule, but voice is a bandwidth
[08:34] (514.80s)
multiplier. That's all it is. It's not
[08:36] (516.80s)
that you're going to be giving better
[08:38] (518.40s)
information as voice, but you're going
[08:40] (520.48s)
to be able to put so much more
[08:42] (522.08s)
consideration and concerns onto the
[08:44] (524.32s)
model of what you're trying to do that
[08:46] (526.24s)
you absolutely will get better results
[08:48] (528.64s)
honestly. So, the interesting thing here
[08:50] (530.72s)
is people that are very advanced and
[08:52] (532.64s)
people that are beginners both have
[08:54] (534.80s)
problems with context. We just talked
[08:56] (536.96s)
about context, of course. Context is
[08:58] (538.88s)
everything. How much you put in is
[09:01] (541.20s)
really representative of what you're
[09:02] (542.88s)
going to get out. And people that know a
[09:04] (544.88s)
lot tend to put in what they know in a
[09:08] (548.08s)
very opinionated way without knowing
[09:10] (550.00s)
that that's what they're doing. I'm
[09:11] (551.36s)
looking at you senior devs. You guys are
[09:13] (553.52s)
putting in I want you to do this, build
[09:15] (555.12s)
it this way. Here's the model. This is
[09:16] (556.48s)
what it should look like. Here's all the
[09:17] (557.68s)
attributes that that's fine. If you
[09:19] (559.36s)
really need that, if that's an actual
[09:21] (561.28s)
hard requirement rather than an opinion,
[09:23] (563.60s)
then absolutely put it in. So, I'm not
[09:25] (565.44s)
saying it's a bad idea. However, I think
[09:27] (567.76s)
very often it's because that's the place
[09:30] (570.48s)
our minds go very easily and very
[09:32] (572.80s)
quickly when we start thinking about the
[09:34] (574.48s)
construction, the architecture of a
[09:36] (576.08s)
problem. If you're brand new, you're
[09:37] (577.92s)
probably saying, "I have no idea what to
[09:40] (580.24s)
ask for. I want a dog house clock. Go."
[09:43] (583.36s)
Well, that's not enough. You probably
[09:45] (585.04s)
actually have more ideas of what you're
[09:46] (586.88s)
asking for. You don't have to be
[09:48] (588.32s)
technical. It's not that. It's well, I
[09:50] (590.72s)
want a dog house clock. Where do you
[09:52] (592.00s)
want it? You want it as a watch
[09:53] (593.68s)
application or phone application? You
[09:55] (595.20s)
want it to run on the browser only. You
[09:56] (596.80s)
want it to be huge or small. Does it
[09:58] (598.80s)
look like Snoopy's doghouse or some
[10:00] (600.64s)
other dog house? Is it the front of the
[10:02] (602.08s)
doghouse? All of these things would come
[10:03] (603.76s)
out if you were talking about it for a
[10:05] (605.60s)
second, but they will not come out if
[10:07] (607.28s)
you're typing. Your voice is your key.
[10:10] (610.16s)
All right, number four. I'm going to
[10:11] (611.52s)
have to try to push through this one. I
[10:13] (613.04s)
apologize. Here is my promise to you. I
[10:15] (615.60s)
will build another video that talks
[10:18] (618.08s)
about building PRDs. They are really a
[10:21] (621.12s)
big unlock for more advanced uses of
[10:24] (624.56s)
something like cloud co code or an
[10:26] (626.32s)
agentic building system if you build
[10:28] (628.64s)
better PRDs which is basically a product
[10:31] (631.92s)
requirements document. It's just kind of
[10:33] (633.52s)
what you'd like to see in a product.
[10:35] (635.52s)
It's not all the technical stuff. It's
[10:37] (637.52s)
really all the idea of what the
[10:39] (639.84s)
application is, how it works, where it
[10:42] (642.08s)
should run, how often it should reboot.
[10:44] (644.80s)
Those kinds of things are all inside of
[10:46] (646.32s)
a PRD. the better PRD, the better
[10:48] (648.88s)
planning document, hear it that way, the
[10:51] (651.04s)
better results of your initial build.
[10:52] (652.96s)
And if you plan frequently for the
[10:55] (655.20s)
different things that you're going to
[10:56] (656.56s)
build, you'll be better off. So, it's
[10:58] (658.72s)
it's pretty particular on how you might
[11:00] (660.80s)
be able to get to a better PR. And there
[11:02] (662.56s)
is no real prescription to it. So, I
[11:04] (664.88s)
think another video actually works here.
[11:07] (667.12s)
Let me know in the comments and
[11:08] (668.40s)
subscribe if you want to see that
[11:09] (669.76s)
because I'm really hopeful that that's a
[11:11] (671.44s)
video that I'll put together. But I will
[11:13] (673.36s)
push into this planning section first
[11:15] (675.52s)
pretending that I just told you really
[11:17] (677.84s)
critical is being able to put together
[11:20] (680.32s)
really solid PRDs. I know that's a
[11:22] (682.80s)
promise of a future video. I apologize,
[11:24] (684.96s)
but really what I'm saying is work back
[11:27] (687.52s)
and forth with some model. You can do it
[11:29] (689.60s)
here in Claude Code or you can do it
[11:31] (691.68s)
somewhere else. I very frequently will
[11:33] (693.60s)
do it somewhere else and you can bring
[11:35] (695.20s)
the plan in and have Claude Code build
[11:37] (697.20s)
it there. So, one of the neat things
[11:39] (699.44s)
about Claude Code is it's part of your
[11:42] (702.08s)
subscription with Anthropic. If you have
[11:43] (703.68s)
a $20 subscription, you have enough to
[11:46] (706.16s)
really use Claude Code pretty
[11:48] (708.08s)
meaningfully. Once you start pushing it,
[11:49] (709.84s)
you'll hit your rate limiting a little
[11:51] (711.28s)
bit more frequently inside of those
[11:52] (712.72s)
4hour windows. But if you're starting to
[11:55] (715.60s)
drift into that spot, one of the things
[11:57] (717.60s)
that you can offload is planning. Just
[11:59] (719.52s)
go back to the Claude website or even
[12:02] (722.40s)
OpenAI Chatt anywhere else and say, "I
[12:04] (724.96s)
need a good plan." Now, you'd like to
[12:06] (726.64s)
use a good model to do this, and you
[12:08] (728.80s)
would like to do this iteratively. So,
[12:10] (730.56s)
you're talking through it, reading what
[12:12] (732.32s)
it's giving you back and forth to make
[12:14] (734.00s)
sure it's a plan that you like. And
[12:15] (735.60s)
again, the plan should represent what
[12:17] (737.76s)
you want from the product, not the
[12:19] (739.92s)
technical how. It's not about the how,
[12:22] (742.16s)
it's all the other stuff. If you don't
[12:24] (744.32s)
give all that other stuff, no matter how
[12:26] (746.32s)
good the technical solution is, it's not
[12:28] (748.64s)
going to match what you want. I know
[12:30] (750.00s)
this all sounds trit, but it really is a
[12:32] (752.80s)
very major feature inside of building
[12:35] (755.68s)
correctly with these versus I threw in
[12:38] (758.00s)
an idea. I just wanted a website that
[12:39] (759.76s)
did X and okay, it was good. Then I had
[12:42] (762.00s)
to go back and forth with it a thousand
[12:44] (764.00s)
more times to get what I really wanted.
[12:45] (765.84s)
You don't have to do that anymore. These
[12:47] (767.20s)
models are really sophisticated and
[12:48] (768.80s)
these tools like Claude Code are
[12:50] (770.64s)
massively sophisticated. So, I would I
[12:53] (773.28s)
would definitely advise using a
[12:54] (774.88s)
different system if you want if you're
[12:56] (776.72s)
on that $20 model. But if you're not
[12:58] (778.80s)
hitting anything of your rate limit and
[13:00] (780.40s)
you can do what I have here, which is I
[13:02] (782.08s)
just went into planning mode and asked
[13:03] (783.84s)
for it to plan something. So I can say
[13:06] (786.16s)
no, keep planning. It has this plan
[13:08] (788.80s)
which is a pretty reasonable PRD. You
[13:10] (790.88s)
can see that it doesn't have a lot of
[13:12] (792.08s)
technical stuff. It's much more the this
[13:14] (794.48s)
is how this will work. This is what we
[13:16] (796.88s)
might add. This is where it might be.
[13:19] (799.28s)
And I might here be able to say save
[13:21] (801.44s)
this as a document in the plans folder.
[13:24] (804.48s)
And that's it. So now it's going to take
[13:26] (806.40s)
this and put a new document in our plans
[13:28] (808.88s)
folder that we can work from. And so
[13:30] (810.96s)
this is something that I do pretty
[13:32] (812.32s)
frequently is the plans that I'm
[13:34] (814.48s)
generating. Let's see if we can actually
[13:36] (816.08s)
get it to show up. Well, let's hope it's
[13:37] (817.84s)
somewhere. I have to move quickly. I'm
[13:40] (820.48s)
sorry. So basically the plans that we're
[13:42] (822.56s)
generating here, um, you don't have to
[13:45] (825.12s)
just leave within memory while it's
[13:46] (826.96s)
building. You can say write a file,
[13:49] (829.04s)
write a document. I very often will have
[13:51] (831.04s)
a docs folder. all the plans that I'm
[13:52] (832.80s)
working through will be listed up here
[13:54] (834.80s)
so that I can go back later and kind of
[13:56] (836.64s)
see what was planned, how it was going
[13:58] (838.48s)
off the rails, or if I had to stop
[13:59] (839.92s)
halfway through, I can just say, "Hey,
[14:01] (841.76s)
go take a look at that plan. Pick up
[14:03] (843.20s)
wherever you were and move on." And at
[14:05] (845.12s)
least I don't always have to worry about
[14:07] (847.36s)
the resume feature and how do I get back
[14:09] (849.52s)
to the context? All right, in any case,
[14:11] (851.60s)
this is planning. Planning is super
[14:13] (853.68s)
important. I just want you to hear that.
[14:15] (855.36s)
And there are ways to get better at it
[14:17] (857.12s)
without having to know all of the
[14:18] (858.64s)
technical gobbledygook that an engineer
[14:21] (861.12s)
would know. You can still do a lot of
[14:23] (863.60s)
the same lifting, but your plan has to
[14:25] (865.68s)
be clean. You really have to say, "I
[14:27] (867.44s)
want it to have two buttons, not four
[14:29] (869.04s)
buttons, or don't just make it any
[14:30] (870.48s)
color. Here's the color schemes that I
[14:32] (872.00s)
want." All right. Sorry. Sorry. Okay.
[14:33] (873.84s)
Moving on to custom commands. But let me
[14:36] (876.32s)
clarify one thing. This was Claude Code
[14:38] (878.32s)
being great. By the way, I am in
[14:40] (880.24s)
planning mode. I asked it to save a file
[14:42] (882.80s)
and it came back and said, "Hey, I know
[14:44] (884.72s)
you want me to save something there. I'm
[14:46] (886.40s)
in planning mode. If you want to leave
[14:47] (887.92s)
planning mode and ask me to do that
[14:49] (889.20s)
again, I will." That's pretty cool.
[14:50] (890.88s)
Great message. It also didn't escape the
[14:53] (893.60s)
rules of planning mode. I just have to
[14:55] (895.52s)
give it props for that. All right. I
[14:57] (897.12s)
want to talk about custom commands and
[14:58] (898.64s)
agents and and some other things, but
[15:01] (901.36s)
essentially these things that you'll
[15:02] (902.64s)
find up in yourcloud file. And these are
[15:05] (905.28s)
really meaningful. The idea of kind of
[15:07] (907.60s)
building your own tool set is critically
[15:10] (910.56s)
important and really to me fundamental
[15:12] (912.72s)
to making Claude code feel like not only
[15:16] (916.00s)
my own meaningful per project. Like I've
[15:18] (918.80s)
said in the past, I have tons of
[15:20] (920.40s)
projects. I create a lot of different
[15:22] (922.00s)
projects and having specific commands
[15:24] (924.48s)
for this project. For example, the build
[15:26] (926.48s)
the commands that I have here, I've
[15:27] (927.84s)
written a build command. So I can just
[15:29] (929.60s)
do /build. And in this project, the way
[15:32] (932.08s)
the project is built because it's an
[15:33] (933.76s)
Electron project is very different from
[15:35] (935.92s)
other projects. So I have a little bit
[15:37] (937.76s)
inside of this build MD thing here. It's
[15:40] (940.08s)
very simple. It's basically the command
[15:42] (942.32s)
that needs to be run is this particular
[15:44] (944.88s)
prod version of my build command.
[15:47] (947.36s)
Whatever. Don't have to worry about it.
[15:48] (948.72s)
And the nice thing is the next time I
[15:50] (950.96s)
come in here or the next person that
[15:52] (952.40s)
happens to be in here, they don't have
[15:53] (953.76s)
to know it either. they can just look
[15:55] (955.20s)
for the slash commands that we have and
[15:57] (957.20s)
see, oh, here's one of the personal
[15:58] (958.96s)
slash commands that we have, I can use
[16:00] (960.88s)
that. So, really, I would really advise
[16:03] (963.52s)
anything that you do kind of frequently
[16:05] (965.44s)
or semi-frequently or you keep
[16:08] (968.00s)
forgetting how to do, just write a
[16:10] (970.40s)
simple MD file. You can come up here and
[16:12] (972.56s)
an MD file, for everybody that doesn't
[16:14] (974.32s)
know, is just basically a text file.
[16:15] (975.92s)
Feel free to just write a text file. In
[16:17] (977.76s)
fact, my build command one has no
[16:19] (979.36s)
markdown. Well, has a tiny bit of
[16:21] (981.12s)
markdown in it, but very little markdown
[16:22] (982.88s)
in it. and it doesn't matter because
[16:24] (984.56s)
intelligence is reading this and it can
[16:26] (986.32s)
figure it out. These kinds of slash
[16:28] (988.00s)
commands from cloud code are really
[16:30] (990.16s)
really valuable and end up being really
[16:32] (992.40s)
meaningful across the board. So I have
[16:34] (994.48s)
others that I've shared in previous
[16:36] (996.96s)
videos. I have an iterator that can do
[16:39] (999.36s)
in number of designs at once. I have
[16:41] (1001.68s)
several git commands that I've put
[16:43] (1003.44s)
together that are really useful. So for
[16:45] (1005.84s)
example here I have some changes. If we
[16:48] (1008.40s)
look here we have these changes here. I
[16:50] (1010.96s)
can just say, oh, I'll do my gsave
[16:53] (1013.68s)
command. And that's going to do
[16:55] (1015.44s)
something that I've written previously.
[16:57] (1017.20s)
That's a global. So, you can put things
[16:58] (1018.88s)
in your home directory. And I know this
[17:01] (1021.04s)
might be getting too far once again
[17:02] (1022.72s)
previous video. Sorry about that. That
[17:04] (1024.80s)
is in your home directory. So, your /
[17:07] (1027.60s)
username directory in the Mac world. And
[17:09] (1029.76s)
then there's a cloud file inside of
[17:11] (1031.60s)
there that looks just like this claude
[17:13] (1033.36s)
file. So, it's nothing special. You just
[17:14] (1034.80s)
need to open it up. And then you can
[17:16] (1036.16s)
edit those as well there. And I've have
[17:18] (1038.40s)
that one has a commands folder in it.
[17:20] (1040.32s)
And this this get gsave item that we're
[17:23] (1043.12s)
running right now is inside of there.
[17:25] (1045.28s)
And this gsave one is pretty complicated
[17:27] (1047.60s)
actually. If we looked at it, it would
[17:29] (1049.12s)
say, "Oh, depend go find out, run some
[17:31] (1051.28s)
diffs, figure out what kind of changes
[17:32] (1052.80s)
there are. Depending upon which kind of
[17:35] (1055.20s)
change it is, use this icon versus that
[17:37] (1057.28s)
icon to denote what kind of changes blah
[17:39] (1059.36s)
blah blah." It's a lot of stuff in it
[17:40] (1060.56s)
that I don't want to have to obviously
[17:41] (1061.92s)
type every time and I would never
[17:43] (1063.84s)
remember to run every single time. But
[17:46] (1066.00s)
now all of my commits will look similar
[17:48] (1068.08s)
to one another because they're using one
[17:49] (1069.92s)
global command. All right. So that's
[17:51] (1071.60s)
build command. Dang it. It's not build
[17:53] (1073.60s)
commands. Those are slash commands. They
[17:55] (1075.84s)
don't all have to be build. Don't make
[17:57] (1077.52s)
all your slash commands build commands.
[17:59] (1079.20s)
Sorry. Okay. So that one finished. We
[18:01] (1081.28s)
can go quickly take a look. This is what
[18:03] (1083.28s)
the different um commit looks like. So
[18:05] (1085.68s)
this is the commit message built out the
[18:07] (1087.44s)
way that I've decided I want my commit
[18:09] (1089.76s)
me messages to look. Very nice as far as
[18:11] (1091.92s)
I'm concerned. And if you recall, what
[18:13] (1093.92s)
do we do? We just learned this. Hey,
[18:16] (1096.24s)
since I've just checked everything in,
[18:17] (1097.76s)
I'm at, you know, one of these uh points
[18:19] (1099.84s)
that are save points, I may as well
[18:21] (1101.76s)
clear my context. I'm at a good place.
[18:23] (1103.92s)
Do that if you can. It really will make
[18:25] (1105.68s)
a difference. All right, what's next?
[18:27] (1107.44s)
This one's a little upside down. You'll
[18:28] (1108.88s)
have to forgive me. Number six,
[18:30] (1110.40s)
checkpointing. That thing we just talked
[18:32] (1112.24s)
about that I told you that I told you
[18:33] (1113.68s)
about previously, but I didn't. So, now
[18:35] (1115.36s)
I'm telling you about it. Pretend like I
[18:36] (1116.72s)
told you about it before I told you that
[18:38] (1118.08s)
last thing. It doesn't really matter.
[18:39] (1119.68s)
Here we go. Checkpointing. Something
[18:41] (1121.20s)
that's missing in clawed code. You can
[18:43] (1123.04s)
find this in Windsurf and VSC and uh and
[18:46] (1126.72s)
other cursor products. They will
[18:48] (1128.80s)
checkpoint whenever you make a big
[18:50] (1130.24s)
change. Whenever you start a big
[18:51] (1131.52s)
conversation or there's a new change
[18:53] (1133.04s)
that's begun, they kind of mark all the
[18:55] (1135.04s)
files and say, "Okay, everything looks
[18:56] (1136.40s)
like this right now. Come back and click
[18:58] (1138.08s)
this button if you want to pull
[18:59] (1139.28s)
everything back to this point." Cloud
[19:00] (1140.80s)
code does not have something like that.
[19:02] (1142.80s)
But it is super easy to do this
[19:04] (1144.88s)
yourself. So, I'm going to introduce you
[19:06] (1146.56s)
to something. Some of y'all are going to
[19:08] (1148.24s)
yawn. I apologize. This one I'll go
[19:10] (1150.32s)
pretty quickly with Git. I also think
[19:12] (1152.64s)
that I want to create a video around
[19:14] (1154.48s)
some concepts on how to use git not just
[19:17] (1157.84s)
as a code kind of management version
[19:20] (1160.80s)
control system that I'm going to
[19:22] (1162.24s)
describe here but also some git agents
[19:24] (1164.80s)
because cloud code works with your git
[19:26] (1166.96s)
repository and can offline do some work
[19:29] (1169.36s)
for you. There's some really interesting
[19:30] (1170.56s)
things that I want to investigate. So
[19:32] (1172.16s)
subscribe once again I'm sorry if you
[19:34] (1174.24s)
want to see me work through git
[19:36] (1176.40s)
solutions with uh cloud code as well.
[19:39] (1179.36s)
One of the things that I will cover is
[19:41] (1181.12s)
having a Git repository. And what does
[19:43] (1183.36s)
that really mean? So, there's GitHub.
[19:45] (1185.20s)
And a lot of you that are that really
[19:46] (1186.72s)
don't know either of these terms
[19:48] (1188.40s)
certainly know the word GitHub. More
[19:50] (1190.00s)
than likely, Git is kind of underlying
[19:53] (1193.36s)
system that manages version controlled
[19:55] (1195.84s)
files. Well, boy, is that a lot. That's
[19:57] (1197.68s)
just basically saying it checkpoints
[19:59] (1199.44s)
everything and says, "All right, where
[20:00] (1200.64s)
everything sits right now, I'm going to
[20:02] (1202.40s)
go save all these files, checkpoint
[20:04] (1204.08s)
everything. This is where it is. any
[20:05] (1205.76s)
changes that happen from here I can come
[20:08] (1208.08s)
back to this moment once they commit
[20:10] (1210.16s)
again that's a special word in get once
[20:11] (1211.76s)
they commit again it's another
[20:13] (1213.04s)
checkpoint so you'll have you can come
[20:14] (1214.64s)
back to the first point or the second
[20:16] (1216.48s)
point all the stuff that happened in
[20:17] (1217.76s)
between you can't see but you can see
[20:19] (1219.36s)
these checkpoints all right think of it
[20:20] (1220.64s)
as a video game you walk up on you know
[20:22] (1222.88s)
the campfire basically and you see that
[20:25] (1225.20s)
lovely term that comes up across the top
[20:27] (1227.20s)
that says saving and you think oh good
[20:29] (1229.28s)
when the bear eats me next time I can at
[20:30] (1230.88s)
least start here that's this is for when
[20:32] (1232.96s)
the bear eats you that's all and the
[20:34] (1234.56s)
bear does eat you. I'm sorry to keep
[20:36] (1236.80s)
this this analogy going. Uh it does eat
[20:39] (1239.36s)
you with agentic coding, right? Every
[20:41] (1241.84s)
now and these thing every now and then
[20:43] (1243.28s)
these things will kind of go off the
[20:44] (1244.88s)
rails just a little bit, kind of have
[20:46] (1246.40s)
their own opinion, kind of push things
[20:48] (1248.00s)
too far in a certain direction and you
[20:50] (1250.00s)
want to commit frequently enough or
[20:52] (1252.24s)
checkpoint frequently enough that you
[20:54] (1254.00s)
can jump back to something recent. And
[20:56] (1256.32s)
that's why I have this slash command
[20:57] (1257.92s)
that we just used here. That is my
[21:00] (1260.40s)
gsave. And all Gave is doing is running
[21:02] (1262.80s)
a git commit basically with that whole
[21:05] (1265.20s)
thing that we just talked about. And so
[21:06] (1266.80s)
if you can do something like that, build
[21:08] (1268.88s)
your own slash command to be able to do
[21:11] (1271.44s)
commit or git commit or whatever else,
[21:13] (1273.76s)
that's fine. But you know what you can
[21:15] (1275.28s)
also do is just ask claude code here,
[21:17] (1277.52s)
can you commit? If you just say that, it
[21:20] (1280.16s)
will go forward. If you don't have a git
[21:22] (1282.00s)
repository, it'll determine that. It'll
[21:24] (1284.16s)
come back and say, well, this doesn't
[21:25] (1285.52s)
look like it's yet in a git repository.
[21:27] (1287.76s)
I was saying there's GitHub and Git.
[21:29] (1289.76s)
They're really separate. Don't worry
[21:31] (1291.12s)
about the GitHub stuff yet if you're
[21:32] (1292.72s)
brand new to this and this all sounds
[21:34] (1294.24s)
fancy on your system itself. You can
[21:36] (1296.80s)
save these checkpoints and that's where
[21:38] (1298.48s)
you want to do it. You want to just have
[21:39] (1299.84s)
as many of these checkpoints as you can
[21:41] (1301.36s)
locally. In fact, you can see this whole
[21:43] (1303.20s)
graph here. These are all of the changes
[21:45] (1305.12s)
that I have in this project that I can
[21:47] (1307.20s)
roll back to. Just tell cloud code, hey,
[21:49] (1309.76s)
I want this in git. And then when once
[21:51] (1311.52s)
it is every time you want to to save
[21:53] (1313.76s)
stuff, you can say, can you commit?
[21:55] (1315.68s)
That's it. All right, we've hit the last
[21:57] (1317.36s)
one. Number seven, going beyond code.
[21:59] (1319.68s)
All right. I will say once you see this,
[22:01] (1321.60s)
you can't unsee it. This changes
[22:03] (1323.84s)
everything. It does take a little bit of
[22:05] (1325.44s)
a leap. You'll hear me say this and if
[22:07] (1327.52s)
you're really not ready for it, you'll
[22:08] (1328.72s)
go, "Okay, I got it. Whatever.
[22:10] (1330.64s)
Confusing. Can't even imagine what
[22:12] (1332.32s)
you're talking about." But the moment
[22:13] (1333.76s)
that it clicks and you go, "Oh, I get
[22:16] (1336.00s)
you." it will change everything because
[22:17] (1337.92s)
I think what's happening in claude code
[22:20] (1340.00s)
and other agentic systems like this
[22:22] (1342.40s)
these agentic editors that we're working
[22:24] (1344.24s)
in now even though it's called claude
[22:26] (1346.48s)
code I think we're seeing something that
[22:28] (1348.80s)
would be akin to what I think is vibe
[22:31] (1351.36s)
editing so it doesn't have anything to
[22:33] (1353.04s)
do with code I've brought you into a
[22:34] (1354.64s)
different project here this is my video
[22:36] (1356.88s)
notes project and this is where I keep
[22:39] (1359.20s)
the different notes for the videos that
[22:41] (1361.36s)
I create I do a lot of what I call
[22:43] (1363.60s)
meetings or walks I walk around really
[22:46] (1366.16s)
frankly right here in this room and talk
[22:48] (1368.16s)
right into this microphone just out loud
[22:50] (1370.88s)
about what I think should be in a video
[22:53] (1373.60s)
and let that go usually for an hour or
[22:55] (1375.92s)
so and that's what you'll find in these
[22:57] (1377.76s)
different transcripts is these very long
[23:00] (1380.00s)
walk notes that I have and those walk
[23:02] (1382.56s)
notes I then come back to claude code
[23:05] (1385.12s)
and say oh I need you to take a look at
[23:07] (1387.36s)
those notes and create an outline from
[23:09] (1389.44s)
those notes and then we will start
[23:10] (1390.96s)
working forward and so I have created
[23:13] (1393.52s)
some things up here in claw pod that are
[23:16] (1396.24s)
agents. Agents just released. I just
[23:18] (1398.40s)
released a video about them. I think
[23:20] (1400.08s)
they're a gamecher. Basically, you can
[23:21] (1401.92s)
think of them as slash commands for now.
[23:23] (1403.84s)
If you don't want to try to figure out
[23:25] (1405.12s)
what I mean by agents, they're very cool
[23:27] (1407.84s)
and they're very worth mentioning here,
[23:29] (1409.52s)
but I haven't been using them for a
[23:30] (1410.88s)
month, so I don't want to talk about
[23:32] (1412.16s)
them here. But if if I use this video
[23:35] (1415.12s)
outliner agent, you can see that it's
[23:37] (1417.12s)
just a big prompt on here that says,
[23:38] (1418.56s)
"You're an expert video content
[23:40] (1420.16s)
strategist and a narrative architect
[23:42] (1422.08s)
specializing in crafting compelling
[23:43] (1423.76s)
outlines, etc., etc., etc., etc., and I
[23:46] (1426.00s)
have a format that I ask for it to come
[23:48] (1428.16s)
out in, and I say, "Here's the format
[23:50] (1430.00s)
that I want you to deliver my notes in."
[23:52] (1432.32s)
And then we go back and forth. So, it
[23:54] (1434.32s)
delivers one of these things. And I'll
[23:55] (1435.68s)
even show you at the bottom of this
[23:56] (1436.96s)
prompt, and I did share this in the
[23:58] (1438.88s)
previous video, so sorry if I'm
[24:00] (1440.32s)
doubletapping, that I say when you save
[24:02] (1442.72s)
the file, I want the file in a special
[24:05] (1445.12s)
format. take the year, month, day
[24:07] (1447.52s)
because all of my notes for these videos
[24:09] (1449.60s)
are under a year, month, day format, and
[24:11] (1451.76s)
then the title of what I presume the
[24:13] (1453.92s)
video might be or just some uh
[24:15] (1455.84s)
nomenclature that defines the video for
[24:18] (1458.00s)
me. I want those to persist. So, that's
[24:20] (1460.32s)
that's one of them. And the video name
[24:22] (1462.24s)
is the other one. And I'm saying I want
[24:24] (1464.48s)
you to create an outline file with those
[24:26] (1466.72s)
two constants, but what's really neat is
[24:29] (1469.60s)
a version number here. And I'm telling
[24:31] (1471.60s)
it every time I want you to update that
[24:33] (1473.60s)
version number. And so if we look into
[24:35] (1475.28s)
the reports as it creates these
[24:37] (1477.28s)
different reports, it will create the
[24:39] (1479.12s)
version 1 3 4 5 6 7 8 9. So as I make
[24:43] (1483.60s)
edits to it and say, "Oh, no. I don't
[24:45] (1485.76s)
think that's quite right." It will work
[24:47] (1487.84s)
back and forth, make some changes that
[24:49] (1489.52s)
I've asked for, and then write another
[24:51] (1491.20s)
version of the same file essentially.
[24:53] (1493.04s)
And if we go into this, this is very
[24:55] (1495.12s)
similar. In fact, it happens to be this
[24:56] (1496.96s)
one that we are working from. And I can
[24:59] (1499.36s)
even show you where we are in our notes.
[25:02] (1502.32s)
come all the way down to let's see where
[25:05] (1505.04s)
are we beyond code it's one of the
[25:07] (1507.20s)
things we talked about right so we are
[25:09] (1509.20s)
in the vibe working revolution if you
[25:11] (1511.92s)
will but what I'm doing here is working
[25:14] (1514.48s)
with just notes these are just text
[25:17] (1517.04s)
files markdown files and I'm using
[25:19] (1519.12s)
claude code to do it and there's
[25:20] (1520.72s)
something really elegant about having an
[25:23] (1523.04s)
LLM at your fingertips to change your
[25:25] (1525.44s)
own environment we've been stuck in that
[25:27] (1527.44s)
chat interface web-based system for so
[25:29] (1529.84s)
long that we forgot that all of these
[25:32] (1532.00s)
tools could do anything if we gave them
[25:34] (1534.40s)
a little bit of capability. If we just
[25:36] (1536.64s)
allowed them some kind of rights and
[25:38] (1538.80s)
privileges to our files and our systems
[25:41] (1541.20s)
and we will see more and more of this. I
[25:43] (1543.20s)
am not saying Claude Code solved this,
[25:45] (1545.20s)
invented it, and it's the answer. I'm
[25:47] (1547.36s)
just saying this hints at a future I can
[25:50] (1550.72s)
very clearly see and we will be doing
[25:53] (1553.36s)
this for literally everything soon. In
[25:56] (1556.72s)
any case, I think we're in the middle of
[25:58] (1558.88s)
something really brand new and Anthropic
[26:01] (1561.52s)
is even, as I understand it, offering
[26:03] (1563.92s)
Claude code. A lot of the different
[26:05] (1565.44s)
people in their in their company are
[26:07] (1567.92s)
using claude code for their own uses
[26:10] (1570.00s)
that are not code related. So, not just
[26:12] (1572.16s)
the engineering teams, but other teams
[26:13] (1573.92s)
are also using it uh for other purposes.
[26:16] (1576.16s)
And I think that's a good example of
[26:18] (1578.72s)
look, this tool can do a lot for you.
[26:20] (1580.80s)
you want it to write uh your Instagram
[26:22] (1582.80s)
posts or you want it to go and read the
[26:25] (1585.36s)
URL from the web page that you're trying
[26:27] (1587.12s)
to summarize and turn into a video. This
[26:29] (1589.76s)
can do it right. It's an agentic system
[26:31] (1591.52s)
that can reach out to the world, can
[26:33] (1593.44s)
reason about things, and can write
[26:34] (1594.88s)
files. It is time to put it to work. So,
[26:37] (1597.44s)
this is my biggest piece of advice. If
[26:39] (1599.20s)
you want to look into something really
[26:40] (1600.64s)
different, like I said, this one might
[26:42] (1602.32s)
miss you because it does take a moment
[26:44] (1604.24s)
to see that next level to go, "Oh, okay.
[26:46] (1606.72s)
I see that I could use it for other
[26:48] (1608.56s)
things." If you're still stuck just
[26:50] (1610.16s)
trying to figure out how to code with
[26:51] (1611.52s)
it, that's perfectly fine, too.
[26:53] (1613.20s)
Obviously, it's excellent at that, and I
[26:55] (1615.36s)
haven't even scratched the surface of
[26:56] (1616.96s)
what it can really do in that space, but
[26:58] (1618.88s)
it really has legs in a place that uh
[27:01] (1621.04s)
maybe people weren't really expecting.
[27:02] (1622.88s)
All right, this is getting really long.
[27:04] (1624.32s)
I apologize for it. Thanks for sticking
[27:06] (1626.08s)
around for this one. Let's jump out.
[27:08] (1628.32s)
Okay, so this was a good one. I I really
[27:10] (1630.48s)
wanted to hand off what my experience
[27:12] (1632.40s)
with working with Claude Code for a
[27:14] (1634.24s)
month was like and what my findings were
[27:16] (1636.88s)
like. Did I stick with everything that I
[27:19] (1639.36s)
started with? What things fell off? What
[27:21] (1641.76s)
things found their way on? I hope I
[27:23] (1643.52s)
showed you some of them. This is really
[27:24] (1644.96s)
the highlight list of how to really get
[27:27] (1647.92s)
the most out of it after a month of
[27:30] (1650.16s)
working with it. And really what I'm
[27:31] (1651.84s)
talking about here is useful in almost
[27:34] (1654.32s)
all agentic coding environments or
[27:36] (1656.32s)
agentic editing environments might be a
[27:38] (1658.16s)
better way to describe these in the
[27:39] (1659.44s)
future. Um, so don't feel like I'm only
[27:42] (1662.32s)
talking about cloud code. If you use
[27:43] (1663.76s)
cursor, all of this or almost all of
[27:46] (1666.56s)
this completely uh uh works for cursor
[27:49] (1669.84s)
and all of the other systems as well.
[27:51] (1671.76s)
Even the online ones, a lot of these
[27:53] (1673.84s)
rules will work if you're working in
[27:55] (1675.60s)
bolt or other things. A lot of this kind
[27:58] (1678.56s)
of tip, idea, pattern stuff that's being
[28:01] (1681.84s)
shared is is really just general stuff.
[28:04] (1684.32s)
So, I hope this hits you a little bit
[28:06] (1686.16s)
with some ideas that you hadn't seen
[28:07] (1687.92s)
before or some aha moments with any
[28:10] (1690.32s)
luck. Uh, a lot of these are aha moments
[28:12] (1692.64s)
for me when I put them all together. So,
[28:14] (1694.64s)
I hope you feel the same. I really do
[28:17] (1697.04s)
appreciate you being here and I'll see
[28:18] (1698.88s)
you next time.