[00:00] (0.24s)
Clawed code is already super powerful
[00:03] (3.12s)
and I use it every day. But with just a
[00:05] (5.92s)
few of these tricks, I've turned it into
[00:08] (8.00s)
something that I actually truly enjoy
[00:10] (10.72s)
using. Two fish are in a tank. One turns
[00:13] (13.28s)
to the other and says, "Do you know how
[00:14] (14.72s)
to drive this thing?" Gosh, I just wish
[00:16] (16.80s)
that I could get this more easily done
[00:18] (18.64s)
inside of cursor. Oh, good lord. I mean,
[00:21] (21.68s)
I asked for crazy. Wow. Yes. Yes. I
[00:24] (24.72s)
didn't tell you about it. Today, I'm
[00:25] (25.92s)
going to cover 11 of my favorite tips
[00:28] (28.24s)
and tricks. Some of them are very
[00:30] (30.48s)
obvious and I'll fly right through them
[00:32] (32.40s)
very quickly, but others are kind of
[00:34] (34.80s)
brand new or really interesting to see.
[00:37] (37.12s)
And one of them really makes it just
[00:39] (39.44s)
really delightful to work in clawed
[00:41] (41.12s)
code. And I hope you think so, too. But
[00:43] (43.20s)
admittedly, I like to be a little bit
[00:44] (44.96s)
silly sometimes. But we really have to
[00:47] (47.28s)
push forward. So, this will be a little
[00:48] (48.80s)
bit quick. If you get lost anywhere, I
[00:51] (51.44s)
have a previous video about claude code
[00:53] (53.44s)
in general. If you don't know about
[00:54] (54.96s)
claude code, you can go check that
[00:57] (57.04s)
previous video out. and maybe that'll
[00:59] (59.04s)
give you a little bit more information
[01:00] (60.64s)
or just ask chat GPT about some of these
[01:03] (63.28s)
things. All right, let's dive in real
[01:04] (64.96s)
quick. Oh, one note before we get
[01:06] (66.72s)
started. A lot of this is going to get
[01:08] (68.40s)
compressed and it's going to feel pretty
[01:09] (69.92s)
tight and fast. It's not intended to be
[01:12] (72.48s)
that fast. Let me know. Send me a
[01:14] (74.16s)
comment or something like that if you
[01:15] (75.44s)
need me to make a whole video about any
[01:17] (77.12s)
one of these or share something that I
[01:19] (79.20s)
didn't share. But at the same time, it
[01:21] (81.04s)
also got a little bit long. I have so
[01:22] (82.80s)
much to share that really makes a
[01:24] (84.88s)
different with with the way that I use
[01:26] (86.88s)
clawed code and it really makes it very
[01:28] (88.96s)
valuable to me that I really wanted to
[01:31] (91.04s)
share them all. That's why it got a
[01:32] (92.32s)
little bit longer. So I have to
[01:33] (93.36s)
apologize upfront taking even more time
[01:35] (95.76s)
to just do that which is insane. But I
[01:38] (98.56s)
apologize for the length I think toward
[01:40] (100.64s)
the end. If you see the first ones and
[01:42] (102.48s)
you feel like I've seen all this, you
[01:44] (104.48s)
won't have seen all the ones toward the
[01:46] (106.00s)
end. So I would say just skip forward or
[01:47] (107.84s)
wait until those come up because these
[01:49] (109.60s)
really compound quite nicely. All right,
[01:51] (111.84s)
let's jump into the real content. All
[01:53] (113.52s)
right, this is not number one, but
[01:55] (115.36s)
installing Claude Code. You'll have to
[01:57] (117.28s)
go to Claude Code. Just search for it
[01:59] (119.20s)
and take this command to install. Take
[02:01] (121.44s)
it to a terminal and install it in your
[02:03] (123.52s)
terminal right there and you'll be on
[02:05] (125.52s)
your way. So, that's how you get Claude
[02:07] (127.12s)
Code started installed. Once you have it
[02:09] (129.36s)
installed, you can just type in Claude
[02:11] (131.76s)
and you'll open Claude Code in the
[02:13] (133.92s)
folder that you're in. I wanted to show
[02:15] (135.76s)
you this. I opened this in my root
[02:18] (138.00s)
folder and Claude Code now comes up. It
[02:20] (140.32s)
didn't do this in the past, but it comes
[02:21] (141.60s)
up and say, "Oh, are you sure you want
[02:23] (143.60s)
to open this in this folder?" What you
[02:25] (145.28s)
really want to do is open claude code in
[02:27] (147.12s)
a project folder where you're writing
[02:28] (148.80s)
code. So, just create a brand new folder
[02:30] (150.48s)
if you need to and do the same thing.
[02:32] (152.08s)
Just type in claude. Nice and easy.
[02:33] (153.68s)
Okay, the first tip, open claude code in
[02:36] (156.32s)
cursor or Visual Studio Code. Both of
[02:38] (158.56s)
those are free applications to just
[02:40] (160.56s)
install and use. You don't have to be a
[02:42] (162.32s)
subscriber VSC if you're not a cursor
[02:44] (164.56s)
user at all. What we're really trying to
[02:46] (166.64s)
do is have some of the controls like
[02:48] (168.72s)
being able to see files and be able to
[02:50] (170.32s)
see the contents very easily. So we're
[02:52] (172.32s)
going to be inside of cursor here. I
[02:54] (174.80s)
will pull open a terminal just like we
[02:56] (176.80s)
were in a terminal window before. Once
[02:58] (178.96s)
you're inside of cursor and you've run
[03:00] (180.88s)
claude. So here we are looking at
[03:02] (182.48s)
claude. I'm going to run a slash command
[03:04] (184.72s)
and there is a slash command called IDE.
[03:07] (187.52s)
And you can see here that it says manage
[03:09] (189.20s)
IDE integrations and show your status.
[03:11] (191.60s)
So if I hit that it knows that I'm in
[03:13] (193.52s)
cursor and what that really does is if I
[03:16] (196.00s)
happen to open a file then what will
[03:18] (198.32s)
happen is when I come down here it will
[03:20] (200.32s)
gain reference to the file that I have
[03:22] (202.16s)
open because of that integration. So
[03:24] (204.32s)
that's one of the things that's one of
[03:25] (205.76s)
our first tricks is once you do this
[03:28] (208.08s)
you'll be working within the IDE and
[03:30] (210.40s)
files that you have and things that you
[03:32] (212.32s)
select will show up down below or inside
[03:34] (214.88s)
of the terminal version of claude when
[03:36] (216.64s)
you're using it and it allows both of
[03:38] (218.00s)
them to work together. We got to move
[03:39] (219.36s)
on. All right, for the next one, very
[03:41] (221.12s)
easy one. It's /init. And it's really
[03:43] (223.76s)
the way that you get started inside of
[03:45] (225.76s)
Claude Code in a new project. So, what
[03:47] (227.84s)
it's about to do when I hit init is
[03:49] (229.60s)
it'll look through the entire project
[03:51] (231.36s)
and tell me something about the project
[03:53] (233.12s)
and record it all in this special file
[03:55] (235.28s)
called claude MD. It's just a file that
[03:57] (237.92s)
lists all the directories and all the
[03:59] (239.84s)
opinions of the system. This is what
[04:01] (241.84s)
they call their memory file. And this is
[04:04] (244.00s)
kind of a thing that's pumped into the
[04:06] (246.16s)
beginning of every chat that you start.
[04:08] (248.00s)
It basically preeds all of the chats
[04:11] (251.12s)
that you start just once so that every
[04:13] (253.20s)
chat you have has this information
[04:15] (255.20s)
inside of it and contextually the models
[04:17] (257.76s)
underneath will always kind of have an
[04:19] (259.68s)
idea of what project it's working inside
[04:21] (261.44s)
of. So basically new project start get
[04:24] (264.08s)
started and then run clot you can do it
[04:26] (266.16s)
at any time. Okay, so the next one, in
[04:28] (268.64s)
fact, two really fast I'm going to show
[04:30] (270.88s)
you because you know these already.
[04:32] (272.32s)
You've probably heard about them as you
[04:34] (274.24s)
move in. Think chat GBT. You start a new
[04:36] (276.32s)
chat, you have a conversation, it gets
[04:37] (277.76s)
longer and longer. All of that is within
[04:39] (279.84s)
the context is the idea. So all of this
[04:42] (282.00s)
gets sent back and forth sort of to the
[04:44] (284.24s)
model every single time. The model has
[04:46] (286.64s)
all of that information to continue to
[04:48] (288.40s)
work on and it helps kind of get better
[04:50] (290.80s)
about the conversation as it goes
[04:52] (292.24s)
forward. Same thing happens here except
[04:54] (294.16s)
there's a lot more data sometimes in a
[04:55] (295.76s)
project, right? these projects get
[04:57] (297.52s)
really really big and the context window
[04:59] (299.52s)
is pretty big these days. So everything
[05:01] (301.84s)
inside of this this context is piled on
[05:05] (305.28s)
top of everything. What you'll start
[05:06] (306.56s)
seeing is a message down here saying 25%
[05:09] (309.20s)
until compaction or something like that.
[05:11] (311.28s)
What it's trying to say is I can't have
[05:13] (313.60s)
an endless amount of information going
[05:15] (315.60s)
in. So I have to summarize it to some
[05:18] (318.08s)
degree and keep the nuances so that the
[05:20] (320.72s)
next question in this chat that you have
[05:22] (322.96s)
I'll still remember all the other things
[05:24] (324.48s)
that we were talking about. So that one
[05:26] (326.32s)
is compact and you can run that yourself
[05:28] (328.48s)
and you'll see it's clears conversation
[05:30] (330.32s)
history but keeps a summary. So that
[05:32] (332.16s)
one's important. You can run compact
[05:33] (333.76s)
anytime you're kind of working through a
[05:35] (335.52s)
problem continually and you want smaller
[05:37] (337.52s)
and smaller essentially contexts for the
[05:40] (340.56s)
model to kind of work on instead of
[05:42] (342.16s)
having this enormous history. It will
[05:44] (344.08s)
autoco compact. It takes a while to
[05:45] (345.84s)
compact. So do it when you feel like you
[05:47] (347.68s)
have time to do it if you're going to
[05:48] (348.96s)
compact. But the one that I would advise
[05:50] (350.96s)
is actually clear. So, it's a sister to
[05:53] (353.36s)
the compact and it's really the first
[05:55] (355.12s)
one that you need to learn. It's
[05:56] (356.56s)
basically hitting the new button or the
[05:58] (358.08s)
plus button in chat GPT to create a new
[06:00] (360.16s)
chat. This one just clears everything
[06:01] (361.68s)
out, starts a new conversation history,
[06:04] (364.16s)
by the way, shves that Claude MD file in
[06:06] (366.72s)
there so that Claude kind of understands
[06:08] (368.64s)
those those things again, and then
[06:10] (370.40s)
you're off to the races with a new
[06:12] (372.00s)
context. Okay, some later ones get
[06:14] (374.32s)
better. I know you've probably heard
[06:16] (376.00s)
quite a few of these, but I thought they
[06:17] (377.60s)
were important to put in here just in
[06:19] (379.04s)
case some people hadn't. The next one
[06:20] (380.48s)
I'm going to show is you can change the
[06:22] (382.24s)
model that you're on. If you have a
[06:24] (384.08s)
subscription with an anthropic that
[06:25] (385.68s)
allows you to have both Opus and Sonnet.
[06:27] (387.60s)
This is the way that you can choose
[06:28] (388.88s)
between Opus and Sonnet or you can
[06:30] (390.56s)
choose their default which does Opus 4
[06:33] (393.28s)
as the first model all the time up to
[06:35] (395.28s)
50% of your usage and then it starts
[06:37] (397.52s)
using Sonnet for when it thinks oh you
[06:39] (399.84s)
might be getting close. Let me pull back
[06:41] (401.36s)
a little bit. The other one here just
[06:43] (403.04s)
going to rush through this. If you hit
[06:44] (404.48s)
shift tab, you'll see that this is
[06:46] (406.24s)
flashing at the bottom of the screen
[06:47] (407.60s)
here as I'm continuing to hit shift tab.
[06:50] (410.32s)
So, it starts on this mode, no mode at
[06:52] (412.64s)
all. Let's call it default mode. And
[06:54] (414.32s)
then if you shift tab one time, it goes
[06:56] (416.08s)
into auto accept. And that really is
[06:58] (418.16s)
every now and then when you ask it to do
[06:59] (419.84s)
something, if it's going to write a
[07:00] (420.96s)
file, if it's going to list your files,
[07:02] (422.96s)
read your files, change a directory,
[07:04] (424.40s)
those kinds of things, it will come back
[07:05] (425.76s)
and say, is it okay that I do this? Yes,
[07:08] (428.32s)
no, yes every time within this session.
[07:10] (430.56s)
Don't ask me again. Those are the kinds
[07:11] (431.92s)
of things that you'll see here. This
[07:13] (433.44s)
mode kind of auto accepts many of those,
[07:15] (435.84s)
not all of them. You will still get that
[07:17] (437.68s)
question. Plan mode though is just for
[07:20] (440.40s)
conversational. It won't write any
[07:21] (441.92s)
files. The idea is you ask it to plan
[07:23] (443.76s)
something out. It comes back with a huge
[07:25] (445.60s)
well-th thoughtout plan. Asks you if
[07:27] (447.68s)
you're okay with it. I would advise
[07:29] (449.20s)
reading through that plan and saying no
[07:31] (451.12s)
and having more conversation with it. It
[07:33] (453.04s)
will end up with a very good plan. If
[07:35] (455.20s)
you work back and forth with it a bit
[07:36] (456.96s)
and then you can say yes, and it will go
[07:38] (458.64s)
off to the races and start doing its
[07:40] (460.32s)
thing. shift tab into auto accept and
[07:42] (462.24s)
you'll have a much better time. But
[07:43] (463.60s)
that's not the only way to do this.
[07:45] (465.20s)
Okay, here's another. I'm gonna try to
[07:46] (466.88s)
be brief about this one, but this one is
[07:48] (468.72s)
critically useful to me. So, I want you
[07:50] (470.40s)
to hear you can put files into this.
[07:52] (472.40s)
Now, admittedly, we're inside of the uh
[07:55] (475.76s)
cursor environment at this point, so it
[07:57] (477.44s)
gets a little confusing, but I can drag
[07:59] (479.60s)
this file over here. And if I drop that
[08:01] (481.92s)
file there, you'll see that it puts in
[08:04] (484.40s)
the path essentially to that file.
[08:06] (486.72s)
That's one way so that you can reference
[08:08] (488.72s)
files directly with a path name and that
[08:11] (491.04s)
works. But you can also use the at
[08:12] (492.96s)
command to get to that. So if I wanted
[08:14] (494.72s)
to get to the calculator file, that's
[08:16] (496.64s)
how I would reference it with an at. So
[08:18] (498.96s)
tab completed that. It just selected
[08:20] (500.88s)
what I was on. So that's an easy way to
[08:22] (502.64s)
kind of reference files that are within
[08:24] (504.40s)
your project. The other thing that's
[08:26] (506.08s)
actually quite useful is if you take a
[08:28] (508.00s)
screenshot of something. So that takes a
[08:29] (509.92s)
screenshot. I have a little utility down
[08:31] (511.52s)
here that allows me to drag my
[08:33] (513.04s)
screenshot around. And if I put it
[08:34] (514.80s)
there, you'll notice all it's really
[08:36] (516.40s)
doing is putting the path in to the
[08:38] (518.64s)
screenshot, which is kind of nice. So
[08:40] (520.56s)
that's just referencing the file that we
[08:42] (522.72s)
created underneath this. And there's
[08:44] (524.48s)
another way, and I'll have to show you
[08:45] (525.84s)
an interesting utility that I have
[08:47] (527.28s)
called paste, which is this is my
[08:49] (529.28s)
clipboard. This is the clipboard that
[08:50] (530.80s)
I've things that I've clipped recently.
[08:52] (532.80s)
And what happened when I took that
[08:54] (534.16s)
screenshot, they automatically go into
[08:55] (535.92s)
my clipboard as well. I can drag it from
[08:58] (538.00s)
here or I can just paste it here. And
[09:00] (540.16s)
this is not obvious. So this is the one
[09:01] (541.92s)
that's worth talking about. control V.
[09:04] (544.32s)
Now in Mac, all Mac users will kind of
[09:06] (546.40s)
hear that and go, "Yeah, yeah, command
[09:07] (547.68s)
V." They meant command V. I really meant
[09:09] (549.52s)
controlV. So weirdly in in this terminal
[09:12] (552.64s)
application of clawed code. If you use
[09:14] (554.72s)
controlV, it'll just paste right in. So
[09:16] (556.40s)
this is essentially the same image.
[09:17] (557.84s)
That's the trick. I highly highly advise
[09:20] (560.32s)
sending images in. It is a fantastic way
[09:22] (562.80s)
to work. These models can figure out a
[09:24] (564.72s)
whole bunch. I could just take a whole
[09:26] (566.08s)
picture of this this entire system and
[09:28] (568.32s)
say, "Oh, go figure out what's wrong."
[09:30] (570.08s)
And it does a very good job of figuring
[09:31] (571.76s)
that out. All right, moving on. Okay, a
[09:33] (573.60s)
quick side trick. So, I haven't talked
[09:35] (575.60s)
about this yet. Let me exit this
[09:38] (578.00s)
terminal version of Claude. We'll close
[09:39] (579.84s)
that window down. There happens to be a
[09:41] (581.92s)
command escape mechanism that I can open
[09:44] (584.24s)
up a clawed tab. So, it works more like
[09:46] (586.48s)
a tab than it does that parked terminal
[09:48] (588.72s)
window. Interesting, but it's just shell
[09:50] (590.40s)
running in the tab. I'm going to run
[09:51] (591.84s)
this way. I just wanted to show you
[09:52] (592.88s)
that. And I really like command escape
[09:54] (594.56s)
to be able to pull open claw at any
[09:56] (596.72s)
time. And then I can just treat it like
[09:58] (598.32s)
any other tab. Okay. So, with that,
[10:00] (600.40s)
we're going to need to talk about custom
[10:01] (601.92s)
commands. Now, these commands are these
[10:03] (603.52s)
slash commands. We've seen them before,
[10:05] (605.44s)
and you can see that I have a couple
[10:07] (607.60s)
extra commands at the top, including the
[10:10] (610.16s)
normal ones that Claude will give you.
[10:11] (611.76s)
So, let's talk about these extra ones at
[10:13] (613.68s)
the top. I have one called joke me. Tell
[10:15] (615.60s)
me a dad joke. And if I hit enter, it
[10:17] (617.68s)
executes that command right away. Goes
[10:19] (619.68s)
to the model. The model runs the
[10:22] (622.00s)
execution. And then whatever comes back
[10:24] (624.32s)
is what it presents to us. Why don't
[10:26] (626.08s)
scientists trust atoms? I think you know
[10:27] (627.92s)
the answer to that. Okay. So very
[10:29] (629.84s)
quickly, where did this come from? What
[10:31] (631.68s)
is that all about? All right. So if you
[10:33] (633.92s)
look into the files over here, it's one
[10:35] (635.84s)
of the reasons that it's neat to be
[10:37] (637.36s)
inside of cursor or some other system
[10:39] (639.12s)
that you can kind of just directly edit
[10:40] (640.80s)
files. I have created a do.cloud folder.
[10:43] (643.12s)
I just created all this by hand. So just
[10:44] (644.96s)
feel free to create. Then there's inside
[10:46] (646.96s)
of that. Cloud folder another folder
[10:49] (649.12s)
called commands. This is just the file
[10:50] (650.88s)
structure that cla code uses to hold
[10:52] (652.80s)
these things. And then inside of that is
[10:54] (654.96s)
a markdown file. any markdown file that
[10:57] (657.44s)
it finds inside of the commands folder,
[11:00] (660.40s)
it will use as a custom command. And you
[11:02] (662.40s)
can put them in subfolders, a whole
[11:03] (663.76s)
bunch of other things. Go look it up.
[11:05] (665.04s)
But if we look inside of joke me, this
[11:07] (667.36s)
file that I've created, tell me a dad
[11:09] (669.44s)
joke is what shows up when I hit the
[11:11] (671.20s)
slash. So the first line is what shows
[11:13] (673.04s)
up. This ends up being the prompt. The
[11:15] (675.36s)
entire thing, in fact, goes into the
[11:16] (676.96s)
model as the entire prompt. And you'll
[11:18] (678.72s)
see that I've even said there's an
[11:20] (680.40s)
optional element down here. It says, if
[11:22] (682.40s)
the user provides a topic, make a joke
[11:24] (684.24s)
about that topic. Otherwise, tell me a
[11:26] (686.24s)
dad joke. Okay, dollar arguments is
[11:28] (688.40s)
where whatever you type in will go in.
[11:30] (690.64s)
Let's take a look at that. Two fish are
[11:32] (692.16s)
in a tank. One turns to the other and
[11:33] (693.92s)
says, "Do you know how to drive this
[11:35] (695.28s)
thing?" Bad bum. Okay, let's briefly
[11:37] (697.20s)
talk about those custom commands. That
[11:38] (698.80s)
one was within this file within this
[11:40] (700.96s)
project. So, these are project settings
[11:43] (703.28s)
that happen. We'll look at settings a
[11:44] (704.96s)
little bit more in just a second. So,
[11:46] (706.40s)
just realize we're inside of this
[11:47] (707.92s)
project and there's a cloud folder.
[11:49] (709.60s)
These are things that will get checked
[11:51] (711.04s)
in depending upon your git ignore file
[11:52] (712.96s)
so that other members of your team can
[11:54] (714.80s)
get to it. All those kinds of cool
[11:56] (716.40s)
things so everybody gets the same kind
[11:58] (718.00s)
of experience. However, this folder also
[12:00] (720.56s)
exists in your root folder in your home
[12:02] (722.56s)
folder. So I have a home/.claude
[12:05] (725.60s)
and inside of that have some of these
[12:07] (727.36s)
things as well. And I'm going to confuse
[12:09] (729.36s)
you real quickly, but I'm going to pull
[12:10] (730.96s)
up another version of cursor here. This
[12:14] (734.16s)
instance of cursor is actually pointing
[12:16] (736.08s)
at my home directory and that clawed
[12:18] (738.48s)
folder. So, it's just everything inside
[12:20] (740.32s)
of mycloud folder in my home directory
[12:22] (742.80s)
opened up here. And what you can see is
[12:24] (744.96s)
there is a commands folder just like we
[12:27] (747.04s)
were looking at. And I have created some
[12:28] (748.56s)
commands in here. One for a get save
[12:31] (751.04s)
kind of mechanism. We'll do a commit
[12:33] (753.12s)
message, a special commit message that
[12:35] (755.12s)
it does with different icons and things
[12:37] (757.04s)
like that. And another one is a set of
[12:39] (759.36s)
project settings and design iteration
[12:41] (761.36s)
that we do. So, we need to really look
[12:42] (762.80s)
at that one cuz that's one of the cool.
[12:44] (764.40s)
So, you might notice if I was you and I
[12:46] (766.96s)
was looking at this a couple weeks ago,
[12:48] (768.40s)
I would have said, gosh, I just wish
[12:50] (770.16s)
that I could get this more easily done
[12:52] (772.08s)
inside of cursor. I have a way of
[12:54] (774.48s)
coloring all of my cursors. Now, this is
[12:56] (776.56s)
just Visual Studio Code. You can color a
[12:58] (778.72s)
project. It's been there for a long
[13:00] (780.24s)
time. I'm not inventing the wheel here,
[13:02] (782.16s)
by the way, but I did use Claude Code to
[13:04] (784.24s)
solve this problem for me because it's a
[13:06] (786.08s)
little bit trickier these days in Visual
[13:08] (788.16s)
Studio Code than it used to be to be
[13:09] (789.60s)
able to do this. So okay if you remember
[13:11] (791.92s)
we were looking at project level
[13:13] (793.76s)
settings here there are also the the
[13:16] (796.24s)
commands that are done at a at a higher
[13:18] (798.80s)
level or my global level essentially my
[13:21] (801.36s)
system level if I hit slash you will see
[13:24] (804.16s)
that the gsave is there project settings
[13:26] (806.40s)
is there so these other files that I've
[13:28] (808.72s)
created here are actually also available
[13:32] (812.00s)
here in every project that I run and
[13:34] (814.16s)
that's one of the values of course is
[13:35] (815.60s)
putting them in your home directory so
[13:36] (816.96s)
that every project that you run gets
[13:38] (818.72s)
them one of them though is very very
[13:40] (820.88s)
cool. So we have to look at this one
[13:42] (822.80s)
first. We're going to look at the
[13:44] (824.72s)
project settings which we just just
[13:46] (826.64s)
solved for. And if I want this version
[13:49] (829.52s)
of cursor to be a different color, then
[13:51] (831.44s)
I can just run project settings. And
[13:53] (833.36s)
that project settings function I'm just
[13:55] (835.60s)
going to let him run. If we come back
[13:57] (837.20s)
and look at it, is not terribly complex.
[13:59] (839.76s)
It says we want to colorize the current
[14:01] (841.92s)
workspace for VSC. Here's the intent
[14:04] (844.88s)
really what we're up to. tells it, hey,
[14:06] (846.96s)
what we need is avo
[14:09] (849.68s)
settingsjson file. Go create those.
[14:12] (852.16s)
Here's an example file as a default if
[14:14] (854.72s)
it doesn't exist. And that's all it's
[14:16] (856.24s)
going to do. And you might notice in the
[14:17] (857.92s)
background here, it did create this
[14:19] (859.68s)
file. And once I accept that file, then
[14:22] (862.64s)
it changes all of the color schemes. And
[14:24] (864.96s)
that's awesome, right? So now I have a
[14:27] (867.20s)
theme environment just using this VS
[14:29] (869.92s)
Code folder, very similar to the cloud
[14:31] (871.52s)
one we just created, by the way. And if
[14:33] (873.28s)
I do something like choose a different
[14:35] (875.20s)
color theme here, then this project will
[14:37] (877.44s)
look like that going forward, right?
[14:39] (879.12s)
Very cool. Okay, there's one more
[14:41] (881.20s)
interesting one down there that we're
[14:42] (882.56s)
going to take on. So there was another
[14:44] (884.08s)
one down here called design iterate. And
[14:46] (886.64s)
what I've done in this design iterate is
[14:48] (888.80s)
just said I want you to launch in number
[14:52] (892.48s)
default of three concurrent subtasks. So
[14:55] (895.68s)
there's sub aents going on. One of the
[14:57] (897.28s)
thing cla code can do and we'll see this
[14:59] (899.12s)
in a second is it can run itself
[15:00] (900.96s)
holistically. So, Claude Code is a CLI
[15:03] (903.28s)
interface that can also run essentially
[15:05] (905.04s)
headless, which means it doesn't need to
[15:06] (906.48s)
show you anything. It'll just go and
[15:08] (908.24s)
execute what you ask it to execute and
[15:10] (910.16s)
then return the response value from
[15:11] (911.84s)
that. We'll see that in a second. I have
[15:13] (913.84s)
some real cool things from that as well.
[15:15] (915.68s)
What you can do is ask it to create
[15:17] (917.60s)
subtasks. And what we're saying is for
[15:19] (919.84s)
each one of the subtasks, I want you to
[15:22] (922.24s)
create if the user gives you an image, a
[15:24] (924.64s)
version of that UI because we kind of
[15:27] (927.12s)
want to iterate on a UI idea to see if
[15:30] (930.56s)
we can come up with some creative things
[15:32] (932.64s)
from that. So what we're going to do is
[15:34] (934.48s)
we're going to create a parallel set of
[15:37] (937.04s)
calls out that are going to create as
[15:39] (939.20s)
many kind of iterations as we want.
[15:41] (941.20s)
Let's take a look at that. We're going
[15:42] (942.40s)
to come back to this guy and we're going
[15:43] (943.92s)
to say we want to do oop sorry spinning
[15:46] (946.80s)
around design iterate. So we want to
[15:48] (948.64s)
design iterate and I want to if you
[15:51] (951.12s)
recall use this clipboard object here.
[15:54] (954.48s)
So that's the PNG. That's our image that
[15:56] (956.48s)
we're going to design iterate. And I
[15:58] (958.40s)
want five designs some simply crazy. All
[16:01] (961.52s)
right. I can see this is calculator
[16:03] (963.28s)
interface with a dark theme. I'll create
[16:05] (965.04s)
five different design iterations. And
[16:06] (966.88s)
what we're going to see it do now that
[16:08] (968.80s)
it knows that it needs to do this. It's
[16:10] (970.48s)
created the UI iterations folder and it
[16:12] (972.72s)
starts creating these tasks. Create
[16:14] (974.80s)
minimalist calculator. Create neon
[16:16] (976.80s)
cyberpunk calculator. Create retro80s
[16:19] (979.20s)
calculator. These have not completed
[16:20] (980.64s)
yet. They haven't even started yet.
[16:22] (982.32s)
Create 3D isometric calculator. And the
[16:25] (985.20s)
emoji chaos calculator, which I just
[16:27] (987.76s)
can't wait. So, you'll see they're all
[16:29] (989.36s)
running at this point. Sorry. Sorry.
[16:31] (991.60s)
There are some issues with the UI here
[16:34] (994.16s)
sometimes. There we go. So, they're all
[16:36] (996.72s)
running right now or kind of
[16:38] (998.00s)
initializing and getting ready to run,
[16:39] (999.68s)
if you will. And then you'll see that
[16:41] (1001.28s)
they keep they start and as they work
[16:43] (1003.52s)
through their work they'll update inside
[16:45] (1005.92s)
of this little task list. So each one of
[16:47] (1007.76s)
them will have their own little
[16:49] (1009.12s)
checklist and those kinds of things.
[16:50] (1010.56s)
It's worth saying I have asked over here
[16:53] (1013.20s)
for construct a standalone HTML page
[16:55] (1015.84s)
featuring one interface screen that
[16:57] (1017.36s)
addresses the user requirement or brief.
[16:59] (1019.36s)
So basically we're going to get this is
[17:01] (1021.20s)
singleshot HTML programming just so that
[17:03] (1023.52s)
we can get designs back. Once we get
[17:05] (1025.28s)
them then we can kind of steal some of
[17:06] (1026.80s)
the components if we like them. Let's
[17:08] (1028.32s)
let this thing cook. Okay. And it's
[17:10] (1030.24s)
done. Let's take a look at what it came
[17:12] (1032.16s)
up with. We can kind of see them right
[17:13] (1033.68s)
here, which is kind of neat. Let's load
[17:15] (1035.36s)
the first one. Oh, good lord. Okay. I
[17:18] (1038.40s)
mean, I asked for crazy. What's next?
[17:20] (1040.32s)
Wow. Yes. Yes. I That's pretty cool.
[17:23] (1043.52s)
Well, maybe some design issues here.
[17:25] (1045.60s)
Can't quite click them. All right.
[17:28] (1048.32s)
Eight. I got an eight. My eight minus.
[17:30] (1050.48s)
Okay. Moving on. Okay. Excellent work.
[17:32] (1052.80s)
Okay. We have three more and they're
[17:35] (1055.04s)
really fun. The last one I love. I
[17:37] (1057.44s)
actually love it. You might have already
[17:39] (1059.28s)
experienced it here, but we'll see in a
[17:41] (1061.28s)
second. So, the first one really super
[17:43] (1063.20s)
simple. Let's drop out here and we'll
[17:45] (1065.68s)
get back to shell and say, okay, Claude,
[17:48] (1068.88s)
dangerously skip permissions. Now, what
[17:51] (1071.36s)
I'm doing here, I want to tell you not
[17:53] (1073.68s)
to do. It's the right thing to do. Don't
[17:55] (1075.52s)
start Claude this way. This will bypass
[17:58] (1078.08s)
permissions. I use it this way quite a
[18:00] (1080.24s)
bit, to be honest. So, I find this
[18:02] (1082.32s)
tremendously useful that I can just
[18:04] (1084.56s)
generally walk away from the system,
[18:06] (1086.48s)
allow it to do what it needs to do and
[18:08] (1088.08s)
cook. I have used it a lot and have not
[18:10] (1090.48s)
had any issues with it. But that doesn't
[18:13] (1093.04s)
mean that it absolutely couldn't start
[18:14] (1094.88s)
eating things. It's not supposed to. So,
[18:16] (1096.64s)
be really really cautious about this at
[18:18] (1098.56s)
your own risk. Put your own protections
[18:20] (1100.32s)
down the way you like. But, this one has
[18:22] (1102.00s)
been a real gamecher for me. I didn't
[18:24] (1104.16s)
tell you about it. Okay, this next one
[18:25] (1105.92s)
is going to feel pretty esoteric, so
[18:28] (1108.56s)
live with me for just a second. And I
[18:30] (1110.64s)
have to describe a couple weird things
[18:32] (1112.08s)
to you. I'm going to bring up a utility
[18:33] (1113.92s)
here that I use to launch applications
[18:36] (1116.72s)
similar to Spotlight. If you're a Mac
[18:38] (1118.48s)
user, you use Spotlight. I use something
[18:40] (1120.48s)
called Raycast. Raycast has the ability
[18:42] (1122.96s)
to allow you to run scripts. You write
[18:44] (1124.88s)
your own scripts and run them. In fact,
[18:47] (1127.36s)
of course, I write all of my scripts
[18:49] (1129.92s)
with Claude code. When I have a script,
[18:52] (1132.32s)
you'll see one of them is clipboard to
[18:54] (1134.16s)
downloads. This is using Claude itself.
[18:56] (1136.80s)
So, what this utility that I wrote or
[18:59] (1139.28s)
really asked Claude to write for me is
[19:01] (1141.60s)
doing is down in here somewhere, you'll
[19:03] (1143.84s)
see that it's using the Claude command
[19:05] (1145.68s)
just like we would by hand and running a
[19:08] (1148.24s)
command for us. Let's take a look. If I
[19:10] (1150.08s)
have something on my clipboard, I'm
[19:11] (1151.76s)
going to copy that. I'm going to show
[19:13] (1153.44s)
you my clipboard utility that this is
[19:15] (1155.28s)
copied onto my clipboard. And then I'm
[19:17] (1157.68s)
going to run this command, which is
[19:19] (1159.76s)
clipboard to downloads. And what it's
[19:21] (1161.76s)
doing is it's sending the whole text to
[19:24] (1164.00s)
Claude with another prompt that says,
[19:26] (1166.72s)
"Evaluate what's on this. I need a file
[19:29] (1169.20s)
name. I need an extension for this. I
[19:31] (1171.52s)
need to understand what's in the file."
[19:32] (1172.96s)
And it gives that back to me. Then the
[19:34] (1174.88s)
script goes forward, saves this into my
[19:37] (1177.28s)
downloads folder so I have an actual
[19:39] (1179.52s)
file and then also pushes that file onto
[19:42] (1182.72s)
my clipboard so that I can paste that
[19:44] (1184.72s)
file in certain places. So for this
[19:46] (1186.72s)
case, what I'm going to do so that you
[19:48] (1188.64s)
can understand what I'm doing here is I
[19:50] (1190.72s)
will paste the file right here just
[19:52] (1192.48s)
because it's on my clipboard as if I had
[19:54] (1194.40s)
dragged it in from my downloads. And I
[19:56] (1196.24s)
can say, is this the poem? And it says,
[19:58] (1198.48s)
yep, that's the poem. If I said, okay,
[20:00] (1200.64s)
go grab this, you'll see I've grabbed a
[20:02] (1202.96s)
hunch a bunch of markdown. And if I run
[20:05] (1205.12s)
it again with a wholly different thing,
[20:07] (1207.36s)
basically a blog post. This time
[20:09] (1209.20s)
Claude's going to come back and say,
[20:10] (1210.48s)
"Oh, well that looks like a markdown
[20:12] (1212.08s)
file. I'm going to save this as a MD."
[20:14] (1214.96s)
and then you have a MD file. So, this
[20:17] (1217.36s)
just allows me to select things on the
[20:19] (1219.04s)
web and create files out of them very,
[20:20] (1220.96s)
very quickly. I do this very often as I
[20:23] (1223.28s)
need to move files around inside of LLMs
[20:25] (1225.76s)
more frequently than just a one-time
[20:28] (1228.00s)
text prompt that I'm dropping in. Okay,
[20:29] (1229.68s)
I thought I'd show you that. I know that
[20:31] (1231.28s)
one's crazy because you have to know
[20:32] (1232.56s)
raycast and scripts and all of this
[20:34] (1234.40s)
other stuff, but this is just us using
[20:36] (1236.48s)
claude as a utility at the command line
[20:38] (1238.96s)
or within another script essentially to
[20:41] (1241.44s)
give us data back and use intelligence
[20:43] (1243.76s)
inside of what otherwise would have just
[20:45] (1245.36s)
been a plain script. All right, moving
[20:46] (1246.80s)
on to the best one. The best one is
[20:48] (1248.56s)
next. My favorite, so hang in there.
[20:50] (1250.96s)
It's pretty short, so let's get through
[20:52] (1252.72s)
it. Okay, here's my favorite last one.
[20:55] (1255.20s)
It takes a little bit of explaining, but
[20:56] (1256.80s)
not nearly as complicated as that
[20:58] (1258.32s)
raycript one. Okay, the raycast one. So,
[21:01] (1261.68s)
here we go. What I am doing is I'm
[21:04] (1264.00s)
showing you first I'm inside of that
[21:05] (1265.92s)
claude project or the claude folder, the
[21:08] (1268.80s)
cloud folder inside of my home
[21:10] (1270.00s)
directory. So, this is just the base
[21:11] (1271.84s)
area for settings for claude on my
[21:14] (1274.64s)
system. And I just needed to show you
[21:16] (1276.32s)
that there's this settings file inside
[21:18] (1278.56s)
of this folder. And in many cases,
[21:21] (1281.28s)
you'll find this in inside of your
[21:24] (1284.32s)
project. So many projects will have
[21:26] (1286.56s)
these claude settings as well in the
[21:28] (1288.24s)
dotcloud folder like we talked about
[21:30] (1290.16s)
before. But what I've done at the top
[21:32] (1292.56s)
level is I've put in something called a
[21:35] (1295.44s)
hook. So if we come back to claude code
[21:37] (1297.60s)
itself and said I want hooks. Slooks is
[21:41] (1301.92s)
a slash command coming from claude
[21:43] (1303.60s)
itself. And if I go into this and you'll
[21:45] (1305.68s)
see they have five different types of
[21:48] (1308.32s)
hook. Pre-tool use, post tool use,
[21:50] (1310.88s)
notification stop, and sub aent stop. So
[21:53] (1313.68s)
pre-tool and posttool is right before a
[21:56] (1316.16s)
tool starts to execute or right before
[21:58] (1318.64s)
the tool execution is done. You can kind
[22:01] (1321.36s)
of interject things. You can then be in
[22:03] (1323.36s)
the pipeline, which is great. Kind of a
[22:04] (1324.88s)
plug-in interface here. Notification is
[22:08] (1328.56s)
sort of when Claude needs your
[22:10] (1330.40s)
attention. It's not just when it's
[22:11] (1331.84s)
finished and it gives you the prompt
[22:13] (1333.28s)
back, but when it might be asking you a
[22:15] (1335.52s)
question or prompting you for a
[22:17] (1337.04s)
selection to make or approval, something
[22:19] (1339.12s)
like that. Stop is when it finishes the
[22:22] (1342.08s)
work that it's working on at this
[22:23] (1343.52s)
moment. And that's the one that we'll be
[22:25] (1345.20s)
showing. Stop sub agent is when you have
[22:27] (1347.36s)
a sub agent or one of these subtasks
[22:29] (1349.28s)
that's kicking off doing work. Every
[22:31] (1351.12s)
time each one of those stops, you can do
[22:33] (1353.52s)
something inside of that agent. All
[22:34] (1354.96s)
right, that's a whole bunch of
[22:36] (1356.40s)
conversation about something. What it
[22:38] (1358.48s)
does, if I had gone in and set that up,
[22:40] (1360.88s)
I just wanted to show you what it
[22:42] (1362.08s)
writes. I have written a a a command
[22:45] (1365.60s)
here. Basically, it's just running a
[22:46] (1366.80s)
shell command called AF play. AF play is
[22:49] (1369.04s)
the audio framework for Mac. So you can
[22:52] (1372.16s)
always drop down and do AF play point to
[22:54] (1374.56s)
some path that is a wave file, MP3 file,
[22:57] (1377.60s)
something like this. And this one just
[22:59] (1379.28s)
points at a wave file that happens to be
[23:01] (1381.68s)
on my my computer somewhere. Right? So
[23:04] (1384.80s)
this is just a standard wave file. And
[23:06] (1386.72s)
what I'll show you here is that will
[23:09] (1389.36s)
play once this is done.
[23:16] (1396.08s)
Okay. So that awesome chime every time
[23:18] (1398.72s)
cla code is completed in any project is
[23:21] (1401.92s)
going to kick off. That's what you're
[23:23] (1403.28s)
going to hear. I'm going to hear because
[23:25] (1405.20s)
I put it at my root level. And I wanted
[23:27] (1407.04s)
to show you that because I'm compounding
[23:28] (1408.96s)
these things. So watch this. In this
[23:31] (1411.44s)
project, which is a service that deals
[23:35] (1415.44s)
with numbers, I have something that goes
[23:37] (1417.92s)
and reads a whole bunch of YouTube
[23:39] (1419.04s)
numbers. It was in my previous video
[23:40] (1420.48s)
about cloud code. You can take a look at
[23:42] (1422.00s)
it there. And I felt like, oh, you know,
[23:44] (1424.08s)
who deals with numbers?
[23:46] (1426.40s)
stats up, bro. Other than, you know,
[23:48] (1428.80s)
maybe a crypto bro. So, that one's
[23:50] (1430.88s)
great. But you heard both audio files
[23:53] (1433.36s)
playing here. If I look in here, this
[23:55] (1435.12s)
one has a clawed file in settings as
[23:57] (1437.04s)
well. And inside of its setting, it has
[23:59] (1439.60s)
a stop hook. So, both of these stop
[24:01] (1441.68s)
hooks are going off at the same time.
[24:03] (1443.36s)
And that's the neat thing that's
[24:04] (1444.64s)
happening is I have two stop hooks. One
[24:06] (1446.96s)
at the global level and another one down
[24:09] (1449.20s)
here at this project level. And if I do
[24:11] (1451.44s)
it at a third project,
[24:14] (1454.16s)
oh, stats UI, then my stats UI project
[24:17] (1457.28s)
also tells me, by the way, I made these
[24:19] (1459.04s)
sound files with 11 Labs with
[24:20] (1460.56s)
personality and all of this other stuff.
[24:22] (1462.32s)
So, a lot of cool stuff going on here,
[24:24] (1464.08s)
but this one is great. So, these things
[24:25] (1465.76s)
run off and take 10, 20 minutes
[24:27] (1467.76s)
sometimes to do their work. And I have
[24:30] (1470.32s)
four or five of them open a lot, very,
[24:32] (1472.80s)
very often. And so, I'm chasing them and
[24:35] (1475.20s)
checking them over and over. I don't
[24:36] (1476.48s)
know which one, even if I just had that
[24:38] (1478.00s)
general sound, I don't know which one
[24:39] (1479.44s)
made the sound. So now I have them, some
[24:42] (1482.16s)
of them at least telling me what
[24:44] (1484.32s)
happened, who finished. So I thought I
[24:46] (1486.72s)
would share that. To me, this was the
[24:48] (1488.64s)
most enjoyable, the silliest one, but
[24:50] (1490.64s)
really makes me feel good when it goes
[24:52] (1492.08s)
off. All right, I hope you enjoyed that.
[24:54] (1494.32s)
I had a lot of fun with these, just
[24:56] (1496.40s)
trying to pull together the top things
[24:58] (1498.40s)
that I'm doing inside of Claude Code
[25:00] (1500.08s)
that augment Claude Code itself that
[25:02] (1502.08s)
make it kind of useful. There are quite
[25:04] (1504.00s)
a few more that I do that I think are
[25:06] (1506.24s)
really useful and valuable. Cloud code
[25:08] (1508.80s)
itself is a great environment, but with
[25:11] (1511.28s)
just a few of these little tips that you
[25:13] (1513.92s)
start to understand what it's trying to
[25:15] (1515.68s)
do for you or how to make it more useful
[25:17] (1517.92s)
or to kind of uh automate some of these
[25:20] (1520.08s)
things like the subtasks, those sorts of
[25:21] (1521.84s)
things are really really wonderful and
[25:23] (1523.76s)
allow you to start really broadly
[25:25] (1525.60s)
thinking how you can use this tool
[25:27] (1527.28s)
rather than it's just simply a place you
[25:29] (1529.36s)
ask a question and it creates you know
[25:32] (1532.00s)
some kind of calculator for you. All
[25:34] (1534.08s)
right, I hope any of these were
[25:36] (1536.24s)
interesting to you. I have a feeling you
[25:38] (1538.16s)
hadn't seen one or two of them. With any
[25:40] (1540.24s)
luck, I hope. Um, I had a lot of fun
[25:43] (1543.12s)
sharing them. If you like this kind of
[25:45] (1545.20s)
content, thanks for coming along this
[25:47] (1547.28s)
long. And thanks for being here. But
[25:50] (1550.24s)
subscribe. Please subscribe. I love
[25:52] (1552.72s)
putting this kind of stuff out. And that
[25:54] (1554.24s)
signal really matters. It improves the
[25:56] (1556.40s)
channel. It certainly gets it a little
[25:58] (1558.00s)
bit more lift, but it also lets me know
[26:00] (1560.00s)
what people are interested in. Give me
[26:01] (1561.92s)
comments, subscribe. It really does
[26:03] (1563.60s)
help. I appreciate it. Thanks for coming
[26:05] (1565.44s)
along for this one and I'll see you in
[26:07] (1567.12s)
the next