[00:00] (0.08s)
You've watched the Claude Code demos and
[00:02] (2.40s)
you've seen all the magic, but between
[00:05] (5.68s)
wow, that's cool and doing it yourself.
[00:09] (9.84s)
There's still a gap.
[00:11] (11.92s)
Well, today we close it from zero to
[00:14] (14.56s)
deployed app in one video. It's going to
[00:17] (17.76s)
be a great ride. Hang on. Okay, so I'm
[00:20] (20.16s)
talking to all the devs out there. I
[00:22] (22.32s)
know you guys don't really need this
[00:24] (24.40s)
first chapter. It's going to really be
[00:25] (25.92s)
about installation and getting
[00:27] (27.20s)
everything set up. in the meantime while
[00:29] (29.68s)
it's playing or feel free to skip it.
[00:32] (32.08s)
But look, I've got a great idea. How
[00:33] (33.76s)
about if you scroll down and answer a
[00:35] (35.60s)
question or two or just say go for it
[00:37] (37.92s)
for anybody that's saying getting
[00:39] (39.36s)
started now. I'm trying to build a
[00:41] (41.68s)
little community here of people that
[00:43] (43.12s)
support one another. I really want us to
[00:44] (44.64s)
lift each other up. This is an
[00:46] (46.08s)
opportunity for us to help each other
[00:48] (48.00s)
move forward in this new landscape. In
[00:50] (50.56s)
any case, you'll almost certainly want
[00:52] (52.72s)
to skip this first section. Everyone
[00:54] (54.48s)
else, let's get on it. So, the first
[00:56] (56.24s)
thing we'll need to do is open a
[00:57] (57.76s)
terminal window. And terminal in a Mac
[01:00] (60.88s)
and many other places, especially to
[01:03] (63.12s)
people that are new is always
[01:04] (64.96s)
frightening. In fact, I find it
[01:06] (66.64s)
frightening because I always worry about
[01:08] (68.00s)
typing the wrong command as well. So,
[01:09] (69.68s)
don't worry about it. We all feel
[01:11] (71.20s)
exactly the same way. But it's really
[01:13] (73.84s)
not that surprising. Think of it as a
[01:15] (75.44s)
chat with your computer rather than a
[01:18] (78.08s)
chat with chat GPT. So, it's really you
[01:20] (80.32s)
just got to say the right things. In
[01:21] (81.92s)
this case, what we're going to do is
[01:23] (83.44s)
figure out what we have to say to our
[01:24] (84.88s)
terminal window so that it'll install
[01:27] (87.28s)
Claude Code for us. Okay. If we look at
[01:29] (89.60s)
the Claude Code web page, you'll see
[01:32] (92.00s)
that there's this command down here that
[01:34] (94.08s)
you can just copy and put over into the
[01:36] (96.48s)
terminal window. Let's get real for a
[01:38] (98.24s)
second. If you're really nervous about
[01:40] (100.08s)
all of this, I'm going to have to skip
[01:42] (102.24s)
through some of this. If you type in a
[01:44] (104.72s)
command that doesn't quite work, you'll
[01:46] (106.40s)
get error messages. I would say copy
[01:48] (108.88s)
everything. Select everything from the
[01:50] (110.88s)
last thing you typed in and everything
[01:52] (112.64s)
below it and go to chat jp to get things
[01:54] (114.88s)
solved. All right, so let's move on from
[01:56] (116.80s)
there knowing all right we're fudging
[01:58] (118.80s)
just a little bit hoping that when you
[02:00] (120.40s)
type this command in it'll just work cuz
[02:02] (122.16s)
it might. If we just paste in the
[02:03] (123.68s)
command that we saw on the web page once
[02:05] (125.60s)
you hit enter it will go through the
[02:07] (127.28s)
steps of installing claude code and it
[02:10] (130.00s)
will give you something like this and be
[02:12] (132.00s)
ready for you to type in claude to get
[02:14] (134.16s)
started. Okay. So now that we have
[02:15] (135.60s)
claude installed we need to go about
[02:17] (137.84s)
executing it. What I will say is you
[02:20] (140.16s)
don't want to open claude in your home
[02:21] (141.84s)
directory which is the first place that
[02:23] (143.44s)
you usually land when you're in
[02:25] (145.04s)
terminal. So if you land in an area in
[02:28] (148.40s)
terminal and you're kind of nervous, you
[02:29] (149.92s)
can use finder to do this or explorer to
[02:32] (152.48s)
do this. What you really need is a
[02:34] (154.56s)
folder in here that you will put your
[02:36] (156.40s)
projects in. You can call it anything
[02:37] (157.92s)
you want. Mine is called code. So if I
[02:40] (160.32s)
change directory to code, then that will
[02:42] (162.56s)
take me into my code folder which has
[02:44] (164.96s)
all of the subfolders of different
[02:46] (166.80s)
projects. I advise putting something off
[02:49] (169.04s)
the root directory so that it's very
[02:50] (170.48s)
easy to get to. And now what we'll do is
[02:52] (172.40s)
make a directory here. Make diir. And so
[02:54] (174.96s)
this is just a simple command. Again, if
[02:56] (176.96s)
you don't know what these are, just go
[02:58] (178.56s)
ask your your AI make their TV joy. I
[03:02] (182.16s)
can move into TVJoy. And right now I am
[03:04] (184.48s)
inside of my home code TV Joy folder.
[03:07] (187.20s)
Okay, that's probably the last time I'm
[03:08] (188.64s)
going to go through the adnauseium
[03:10] (190.16s)
version of how to get things installed.
[03:12] (192.32s)
We are now in a place where we are ready
[03:14] (194.32s)
to get Claude going. So let's move on to
[03:17] (197.12s)
the next section which is orientation of
[03:19] (199.44s)
claude itself. Okay, first really
[03:21] (201.60s)
briefly let me answer a couple maybe
[03:24] (204.40s)
obvious questions here. What is claude
[03:26] (206.56s)
code? Why is it in terminal? What is
[03:29] (209.04s)
this CLI thing all about? And how does
[03:31] (211.12s)
it differ from some of the others? So
[03:33] (213.36s)
first what is claude code? That kind of
[03:35] (215.60s)
covers the first and the third which is
[03:37] (217.44s)
it is just a development environment.
[03:39] (219.92s)
It's just basically an agentic coding
[03:43] (223.04s)
system. In the old days, we would have
[03:44] (224.88s)
said an IDE or some kind of code editor
[03:47] (227.92s)
or something like that. So, we talked
[03:49] (229.36s)
about Cursor, GitHub, Copilot, Windsurf,
[03:52] (232.24s)
Bolt, and they're all really doing the
[03:54] (234.72s)
same thing. They're allowing you to use
[03:56] (236.80s)
natural language to help in the
[03:58] (238.96s)
development of software. And when I say
[04:00] (240.80s)
help, I really do mean working
[04:02] (242.64s)
cooperatively with the intelligent
[04:04] (244.64s)
system, the models that you're choosing
[04:06] (246.08s)
to work with. The last thing that I will
[04:07] (247.92s)
cover in this space is kind of what is a
[04:10] (250.32s)
CLI and do we need a subscription? Last
[04:13] (253.60s)
one, spoiler, yes, you need a
[04:15] (255.36s)
subscription. Claude code actually is
[04:18] (258.08s)
essentially free to use if you have a
[04:20] (260.00s)
$20 subscription with anthropic. And
[04:22] (262.16s)
then why in the CLI? Why didn't they
[04:24] (264.24s)
build an application? It is the same
[04:26] (266.16s)
thing as cursor sort of, but without the
[04:28] (268.72s)
application wrapped around it. They just
[04:30] (270.32s)
use the terminal as the application to
[04:32] (272.32s)
wrap around it. So, if you just imagine
[04:33] (273.92s)
it that way, you're just having to go
[04:35] (275.92s)
into terminal to start it instead of
[04:38] (278.08s)
being able to name it and start it that
[04:39] (279.84s)
way. And it has its own window. And I
[04:41] (281.36s)
think they built it that way because
[04:42] (282.48s)
they thought things were changing so
[04:44] (284.08s)
quickly that spending all the extra time
[04:46] (286.32s)
to get a UI built out perfectly would
[04:49] (289.44s)
really kind of be at cross purposes with
[04:52] (292.16s)
all the changes they saw coming. In any
[04:54] (294.72s)
case, this is the way it works. It also
[04:56] (296.72s)
makes it very easy to utilize it as a
[04:59] (299.36s)
CLI, which is what we call a command
[05:01] (301.92s)
line interface, which allows you from a
[05:04] (304.48s)
command line when you're in shell to be
[05:06] (306.00s)
able to just say claude and then a
[05:07] (307.92s)
message after it and Claude will run and
[05:11] (311.28s)
respond to that message and just give
[05:12] (312.80s)
you the response back. In fact, I think
[05:15] (315.20s)
we should take a look at that first just
[05:16] (316.96s)
for fun. Okay, so dropping back to
[05:19] (319.12s)
shell, we can use claw directly. This
[05:21] (321.92s)
maybe isn't the way that you can use it
[05:24] (324.48s)
yet if you haven't yet opened Claude.
[05:26] (326.40s)
So, we'll see that in a moment. But if I
[05:28] (328.32s)
call Claude here at the command line,
[05:30] (330.32s)
it's actually taking everything after
[05:31] (331.92s)
that Claude word, launching Claude
[05:34] (334.32s)
completely in agent mode and sending
[05:36] (336.56s)
that prompt onto the the Sonnet or Opus
[05:40] (340.16s)
uh model depending upon your
[05:41] (341.84s)
subscription and then returning whatever
[05:43] (343.84s)
response it gets. So, Claude can be used
[05:45] (345.84s)
in a way that many of those other
[05:47] (347.28s)
systems that are full Windows systems
[05:48] (348.88s)
can't be used. All right, I'm going to
[05:50] (350.64s)
have to rush through a lot of things
[05:52] (352.08s)
here. So, let's dive into Claude very
[05:54] (354.32s)
quickly so that we can see the moving
[05:56] (356.56s)
parts of Claude itself. Okay, so here we
[05:59] (359.04s)
are in Claude. When you launch Claude,
[06:00] (360.96s)
it will give you some information of
[06:03] (363.20s)
tips or tricks, those kinds of things.
[06:05] (365.36s)
But once you're sitting here, this is
[06:06] (366.96s)
the entire application. So, you're
[06:08] (368.64s)
looking at the application. Yours may
[06:10] (370.32s)
look a little bit different. Mine has
[06:11] (371.84s)
been launched a bunch of times. There is
[06:13] (373.60s)
a question mark down here. It says
[06:15] (375.20s)
question mark for shortcuts. So if we
[06:17] (377.12s)
hit that, you'll see it pop up a whole
[06:18] (378.88s)
bunch of shortcuts that are just
[06:20] (380.48s)
confusing to a newcomer. So I would hit
[06:23] (383.04s)
question mark. Again, there is another
[06:24] (384.72s)
one which is slash. The slash commands
[06:27] (387.12s)
are quite useful and it might really
[06:28] (388.96s)
help you out of jam if you get stuck.
[06:30] (390.64s)
The one that actually you probably will
[06:33] (393.04s)
find quite useful is slashexit. That's
[06:34] (394.96s)
how you quit the application. There are
[06:36] (396.72s)
other ways. This is the easiest way to
[06:38] (398.72s)
to learn. Okay, there's others in here.
[06:41] (401.44s)
You can resume a conversation and I want
[06:43] (403.76s)
to say that very clearly. You don't have
[06:45] (405.84s)
to be delicate about Claude. Claude is
[06:48] (408.16s)
memorizing everything you do. While it's
[06:50] (410.48s)
running, you'd like to leave it running.
[06:52] (412.24s)
So, if it's in the middle of thinking,
[06:54] (414.16s)
let it finish thinking before you hit
[06:55] (415.76s)
/exit. But when you come back, you can
[06:58] (418.48s)
just run this resume command, and it'll
[07:00] (420.48s)
give you a list of previous
[07:01] (421.68s)
conversations that you can just continue
[07:03] (423.36s)
with. So, you don't have to worry about
[07:04] (424.72s)
losing all of that context. A lot of
[07:06] (426.56s)
people are nervous in that way. That's
[07:08] (428.32s)
no big deal when you do have a lot of
[07:10] (430.08s)
context. So, if we had said hello here,
[07:12] (432.16s)
it's just building up context. And if I
[07:14] (434.80s)
said hello and hello again, then it's
[07:17] (437.20s)
going to send that to the model, respond
[07:19] (439.04s)
twice. How many times have I said hello?
[07:21] (441.36s)
It's going to go through all of that
[07:23] (443.12s)
context just like chatbt is going back
[07:25] (445.52s)
and forth with the model. So this
[07:27] (447.60s)
context here will get big, big, big.
[07:30] (450.08s)
You're in a coding environment. There's
[07:31] (451.84s)
a lot going back and forth. You don't
[07:33] (453.60s)
want it that size because everything
[07:35] (455.20s)
that's being sent is what the model's
[07:36] (456.80s)
thinking about to solve the question
[07:38] (458.16s)
that you've asked. Hey, I want you to
[07:39] (459.76s)
turn that button red. But if there's
[07:41] (461.92s)
thousands of lines of context, it's got
[07:44] (464.24s)
to go, do I know exactly which button
[07:46] (466.48s)
they're talking about? Maybe it was the
[07:47] (467.84s)
previous button they were talking about,
[07:48] (468.96s)
and it's got to work through that. So,
[07:50] (470.56s)
what you want to use, and this is a very
[07:52] (472.24s)
important slash command, is clear. And
[07:54] (474.00s)
that's the last one I'll go through
[07:55] (475.52s)
here. Clear just simply is new chat on
[07:58] (478.56s)
one of the chat windows for chat GPT or
[08:00] (480.80s)
something like that. So, this just
[08:02] (482.16s)
clears the context and gets you back
[08:04] (484.00s)
here. Okay, so that's pretty much the
[08:06] (486.24s)
overview of how this works. Now, if
[08:08] (488.72s)
that's all there is to it, how the heck
[08:10] (490.16s)
are we supposed to get coding? Okay, one
[08:12] (492.08s)
more set of keystrokes here. If you hold
[08:14] (494.24s)
down shift and tab, you will see this
[08:17] (497.44s)
area down here. I'm hitting it again and
[08:19] (499.12s)
again, you will see that this area down
[08:21] (501.44s)
here changes mode. And this is really
[08:23] (503.52s)
which mode you're in. You're typically
[08:25] (505.44s)
in the default mode, which it will ask
[08:27] (507.52s)
you for approval to do things. There is
[08:29] (509.60s)
a way to auto approve edits. Now, this
[08:32] (512.80s)
is just edits when it's editing files,
[08:35] (515.12s)
changing files are those will be auto
[08:37] (517.20s)
approved and you won't have to say yes
[08:38] (518.64s)
to each different type of file being
[08:40] (520.40s)
edited. Then there's planning mode and
[08:42] (522.32s)
planning mode basically will not write
[08:44] (524.64s)
anything. It doesn't write to files, but
[08:46] (526.64s)
it will return big plans to us. And
[08:48] (528.80s)
planning is what we're here to talk
[08:50] (530.64s)
about. So, planning is a very important
[08:52] (532.96s)
part of this. Other videos that I have,
[08:55] (535.20s)
I I talk a little bit more about this. I
[08:57] (537.28s)
plan on putting a whole video together
[08:59] (539.04s)
about planning because it is that
[09:01] (541.20s)
important. But here is the one thing
[09:02] (542.88s)
that I will tell you as a newcomer to
[09:04] (544.72s)
this kind of stuff. These models are
[09:07] (547.04s)
incredibly smart and very capable
[09:09] (549.68s)
programmers. They can't do everything.
[09:12] (552.00s)
And one of the things that they
[09:13] (553.52s)
absolutely fall on their face with and a
[09:16] (556.16s)
lot of senior devs kind of like poking
[09:18] (558.64s)
them in the eye about is they lose the
[09:21] (561.68s)
understanding of what's going on. They
[09:23] (563.60s)
don't seem to connect the dots all the
[09:25] (565.28s)
time for the why things are occurring.
[09:28] (568.24s)
They know how to do the how. They know
[09:30] (570.96s)
how to write the code and make the
[09:32] (572.88s)
different parts work together generally
[09:34] (574.72s)
quite well. What they don't understand
[09:36] (576.64s)
and what they need from you since you're
[09:38] (578.32s)
a pair programmer here since you're in
[09:40] (580.40s)
cooperation with this model, you have to
[09:42] (582.48s)
bring the what. Your whole job here is
[09:44] (584.96s)
to bring the what. And you can't just
[09:46] (586.88s)
say, I want an alarm clock. It will give
[09:50] (590.40s)
you anything. It's going to have to
[09:51] (591.92s)
dream up all of the rest of the what. If
[09:54] (594.00s)
your what was I want an alarm clock that
[09:56] (596.32s)
runs in a web browser and gets started
[09:58] (598.64s)
when you click a button and has snooze
[10:00] (600.64s)
and all of those other what parts you
[10:03] (603.04s)
need to send in and that's really
[10:04] (604.88s)
important. So I'm going to start us with
[10:06] (606.40s)
a prompt that gets us on the road of
[10:08] (608.24s)
writing an application but this is not
[10:10] (610.56s)
the plan. So remember we're in planning
[10:12] (612.88s)
mode and I'm going to paste in a prompt
[10:15] (615.28s)
here that we can take a look at after I
[10:17] (617.52s)
submit it. All right. So, TV Show
[10:19] (619.36s)
Explorer is a lightweight web app that
[10:20] (620.80s)
lets users discover series at a glance
[10:22] (622.56s)
and deep dive when curiosity strikes.
[10:24] (624.48s)
The landing screen features a sleek hero
[10:26] (626.48s)
search bar, plus two dynamic scroll
[10:28] (628.64s)
snappable carousel, one surfacing TMDB's
[10:31] (631.52s)
trending today posters, the other its
[10:33] (633.12s)
current most popular lineup, inviting
[10:34] (634.80s)
instant exploration beyond a plain grid.
[10:37] (637.28s)
Selecting any show opens a rich detailed
[10:38] (638.96s)
view packed with ratings, synopsis,
[10:40] (640.88s)
cast, season, streaming providers, and
[10:43] (643.60s)
similar show suggestions, giving
[10:45] (645.12s)
newcomers plenty to click without
[10:46] (646.56s)
feeling overwhelmed.
[10:48] (648.24s)
Okay, this is enormous. If we pull this
[10:50] (650.08s)
off, bully for us. But if we get
[10:52] (652.48s)
anywhere close, I'll be super happy as
[10:55] (655.12s)
we really don't want this video to last
[10:56] (656.96s)
all day long. But I am describing
[10:59] (659.36s)
basically what I'm interested in having.
[11:02] (662.40s)
I want a system that does these things,
[11:05] (665.20s)
right? That's what's the important part.
[11:07] (667.20s)
The the how it is done is up to the
[11:10] (670.96s)
system itself, the intelligence itself.
[11:12] (672.72s)
So let's submit this in planning mode,
[11:14] (674.64s)
if you recall, and see what comes back
[11:16] (676.56s)
from this. And what it comes back with
[11:19] (679.12s)
is a better version of a plan. Whether
[11:22] (682.08s)
or not it's a perfect plan, it's almost
[11:24] (684.24s)
certainly not. It's really important for
[11:26] (686.16s)
me to say there is no perfect here. So
[11:28] (688.16s)
don't try to get this absolutely
[11:29] (689.68s)
perfect. No matter how well you describe
[11:31] (691.68s)
each one of these things, it will miss
[11:33] (693.60s)
some of them. Just like any engineer
[11:35] (695.68s)
would miss some detail inside of a very
[11:38] (698.00s)
detailed plan. Now, you don't
[11:39] (699.92s)
necessarily have to make sense of
[11:41] (701.84s)
everything that they're doing here. You
[11:43] (703.36s)
don't have to look at it and understand
[11:44] (704.64s)
what Vit is, what Tailwind is, the TMDB
[11:48] (708.08s)
API. You don't necessarily need to know
[11:50] (710.08s)
those moving parts, but you can see that
[11:52] (712.08s)
it's saying for the front end, it's
[11:54] (714.00s)
going to use a couple things. For
[11:55] (715.60s)
styling, it's going to use a couple
[11:57] (717.44s)
things. For state management, it will
[11:59] (719.36s)
use something else. Okay? And this is
[12:01] (721.44s)
really your road. Don't completely skip
[12:04] (724.00s)
this step. These are the things that
[12:05] (725.84s)
help you become a little bit of aware of
[12:08] (728.48s)
the different moving parts of an
[12:10] (730.00s)
application and what's important. And
[12:11] (731.84s)
these are really important aspects,
[12:14] (734.08s)
right? So they also give you a full
[12:15] (735.76s)
breakdown of the project or the files
[12:17] (737.68s)
that will be in this project and the
[12:19] (739.12s)
structure that they'll follow. So let's
[12:20] (740.88s)
go forward with yes and autoaccept
[12:22] (742.88s)
edits. And so now we're on our way. And
[12:25] (745.04s)
you can see it's changed us to that
[12:27] (747.12s)
purple mode of autoaccept edits. So it's
[12:29] (749.84s)
not going to tell us about all of those
[12:31] (751.52s)
files that it listed out. It would have
[12:33] (753.28s)
said, are you sure you want me to write
[12:34] (754.56s)
this file? Are you sure you want me to
[12:35] (755.92s)
write that file? I'm about to do this.
[12:37] (757.44s)
Do you want me to do that? So some
[12:39] (759.12s)
things it will auto accept. other things
[12:41] (761.04s)
it will come back and ask permissions.
[12:43] (763.44s)
Okay, just for completeness I will show
[12:45] (765.92s)
you. I've used TMDB many times so I'm
[12:48] (768.56s)
fully aware of this and I don't have to
[12:50] (770.08s)
wait for the model to tell me this. If
[12:51] (771.76s)
you're building along or anything like
[12:53] (773.36s)
that, you will need a TMDB API key.
[12:55] (775.92s)
That's a very common thing. You'll need
[12:57] (777.68s)
to go out to the movieb.org
[13:00] (780.88s)
and that will be tmdb set up an account.
[13:04] (784.32s)
It's free. Then you can come in and ask
[13:06] (786.64s)
for an API key. That little key is what
[13:08] (788.80s)
we're going to use in the rest of the
[13:10] (790.64s)
application. But it is important and I
[13:13] (793.12s)
just wanted to show if you're building
[13:14] (794.40s)
this along. I didn't get this for free.
[13:16] (796.56s)
Okay. It's also worth saying that Cloud
[13:19] (799.12s)
Code is just churning away. It's working
[13:20] (800.96s)
through this checklist and you can see
[13:22] (802.56s)
it's a very nice progression that you
[13:24] (804.32s)
can see where it is in building the
[13:26] (806.64s)
files. Okay. So, it says it completed.
[13:29] (809.44s)
Excellent. So, you can see that it went
[13:31] (811.28s)
through. It checked everything off of
[13:32] (812.96s)
its list and it says, "Okay, here's
[13:35] (815.12s)
everything that I just finished." It
[13:36] (816.88s)
also has instructions in here to run the
[13:39] (819.12s)
application. Set up your D TMDB API key
[13:42] (822.24s)
like I mentioned. Create an ENV file.
[13:44] (824.80s)
They have an ENV example that you just
[13:46] (826.80s)
copy, take off the example, and that
[13:49] (829.92s)
will be the the place where you put your
[13:51] (831.76s)
key. Um, start the development server.
[13:54] (834.24s)
And so, this one's an important one. You
[13:56] (836.32s)
can always just ask Claude again. Claude
[13:58] (838.88s)
knows how to do this. So, if I just
[14:00] (840.48s)
said, how do I start the the server or
[14:02] (842.64s)
how do I start this? How do I run it?
[14:04] (844.40s)
How do I see it? It'll get you there.
[14:05] (845.92s)
either way, but it does tell me when it
[14:07] (847.92s)
completed npm rundev. And this is a very
[14:10] (850.72s)
common development running process kind
[14:13] (853.84s)
of command. Basically, we want to run
[14:16] (856.08s)
this command, npm rundev. But our
[14:18] (858.40s)
terminal window that we're running in is
[14:20] (860.48s)
filled up with claude. You don't want to
[14:22] (862.08s)
have to keep leaving Claude and coming
[14:23] (863.84s)
back in because servers generally need
[14:26] (866.48s)
to stay running. So, what we're going to
[14:28] (868.48s)
need to do, and I'm using warp, I can
[14:30] (870.40s)
just create a new tab. You're probably
[14:32] (872.08s)
going to have to hit command N to create
[14:33] (873.76s)
a new window. And that window is going
[14:35] (875.76s)
to be the place in the same folder. So
[14:38] (878.32s)
you have to go back to that directory.
[14:40] (880.64s)
If the new window didn't open in the
[14:43] (883.04s)
project folder, you'll have to go in
[14:44] (884.96s)
there and do npm rundev in that
[14:47] (887.84s)
location. So when I run this, what I see
[14:50] (890.96s)
is a URL that I can click on and that
[14:53] (893.52s)
will launch the browser to this URL. All
[14:56] (896.40s)
right. And at this point when I launch
[14:58] (898.00s)
it, I have a problem. Not surprising. So
[15:01] (901.36s)
I just take the entire problem. I will
[15:03] (903.76s)
come back to Claude, give him that
[15:05] (905.60s)
entire problem, and basically make it
[15:07] (907.68s)
his fault. I'm out. Okay, so Claude went
[15:10] (910.00s)
about fixing that. But if I come back
[15:12] (912.48s)
here and I reload, I still have this
[15:14] (914.96s)
problem. So here is where the complexity
[15:17] (917.12s)
lies. Claude changed something in a file
[15:19] (919.92s)
that is read when things start. This
[15:22] (922.40s)
doesn't happen terribly often, and you
[15:24] (924.24s)
won't know when that's the case.
[15:26] (926.00s)
Sometimes it will tell you, "Try
[15:27] (927.76s)
refreshing your browser or restarting
[15:29] (929.68s)
the dev server if needed." So in this
[15:32] (932.32s)
case, because of the kind of file that
[15:34] (934.32s)
we changed, I might need to come over to
[15:36] (936.56s)
my terminal that has my server running.
[15:38] (938.72s)
Hit control C. If you recall that C that
[15:41] (941.68s)
we talked about earlier, that will
[15:43] (943.52s)
cancel or close this server. So now
[15:46] (946.08s)
we're not running that server. And if I
[15:48] (948.32s)
reload, you'll get this. And then I can
[15:50] (950.56s)
just hit the up arrow key, which will
[15:52] (952.48s)
rerun the last command generally. And
[15:54] (954.72s)
then come back. And now we're running.
[15:56] (956.72s)
Maybe not successfully, but now we're
[15:58] (958.56s)
off. Okay. Two things to do when
[16:00] (960.32s)
something like this happens. I come back
[16:02] (962.24s)
and check the server to see if the
[16:03] (963.84s)
server had an error. Server seems fine.
[16:06] (966.08s)
Doesn't have one of these big error
[16:07] (967.52s)
messages. Second, I will rightclick and
[16:10] (970.00s)
hit inspect, which takes me to the tools
[16:12] (972.40s)
where there is a console. I'm going to
[16:14] (974.08s)
leave that as that. But basically, we're
[16:16] (976.24s)
trying to see the output of the
[16:18] (978.24s)
application running in the browser. And
[16:20] (980.32s)
that says this. And once again, I will
[16:22] (982.64s)
take this come back to Claude and say, I
[16:25] (985.44s)
don't know what's going on. I'm going to
[16:26] (986.80s)
give you this error message. And more
[16:28] (988.88s)
than likely most of the changes that the
[16:31] (991.60s)
system has to make now will
[16:33] (993.44s)
automatically refresh in this browser.
[16:36] (996.24s)
So very often I will leave these two
[16:38] (998.72s)
next to one another or related to one
[16:40] (1000.64s)
another so that we can see as this one
[16:42] (1002.56s)
is making changes, it's updating things
[16:44] (1004.96s)
and the server over here is smart enough
[16:47] (1007.04s)
to watch for changes and reload the
[16:49] (1009.12s)
server when it sees them. And okay, so
[16:51] (1011.76s)
it did say try stopping the dev server
[16:53] (1013.76s)
and restarting it. So once again, Claude
[16:56] (1016.00s)
is trying to instruct me of everything
[16:57] (1017.28s)
that I need to know. But I come and look
[16:59] (1019.28s)
and I say, "Yeah, okay. I'm going to
[17:01] (1021.60s)
close that for now and say maybe it
[17:04] (1024.00s)
missed the mark. I'm pretty sure this
[17:05] (1025.60s)
isn't what it meant." So here's what I'm
[17:07] (1027.76s)
going to do. I'm going to take a
[17:09] (1029.20s)
screenshot and come back over to Claw
[17:10] (1030.96s)
Code and paste that screenshot in right
[17:13] (1033.04s)
there and say, "Yikes, this is ugly."
[17:15] (1035.52s)
And it's saying, "Oh, the styling is not
[17:17] (1037.20s)
being applied properly." So that makes a
[17:18] (1038.96s)
lot of sense that this isn't the way
[17:20] (1040.48s)
that it designed it, but oh, it has an
[17:22] (1042.56s)
actual problem with the stylesheet that
[17:24] (1044.64s)
it was trying to apply underneath it. So
[17:27] (1047.20s)
let me go check and see how I'm applying
[17:29] (1049.52s)
creating stylesheets and things of that
[17:31] (1051.28s)
nature. And as you can see, it's
[17:32] (1052.72s)
flipping around in the background as he
[17:34] (1054.72s)
makes changes. And now the stylesheet is
[17:37] (1057.12s)
starting to be applied. Uh I think
[17:39] (1059.44s)
hopefully a little bit more gracefully
[17:40] (1060.88s)
than that last time. Oh, okay. In the
[17:42] (1062.88s)
middle of its changes, I wanted to show
[17:44] (1064.32s)
you this. It's been writing lots of
[17:46] (1066.08s)
files and doing lots of things, but now
[17:48] (1068.24s)
it needs to run a command that it hasn't
[17:50] (1070.24s)
seen yet. And I'm going to say instead
[17:52] (1072.16s)
of just yes once, I'm going to say yes
[17:54] (1074.16s)
and don't ask again. And what it does is
[17:56] (1076.40s)
it writes that in a local file that is
[17:58] (1078.72s)
its own settings file for this project.
[18:00] (1080.80s)
It's not global. It's just for this
[18:02] (1082.72s)
project. So it's very safe to say as you
[18:04] (1084.80s)
move in and get better permissions in a
[18:06] (1086.56s)
given project. that will enhance your
[18:08] (1088.40s)
ability to kind of more easily
[18:10] (1090.24s)
gracefully make changes inside of a
[18:11] (1091.84s)
project, but it won't necessarily solve
[18:13] (1093.68s)
other projects. Okay. And it finished.
[18:15] (1095.84s)
And in fact, problem was that it needed
[18:18] (1098.16s)
to downgrade from Tailwind version 4 to
[18:21] (1101.92s)
version 3 because it has some breaking
[18:24] (1104.00s)
changes that it didn't like. I don't
[18:25] (1105.68s)
know what those changes are, but once it
[18:27] (1107.52s)
did that, everything was happy again.
[18:29] (1109.44s)
So, this is the application that it
[18:31] (1111.20s)
built and designed the first time out if
[18:33] (1113.36s)
it wasn't for those two problems that we
[18:35] (1115.20s)
ran into. Really, frankly, this is
[18:37] (1117.28s)
pretty great. What do you think's going
[18:38] (1118.56s)
to happen if we click on one of these?
[18:42] (1122.96s)
Come on.
[18:47] (1127.52s)
Come on.
[18:51] (1131.12s)
No cast. One season, no streaming
[18:54] (1134.08s)
information. All right, let's see. How
[18:56] (1136.32s)
about Rick and Morty? They have a cast.
[19:00] (1140.24s)
Oh, this looks great. Oh my god,
[19:05] (1145.04s)
boy. Hi, Agentic Coding. I love you. All
[19:08] (1148.72s)
right, so we now have an application.
[19:11] (1151.20s)
Let's see. One of my favorite shows. If
[19:13] (1153.76s)
I go to I zombombie. Oh, score. Full
[19:16] (1156.40s)
score. Thank you.
[19:19] (1159.04s)
I am continually blown away by this
[19:21] (1161.36s)
stuff. If we look at what's in this, you
[19:23] (1163.92s)
can see how long this history is. This
[19:26] (1166.08s)
is from the initial request after all
[19:28] (1168.56s)
that plan, everything dropped down, all
[19:30] (1170.56s)
of the changes. This is the context. And
[19:32] (1172.64s)
this is what I was talking about.
[19:33] (1173.68s)
There's an enormous amount of context
[19:35] (1175.44s)
here. So if I was to say I really want
[19:37] (1177.92s)
this ended to be a different color, it
[19:40] (1180.16s)
would have to be aware of everything
[19:41] (1181.60s)
else that it's changed here and guess
[19:43] (1183.76s)
that I'm talking about the ended that's
[19:45] (1185.28s)
happens to be on the screen, not
[19:46] (1186.64s)
something that it had written previously
[19:48] (1188.08s)
in this context. So all along after it
[19:50] (1190.88s)
finished and it got to a successful
[19:53] (1193.28s)
place that first buildout, I should have
[19:55] (1195.36s)
said clear. Now I have no context and
[19:57] (1197.84s)
the conversations that I have with it
[19:59] (1199.60s)
are going to be far more successful.
[20:01] (1201.52s)
Okay, so now that we have the full
[20:03] (1203.60s)
picture of how to develop an
[20:04] (1204.80s)
application, we have one problem and
[20:06] (1206.80s)
that problem is it's only on our
[20:08] (1208.64s)
desktop. Let's solve that by a little
[20:11] (1211.44s)
bit of magic. We're about to install
[20:14] (1214.24s)
Git. Now, you may already have Git on
[20:16] (1216.72s)
your system. Fantastic if you do. I am
[20:19] (1219.28s)
not going to go through the steps of
[20:20] (1220.64s)
installing Git. So this is one of those
[20:23] (1223.04s)
engineering moments of if you drop down
[20:25] (1225.44s)
into shell and you can't run these
[20:27] (1227.36s)
commands that we're about to talk about,
[20:29] (1229.36s)
I'm going to advise frankly that you ask
[20:31] (1231.84s)
Claude how to do it. Claude can
[20:33] (1233.84s)
definitely help in this case. The next
[20:36] (1236.16s)
thing that happens on top of that is
[20:38] (1238.08s)
GitHub. Now Git and GitHub, two entirely
[20:42] (1242.32s)
separate things. They sound like they're
[20:44] (1244.00s)
the exact same thing. Git is the local
[20:46] (1246.72s)
thing that saves versions. That's just a
[20:49] (1249.60s)
local piece of software that everybody
[20:51] (1251.20s)
can use that saves versions of your
[20:53] (1253.04s)
software. Once you push it up to the
[20:55] (1255.68s)
cloud so that you can do other things
[20:57] (1257.12s)
with it, other people can see it. That's
[20:59] (1259.04s)
where GitHub comes into play. You
[21:00] (1260.64s)
usually will push it to GitHub. There's
[21:02] (1262.72s)
other places you can actually push it
[21:04] (1264.00s)
to. GitHub's not the only place. So,
[21:06] (1266.48s)
that's just an extra place. Now, you
[21:08] (1268.24s)
have to create a profile up there if you
[21:09] (1269.76s)
don't have one to follow along with what
[21:11] (1271.76s)
I'm going to do next. Also, a very
[21:14] (1274.32s)
solved problem. I would set yourself a
[21:16] (1276.32s)
task to do it. you you'll be done in 15
[21:18] (1278.24s)
minutes and then we will need to push
[21:20] (1280.56s)
our files up into a GitHub repository
[21:23] (1283.84s)
and then take that last step which is
[21:26] (1286.64s)
not going to be a developer card
[21:28] (1288.08s)
problem. I'll let you solve this one on
[21:29] (1289.68s)
your own but it's going to be using a
[21:31] (1291.28s)
third party service that will deploy it
[21:33] (1293.84s)
for us on the internet but that is so
[21:35] (1295.76s)
simple that I'm definitely going to show
[21:37] (1297.12s)
that. So let's pretend like you have git
[21:40] (1300.08s)
on your system. Wink.
[21:43] (1303.36s)
Okay, so here we are. We love our
[21:45] (1305.68s)
application. We think everybody should
[21:47] (1307.84s)
see it. Fantastic. So, what we want to
[21:49] (1309.92s)
say here to Claude is, "Hey Claude, turn
[21:52] (1312.88s)
this into a Git repository and check
[21:54] (1314.96s)
everything in." That's it. And really,
[21:56] (1316.80s)
that took almost no time at all.
[21:58] (1318.88s)
Fantastic. This is all committed and
[22:00] (1320.96s)
ready to go or just about. So, what we
[22:03] (1323.92s)
have is a local version controlled
[22:06] (1326.48s)
system. Everything's committed. If I do
[22:08] (1328.56s)
anything else, I can roll back to this
[22:10] (1330.16s)
point. That's the idea of a commit. I
[22:11] (1331.76s)
won't go any further about that. either
[22:13] (1333.52s)
go check your local AI about that or
[22:16] (1336.00s)
check some of my previous videos. But
[22:18] (1338.16s)
the next thing we need to do is we need
[22:19] (1339.68s)
to get this thing into GitHub, a cloud
[22:21] (1341.92s)
version of Git. It's just kind of a
[22:23] (1343.44s)
holder of different Git repositories.
[22:25] (1345.92s)
So, there's a bunch of ways to do this.
[22:27] (1347.28s)
If you don't have a Git username or
[22:28] (1348.96s)
profile, there's a little bit of a
[22:30] (1350.64s)
challenge. I think I talked about that.
[22:32] (1352.16s)
So, you might have to pay attention on
[22:34] (1354.16s)
how to get Git into the GitHub. Pardon
[22:37] (1357.84s)
my southern. Okay, so that's what we're
[22:40] (1360.00s)
going to do, but we're going to pretend.
[22:41] (1361.84s)
Congratulations, you have a GitHub
[22:43] (1363.84s)
account. Wink. Okay, two versions of
[22:46] (1366.80s)
this. One, you go the traditional route.
[22:48] (1368.96s)
You go to GitHub yourself. You create a
[22:50] (1370.80s)
new repository with the name of the
[22:52] (1372.40s)
application and it will give you
[22:54] (1374.40s)
terrific instructions to check
[22:56] (1376.16s)
everything in and push it up. That's
[22:57] (1377.68s)
easy. Do it that way. I'm going to try
[22:59] (1379.36s)
it here with Claude. Hey Claude, can you
[23:01] (1381.52s)
create a new uh private repo on GitHub
[23:05] (1385.12s)
for me and push all of these files up
[23:07] (1387.36s)
there? Okay. I will say my transcription
[23:10] (1390.72s)
software Super Whisper that I used
[23:12] (1392.72s)
actually messed up where I asked it to
[23:14] (1394.80s)
make a private can you create a new uh
[23:17] (1397.92s)
on GitHub. So it made it public.
[23:20] (1400.56s)
Perfectly fine. Feel free to go look at
[23:22] (1402.48s)
this. You can pull this project yourself
[23:24] (1404.08s)
to get where we are as a starting point.
[23:26] (1406.32s)
And so this is the entire thing that we
[23:28] (1408.56s)
have. It's just sitting here waiting to
[23:30] (1410.56s)
be used. Great. We're on literally the
[23:33] (1413.04s)
final step. Okay. There's a few
[23:34] (1414.88s)
services. All of them allow with an
[23:37] (1417.44s)
account and a free account by the way.
[23:39] (1419.52s)
All of them will host your applications
[23:41] (1421.92s)
for free up to a certain number of them.
[23:44] (1424.24s)
They will stop being free after they
[23:46] (1426.32s)
will pull them down. I think they won't
[23:48] (1428.32s)
allow a certain amount of traffic into
[23:49] (1429.68s)
them. But as long as you're using this
[23:51] (1431.12s)
for yourself and just a couple friends
[23:52] (1432.72s)
or something like that, this is a really
[23:54] (1434.56s)
great way to get started. I use a
[23:56] (1436.40s)
service called Railway. Netlfi is a very
[23:59] (1439.28s)
popular one. Another one that's really
[24:00] (1440.96s)
wellnown is Versel, but there's just a
[24:03] (1443.92s)
ton of these. We'll start with Netlefi
[24:06] (1446.24s)
here. So, let me log in. And once we're
[24:08] (1448.24s)
logged in, we're just going to hit the
[24:09] (1449.76s)
add new project. And we're going to
[24:11] (1451.68s)
import an existing project from GitHub.
[24:14] (1454.80s)
This is going to be pretty
[24:15] (1455.68s)
straightforward. It's going to go out
[24:17] (1457.28s)
and say, is Netlefi authorized to read
[24:20] (1460.08s)
things in your GitHub? Yep. And TVJ is
[24:23] (1463.20s)
what we just pushed up. We're going to
[24:24] (1464.80s)
select it. We'll call it TVJoy. It will
[24:27] (1467.60s)
watch for changes in your repository,
[24:29] (1469.76s)
which is fascinating. This is called
[24:31] (1471.68s)
continuous delivery. So this is the
[24:33] (1473.68s)
concept of as something changes in
[24:35] (1475.76s)
GitHub the next time you push your files
[24:37] (1477.68s)
up using Claude like we just did.
[24:39] (1479.44s)
They'll go into this branch presumably
[24:41] (1481.92s)
this system is watching that branch and
[24:44] (1484.48s)
we'll see that there's a change, pull
[24:46] (1486.32s)
all of that information and deploy the
[24:48] (1488.16s)
new version. You'll never have to come
[24:49] (1489.92s)
back here and you'll always be on the
[24:51] (1491.76s)
newest version assuming that everything
[24:53] (1493.36s)
always works out, meaning you didn't
[24:54] (1494.88s)
have errors in your code when you pushed
[24:56] (1496.32s)
them up. But heck, that's Cloud's fault.
[24:58] (1498.00s)
All right. So, there's one last thing
[24:59] (1499.76s)
here that's kind of important because
[25:01] (1501.76s)
we're using an API. I am going to have
[25:04] (1504.16s)
to add an environment variable. And if
[25:06] (1506.80s)
you remember, I shared early on that ENV
[25:09] (1509.52s)
file, which is where we had to put our
[25:11] (1511.36s)
environment key. The key is on the left
[25:13] (1513.60s)
and the value is on the right. I'm going
[25:15] (1515.68s)
to put the key here and the value here.
[25:17] (1517.92s)
So, I'm just copying and pasting them
[25:20] (1520.08s)
from the ENV file that I have that works
[25:22] (1522.32s)
when I run locally. That env file is not
[25:25] (1525.28s)
pushed up into GitHub. So this system
[25:28] (1528.00s)
has no understanding of that. You
[25:29] (1529.44s)
wouldn't want to share your files, your
[25:31] (1531.28s)
your keys in that way. We'll go through
[25:33] (1533.36s)
security some other time. Okay. And now
[25:35] (1535.60s)
let's deploy TVJoy project deploy in
[25:38] (1538.48s)
progress. So it takes a minute and it's
[25:40] (1540.80s)
working on deploying it. Setting up
[25:42] (1542.72s)
custom domains, pushing everything. I'll
[25:44] (1544.72s)
be back in just a second. Okay. And
[25:46] (1546.96s)
before I could finish that sentence,
[25:48] (1548.56s)
this shows up down here which is the
[25:50] (1550.40s)
deployment. If we go and look at that
[25:52] (1552.48s)
deployment, here's our application on
[25:54] (1554.64s)
the internet. Wow. That's it. It was
[25:56] (1556.88s)
that fast. It was that easy. And it's
[25:59] (1559.12s)
not complete until we show I zombie
[26:01] (1561.20s)
again. Love you, Liv. All right, so this
[26:03] (1563.20s)
was kind of awesome. Maybe it went a
[26:04] (1564.88s)
little bit longer than expected. Let's
[26:06] (1566.32s)
pull out of here. That is it. Soup to
[26:08] (1568.40s)
nuts from zero all the way to deploying
[26:11] (1571.60s)
an application that uses a public API
[26:14] (1574.40s)
that you have to use a key for. That is
[26:16] (1576.96s)
a huge number of steps. If you take this
[26:19] (1579.28s)
project on, please let me know in the
[26:21] (1581.20s)
comments below because I would love to
[26:22] (1582.56s)
give you some applause. And if you have
[26:24] (1584.32s)
any open questions at all, drop them in
[26:26] (1586.32s)
the comments. Hopefully, some of those
[26:27] (1587.92s)
devs will still be around to kind of
[26:30] (1590.08s)
answer some of the questions or at least
[26:31] (1591.60s)
root you on as you move away from just
[26:34] (1594.24s)
watching these things and move all the
[26:36] (1596.24s)
way into building and deploying your own
[26:38] (1598.32s)
applications. I can't wait to see what
[26:39] (1599.68s)
you come up with. I know this was a long
[26:41] (1601.84s)
one, but I hope it really brought some
[26:43] (1603.36s)
value. Thanks for coming along for the
[26:44] (1604.96s)
ride on this one and I'll see you in the