[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.