0:01 Cloud Code has been allowing me to build
0:03 things that used to take me hours in
0:05 just minutes. So that's exactly what I'm
0:06 going to be teaching you guys today.
0:08 Even if you don't know how to code and
0:09 even if you've never touched an IDE
0:11 before. IDE stands for integrated
0:12 development environment. But if you
0:14 didn't know that, it's still completely
0:16 fine. It's crazy how fast the technology
0:18 is evolving every single day. What used
0:19 to take people this long with manual
0:21 code was significantly reduced when
0:22 editing came out because we could drag
0:24 and drop nodes and build workflows that
0:26 way. And now that has once again been
0:27 significantly reduced with the release
0:29 of things like cloud code and
0:30 anti-gravity. Now I'm not out here
0:32 saying that NAND is dead or that Cloud
0:34 Code completely replaces NADN. They're
0:35 slightly different. But I am going to
0:37 show you how easy it is to build
0:39 automations with Claude Code today. If
0:40 you've never touched Claude Code before
0:41 or even watched a video about it, you're
0:43 in the right spot because my job is to
0:45 make confusing things as simple as
0:47 possible. So in today's agenda, I'm
0:48 going to be going over the interface,
0:49 what do you need to know because there's
0:51 a lot of stuff, but I'm just going to
0:52 tell you what's actually important to
0:53 understand. We're going to go over the
0:54 framework that we use to actually build
0:56 automations. I'm going to talk about
0:57 planning and the importance of clear
0:59 communication. We're going to talk a
1:00 little bit about the superpowers that
1:02 you can give Cloud Code like MCP servers
1:04 and skills. We're going to talk about
1:05 testing and how you actually optimize
1:07 your workflow and then talk about
1:08 deployment, which means actually kind of
1:10 turning it on or pushing it into
1:11 production. And I'm not just going to be
1:12 talking throughout all of this. I'm
1:14 actually going to build a full workflow
1:15 in front of you guys and deploy it by
1:17 the end. So after this video, you'll
1:18 have everything that you need to go
1:20 build your first automation in Cloud
1:21 Code. and you're going to see how easy
1:23 it really is. All right, so we're just
1:25 going to jump right into it. This is the
1:26 interface. We're going to be using
1:27 Visual Studio Code, which has been
1:29 around for a long time. And if you go to
1:31 Google and type in VS Code, you can just
1:33 go ahead and go to this link and just
1:34 download it. It's free to download. And
1:36 then in here is where we're going to
1:37 actually be using Claude Code. So this
1:39 is what it should look like. What we're
1:40 seeing here is just kind of the welcome
1:42 page. You can see we can open new files,
1:44 new folders, we can do some of these
1:45 walkthroughs. But what I'm going to do
1:47 here is I'm going to go over to this
1:49 lefth hand side and click on extensions
1:52 and just type in claude code. And then
1:53 you'll see right here that this
1:55 extension pops up which lets us use
1:57 claude code inside of VS Code. So what
1:59 you're going to do here is go ahead and
2:00 install it. You could also do this in
2:02 anti-gravity or in cursor or somewhere
2:04 else or you could even use the claude
2:06 code kind of app by itself and install
2:08 that locally. But wherever you choose to
2:09 use it, you're going to log in and then
2:11 we'll get started. I'm just using VS
2:13 Code in today's tutorial. It'll prompt
2:14 you to sign in with your anthropic
2:16 account and then you'll be all set. Now,
2:18 in order to access Claude Code, you do
2:19 have to be on a paid plan of Claude. As
2:21 you can see, if you're on the 17 bucks a
2:23 month plan with Pro, you get Claude
2:25 Code. Um, but you will probably find
2:26 pretty quick that you'll want to upgrade
2:29 to Max or the the higher version of Max
2:31 because you'll be doing a lot of
2:32 automations in there and you don't want
2:33 to hit your limit and then have to
2:34 upgrade. But you could always start on
2:36 Pro and then upgrade later. So once we
2:38 got that extension installed, I'm just
2:39 going to go ahead and click on this
2:40 button in the top right, which looks
2:42 like the Enthropic logo. And I'm just
2:44 going to open up Cloud Code. I'm going
2:46 to close out of this window. And now you
2:48 can see that we have basically a chat
2:50 GBT like looking interface where we have
2:52 Claude Code right here. So on the left
2:53 hand side, instead of looking at the
2:55 extensions marketplace, we're going to
2:56 click on this button up at the top that
2:58 says explorer. And what it tells us
2:59 right here is that you have not yet
3:00 opened a folder. So it prompts you to
3:02 open a folder. So before we go ahead and
3:05 open one up, let's talk about why and
3:07 what we're looking at. So this is kind
3:08 of the environment that we're looking at
3:09 right now. We've got our files on the
3:11 lefth hand side and this is where we're
3:13 going to actually build our project, our
3:15 system prompts, our workflows, our
3:16 tools, and then on the right hand side
3:18 we have the agent. So this is where we
3:21 talk to claude code. We have it help us
3:23 with a plan. It asks us questions and
3:24 then it actually executes on those
3:26 actions. So lefth hand side is files,
3:28 right hand side is the agent. It's going
3:29 to be super simple and I'm going to show
3:31 you how we can keep our file structure
3:32 really clean so it doesn't get
3:34 overwhelming and confusing on this lefth
3:35 hand side over here. So whenever you're
3:37 in cloud code, you have to be working
3:39 inside a project and that's why it
3:41 prompts you to open up a folder. So what
3:42 I'm going to do is in my documents, I've
3:44 got a folder called aentic workflows and
3:45 I've got a bunch of ones that I've been
3:47 playing around and testing with. But I'm
3:48 just going to go ahead and open up a new
3:50 blank folder for today's video. I'm
3:51 going to go ahead and call this one YouTube
3:53 YouTube
3:55 analysis. And then I've created that
3:57 folder. So now when I go back into cloud
3:59 code, I'm just going to open up that
4:00 folder. Cool. So I just opened it up and
4:02 it changed what we were looking at over
4:03 here. On the right hand side, we've got
4:05 like VS Code's agent. So I'm not going
4:06 to worry about that and just close out
4:08 of that. And then on the left hand side,
4:10 you can see we're now in the YouTube
4:12 analysis folder, but there's nothing in
4:13 there yet. So once again, I'm just going
4:16 to reopen Cloud Code, close out of this
4:17 one. You can see you can have multiple
4:19 different files open on the right hand
4:20 side. So if you wanted to have like five
4:22 cloud code agents running or you wanted
4:24 to look at five different files or
4:26 system prompts, you could do so. But
4:27 right now, we're just going to keep it
4:29 open to one. So the first thing that we
4:30 need to do is we need to give Claude
4:32 Code a system prompt for this project.
4:33 And that's the first thing that you
4:35 should do whenever you open up a new
4:36 project in Claude Code. And we call this
4:39 system prompt a claude.md file MD just
4:41 standing for markdown. So I'll show you
4:42 guys that in a sec. But without a system
4:45 prompt, it's like we have an NN AI agent
4:47 like an expert copywriter and we don't
4:48 actually give it a system prompt in
4:50 here. So without a system prompt, it
4:51 wouldn't actually really be an expert
4:53 copywriter. It would be super generic.
4:55 It wouldn't understand the tools it has,
4:56 the product that we're trying to sell,
4:58 or where the documents live and what
5:00 those look like. So that leads me into
5:01 the next part of the video, which is
5:03 talking about the framework, which is
5:05 how we actually build these automations.
5:07 So here's a really, really simple
5:08 visualization of what we're actually
5:10 doing here. We've got our agent, which
5:12 is Claude Code, and the agent is going
5:14 to help us build workflows. Workflows
5:18 meaning processes, SOPs, instructions of
5:20 what we actually want to do. And inside
5:21 those workflows, we're going to give it
5:23 access to tools. And tools means
5:25 actually executing actions. So send
5:26 email would be a tool. Research a
5:28 YouTube channel would be a tool. So it's
5:30 really similar to the way that we have
5:32 workflows and tools in NN. Here you can
5:34 see is an NIN workflow for a daily news
5:36 summary. And inside the workflow, which
5:38 is a specific set of instructions in a
5:39 specific order, so it's a deterministic
5:41 process. We have different tools. We've
5:43 got a tool here for Tavali to do
5:44 research. We've got a tool here for an
5:46 AI agent to do the newsletter writing.
5:48 And we've got a tool at the end to send
5:50 a Gmail message. So hopefully that all
5:52 makes sense. It's going to be really
5:53 simple. We're going to have a folder for
5:55 workflows. And in there will be all of
5:56 our processes. We're going to have a
5:58 folder for tools. And in there will be
5:59 all of the actual things that it can
6:01 execute. And then the agent basically
6:03 helps us set up those tool files and
6:04 workflow files and then execute those
6:06 actions. So I'm going to do is drag in
6:08 this claude file. And you can see it's a
6:10 claude.md. This could be called
6:12 agents.mmd, gemini.mmd, whatever you
6:14 want. In this case, we're using cloud
6:16 code, so I'm calling it claude.md.
6:18 But let me go ahead and expand this one
6:20 and let's briefly read through it so you
6:22 understand exactly what I just talked
6:23 about with the workflows, agents, and
6:25 tools. So this is the agent instructions
6:27 for this specific project. You're
6:30 working inside of the WAT framework,
6:31 which stands for workflows, agents,
6:33 tools. This is a three-layer framework
6:34 and it basically separates concerns so
6:36 that the probabistic AI handles
6:38 reasoning while deterministic code
6:40 actually handles the execution and that
6:42 is what makes these systems actually
6:44 reliable. So like I said layer one is
6:46 the workflows the instructions. So these
6:48 are markdown SOPs stored in the
6:50 workflows folder which will be created
6:51 in a sec. Each workflow defines the
6:53 objective the required inputs which
6:55 tools to use expected outputs and how to
6:58 handle edge cases. It's written in
6:59 completely plain language the same way
7:01 that you brief someone on your team. And
7:03 by the way, when I say markdown, it
7:04 basically just means this structure.
7:06 This is a markdown file right here where
7:08 we have like headers and subheaders and
7:10 bold font and things like that. Layer
7:12 two is the agent. So this is the actual
7:14 cloud code agent that we talk to. This
7:16 is your role. You're responsible for the
7:18 coordination between workflows and
7:20 tools. You read the relevant workflow.
7:21 You run tools in the correct sequence
7:23 and you handle failures. You ask
7:24 clarification questions when needed.
7:26 Layer three, we have the tools. And
7:28 these are actually going to be Python
7:29 files. So right here you can see cloud
7:32 is a markdown file. So it's claw.md. We
7:33 said that our workflows were going to be
7:35 markdown files. So it will be like um
7:37 scrape website.md.
7:38 But then in the tools which we will have
7:40 another folder for over here we're going
7:43 to have tools that are going to be py.
7:45 So a python file. So in this case we can
7:46 see there's an example tool called
7:49 scrape single site. py which would be a
7:51 python script that would execute an
7:53 action. These can be API calls, data
7:54 transformations, file operations,
7:56 database queries. And a lot of times in
7:58 these tools, we'll need an API key, but
7:59 we're not going to actually store them
8:02 in the tool code logic itself because if
8:04 that got exported or we push that onto
8:06 the web, then our API keys would be
8:08 exposed. So, we're going to handle
8:11 secrets by storing them inv files. You
8:12 don't have to understand exactly what
8:14 that means or how that works right now.
8:15 We'll show you. So, then we talk a
8:17 little bit about like why this matters,
8:18 how to operate. So, you look for tools
8:20 first. You learn and adapt when things
8:22 fail because these agentic workflows are
8:24 basically self-healing. So, as we're
8:25 going through and building this
8:26 workflow, you will see that it says,
8:28 "Okay, I ran into an error here. Let me
8:30 figure out what happened and let me fix
8:32 it." So, fix the script and retest
8:34 document what you learned. So, if it ran
8:35 into an error and it fixed it, it will
8:37 go ahead and change the workflow file so
8:38 it doesn't run into that error again.
8:40 So, an example could be you get rate
8:42 limited on an API, you dig into the doc,
8:44 so you do research, you discover a batch
8:46 endpoint, you refactor the tool to use
8:48 it, you verify that that works, and then
8:50 you update the workflow so that it never
8:51 happens again. This is once again where
8:52 we talk about that self-improvement
8:54 loop. We talk about the file structure
8:55 and you can see that it's going to
8:57 create this for us. And basically the
8:59 bottom line is that you sit between what
9:01 I want which are workflows and what
9:02 actually gets done which are the tools.
9:04 Your job is to read instructions, make
9:05 smart decisions, call the right tools
9:07 and keep improving the system as you go.
9:09 So I know we skimmed through this kind
9:10 of fast but you guys will get access to
9:12 this exact same system prompt. I'll
9:13 leave it in my free school community.
9:14 The link for that will be down in the
9:16 description. That way you can just go
9:17 ahead and grab this, paste it in, and
9:19 then when you want to follow along and
9:20 build some workflows in Cloud Code,
9:22 you've got this right here for you. So
9:23 now what we need to do is just set up
9:24 our environment with the different
9:26 folders. So I'm going to talk to cloud
9:28 code and just say initialize this
9:30 project based on the claw.md file. So
9:31 I'll go ahead and shoot that off. And
9:33 when we talk to claude, what it does is
9:35 it basically just tells us exactly what
9:36 it's doing and what it's thinking. What
9:38 you'll notice right here is that I'm on
9:41 a mode called bypass permissions. And
9:42 you might not see this initially. You'll
9:44 see ask before edits, edit
9:46 automatically, and plan mode. But it is
9:47 really helpful to be able to turn on
9:48 bypass permissions. So the way that you
9:50 do that is you go to the bottom left to
9:52 settings. You're going to go to settings
9:54 once again. You'll type in cloud code
9:55 and then you're just going to turn on
9:57 this option that says allow bypass
9:58 permissions mode. And that's what allows
10:00 you to do that so that you can let your
10:01 agent run and you don't have to approve
10:03 every step. Now, as this is running,
10:04 what you'll notice is on the lefth hand
10:06 side, we're seeing some files and
10:07 folders pop up. So, we've got a
10:08 temporary folder, which just means
10:10 anything that it needs to store and then
10:12 like delete later, just temporarily, it
10:13 can do so in there just to keep
10:15 everything clean. We've got our tools
10:16 folder, we've got our workflows folder,
10:19 and then we have av and getit ignore. So
10:20 this is going to help us just basically
10:23 keep our project clean, but also the
10:26 agent knows exactly where everything is.
10:28 Cool. So the project is now initialized
10:30 using our WAT framework and it showed us
10:32 what it created. So now let's move on to
10:33 section three of the video where we're
10:35 going to be talking about planning and
10:37 communicating with our agent. So what
10:39 I'm going to do is I'm going to clear
10:41 out this conversation. If I wanted to
10:42 access past conversations, I could do so
10:44 up here. I'm going to go to plan mode.
10:46 And this is really important. Whenever
10:48 you're doing something that actually
10:50 involves like creating something, you
10:52 need to describe the goal and you need
10:54 to be able to describe it super super
10:56 clearly. And it's not just the goal, you
10:57 need to also describe the features that
10:58 you want. And if you were to just
11:00 describe something and then chuck
11:01 clogged code at it and you would do
11:03 bypass permissions, you probably
11:05 wouldn't get a great output. So, what
11:06 you always want to do when you're
11:08 creating an idea is you want to go on
11:09 plan mode because what you're going to
11:11 see is when I'm on plan mode, it thinks
11:13 extra hard and it looks at everything in
11:16 the folder and it's going to ask me tons
11:17 of questions that I might not have
11:18 thought of, which is really, really
11:20 helpful because it gets a really, really
11:21 good understanding of what we want and
11:23 it brainstorms options and then it
11:24 actually will do it after it's
11:26 confident. So, let's explain the
11:27 workflow that we want to build today.
11:29 Hey Claude, I need your help building an
11:31 automation. I want this automation to
11:34 basically scrape tons of YouTube videos
11:37 and YouTube channels in my niche, which
11:40 is AI and AI automation. I want to get
11:41 insights about what videos are trending,
11:43 what's working well, and kind of what
11:46 the AI space is feeling like so that I
11:47 can create more content that people want
11:49 to see and that will be beneficial for
11:51 them. I need your help understanding how
11:52 we can actually get this data. So, look
11:55 into different APIs or MCP servers.
11:56 Also, let me know if there's any skills
11:58 that would be helpful because after
12:00 you've done this research, what I want
12:02 you to do is I want you to create a
12:04 slide deck for me. So, I want to get an
12:05 actual deliverable that will be sent to
12:08 my email using Gmail and it should be a
12:10 really nice professionallook slide deck
12:12 with charts and images and all of these
12:14 different graphics so that I can
12:15 understand what's going on in the
12:17 industry. So, that's what I've got. Let
12:19 me know if you have any questions or if
12:21 you have any recommendations for things
12:22 that I haven't thought of about this
12:24 automation system. Cool. So that was my
12:26 little brain dump and it's going to come
12:28 back and ask me a ton of questions which
12:30 is just going to help make this project
12:32 a lot lot better. And so I know a lot of
12:34 you guys might be looking at this and it
12:35 seems overwhelming and confusing and I
12:37 agree like when I first wanted to dive
12:39 into claude code I watched some YouTube
12:41 videos and I just it didn't click. The
12:42 only way it's truly going to click is if
12:44 you get in here and you do it yourself
12:46 because once you send off these messages
12:48 just read everything it's doing. Read
12:49 every single line and you'll start to
12:50 understand the way that these models
12:52 think and what they try to do. And
12:54 that's truly the best way. So after this
12:56 video, restart it from the beginning,
12:58 open up Cloud Code, and just kind of
12:59 follow along with what I'm doing, and it
13:01 will all start to click. I promise. And
13:02 by the way, you can see that as it's
13:04 making this plan for us, it's doing
13:05 research. So it's not just thinking,
13:07 it's also searching the web to find out
13:09 how we can scrape the YouTube analytics
13:11 and how we can use MCP servers and
13:13 things like that. Okay, so we got some
13:14 questions now from Claude. It says,
13:16 "What specific YouTube channels do you
13:18 want to track? Should I discover top AI
13:19 automation channels automatically or do
13:20 you have a list? Let's just go with
13:22 autod discover top channels. Frequency
13:24 is how often should this report be sent?
13:25 I'm going to go ahead and do weekly.
13:27 Then it asks us if we want to track all
13:29 this data in sheets. Yes, absolutely.
13:31 Let's do that. And then for delivery, it
13:32 says what email address should the
13:34 reports be sent to? And I'm going to go
13:36 ahead and say send to my Gmail. So, I
13:37 shut off those answers and now it's
13:39 going to keep updating the plan. All
13:40 right. So, the plan is finished. The
13:42 objective is to build an automated
13:43 system that scrapes YouTube data for the
13:46 AI niche. It analyzes trends and gets
13:48 performance metrics and then generates a
13:49 professional slide deck with charts and
13:51 visualizations and sends that to me over
13:53 Gmail. We've got the workflow which is
13:54 YouTube weekly report. We've got the
13:56 agent layer. We've got different tools.
13:58 It's going to build out these seven
13:59 different Python tools that it
14:01 mentioned. So fetching YouTube data,
14:03 analyzing YouTube data, generating
14:05 charts, generating slides, sending the
14:07 email report, exporting to sheets, and
14:09 discovering channels. And now it needs
14:11 to actually create this workflow. So, we
14:12 could obviously read through all of this
14:14 and we could give it some feedback if we
14:15 wanted to, but I'm just going to go
14:16 ahead and accept these because I want to
14:18 see how well it did with just one
14:20 iteration of our plan, which took me a
14:21 few minutes. So, you can see what it
14:23 does is it starts a to-do list. So, it's
14:24 basically just going to knock off one of
14:26 these at a time. And that's really nice
14:27 because it helps the agent stay on
14:29 track, but it also means that you could
14:30 go to your other monitor here and work
14:32 on something else and just kind of keep
14:34 peeking in on it and checking on the
14:36 to-do list to see how much is left to
14:38 run. Okay, so the to-do list is done.
14:39 The workflows and tools have been built.
14:41 So, here's where we're at. We've got our
14:43 seven tools have been created. So, if I
14:45 open up the tools folder, we should see
14:47 we now have these seven Python files.
14:48 And each of these, like I said, are
14:51 actual Python code that will execute
14:53 some sort of action. So, those have been
14:54 built. We've also got the workflow. So,
14:56 this is our markdown file, YouTube
14:58 weekly report, which is an actual
15:00 process. So, I'm not going to read this
15:02 whole thing, but it has the actual steps
15:03 that we would be doing here. So, now it
15:05 says to get started, we have a few
15:06 dependencies. So, the first one is we
15:08 need to install something. The second
15:10 one is to add a YouTube API key. The
15:12 third one is to set up Google OOTH for
15:14 Gmail and sheets. And then the fourth
15:15 one is just to run the actual workflow.
15:17 So a lot of times when cloud code's done
15:18 and it has some action items, it
15:20 actually just tells you to do some stuff
15:22 that it could do itself. So right now we
15:23 would obviously have to go get our
15:24 YouTube API key and then we could just
15:26 give it to it and say, "Hey, you go
15:28 update the I don't want to touch that.
15:30 You just go do it." But first, what it's
15:32 doing is it's asking us to do this. So,
15:34 we could obviously just install this
15:36 right now, or I could just say, can you
15:38 please go ahead and install the
15:39 dependencies? I'll go grab my YouTube
15:41 API key. Cool. So, it went ahead and
15:43 installed that stuff just like I told it
15:44 to. And now it's asking for a YouTube
15:46 API key. So, instead of just adding it
15:48 to the file, I'm just going to drop it
15:49 in right here. And then the one thing I
15:51 will have to go do manually is step
15:52 three. So, I'll have to enable the
15:54 YouTube data API and Gmail and Google
15:56 Sheets and then create the credentials
15:58 and just drag in the JSON file, which I
16:00 will do that in a sec. And here's
16:01 another thing I'm doing with my API key.
16:03 It should only be added to thev file. It
16:05 shouldn't be listed in the workflows or
16:07 the tools. Okay, so I added everything
16:09 that I needed to. And if you're confused
16:11 about how to do that, just say, "Hey,
16:12 where do I go? What do I click on? How
16:13 do I do that?" And it'll walk you
16:15 through. And now what it's doing is
16:16 because it has all our credentials, it's
16:18 actually just testing out if the things
16:20 work. So you can see the YouTube API is
16:21 working. Now, let's run the full data
16:23 collection pipeline. So it's basically
16:24 just testing that the flow works and
16:26 then we'll give it a full run. But we
16:28 can see that it just ran the full
16:29 pipeline. So that was our first initial
16:32 test. It found 30 channels. It fetched
16:34 187 videos. It generated analysis. It
16:37 made six charts. It built a nine slide
16:39 PowerPoint deck for us, exported it to
16:40 Sheets, and then it emailed us the
16:42 report. So, let's go take a look at all
16:43 that. Okay, so here's the email that I
16:46 got. AI automation YouTube analytics.
16:48 So, the weekly report for Jan 20, we got
16:50 30 channels tracked, 187 videos. We have
16:53 some top videos from the week. We have
16:54 recommendations. And then we also have
16:56 our PowerPoint right here, which we can
16:58 see. We have similar information. We've
17:00 got median views, median engagement,
17:01 trending topics. We've got top
17:03 performing videos. So, we have this laid
17:05 out by title and by views. We've got top
17:07 channels by subscribers. Unfortunately,
17:09 I do not see my name up there. So,
17:10 please hit the subscribe button. We've
17:12 got engagement analytics. We've got
17:14 trending topics, by keywords in the AI
17:16 automation, posting patterns, and then
17:18 we have some recommendations to kind of
17:20 close us off here. So, keep in mind this
17:21 is not perfect, and we obviously would
17:22 want to come back and make this a little
17:26 bit more tailored for us, but this was
17:28 one prompt. Cloud code asks us questions
17:30 and then I basically just sat down and
17:31 then I came back over here when it was
17:33 done and this is what we have ready for
17:35 us. What we also see is that we got this
17:37 exported to a Google sheet. So if I
17:39 click on this, remember that we didn't
17:40 create this sheet. We didn't create
17:43 these different tabs or the actual like
17:44 schema of this. But we've got three
17:46 tabs. The first one is channel stats. So
17:48 this pulled channel stats from today's
17:50 date which is January 20th. We have the
17:52 channel IDs. We have the actual channel
17:54 names. And then we've got subscribers,
17:56 total views, and video count. We can see
17:58 nice that Nate Herk AI automation did
18:00 make it in this scrape. We've also got
18:02 top videos. So once again, this was ran
18:04 based on today's analytics. We got the
18:06 video ID. We've got the title of the
18:07 videos. We've got the channel, the
18:09 views, the likes, the comments, the
18:10 engagement rate, which is pretty cool.
18:12 And also how old the videos are. So we
18:14 can see that we're getting real accurate
18:16 like what's trending right now. And then
18:17 we get a weekly summary. So this is
18:19 supposed to run every single week. We
18:20 can see the day that it ran, the
18:22 channels it tracked, the videos it
18:23 analyzed, the median views, the median
18:26 engagement score, and the top keyword in
18:28 top keyword 2, which actually, it's
18:30 funnily enough, spells out claude code,
18:32 which is why you're seeing this video
18:33 right now. Okay, so let's recap what
18:35 we've done. We have familiarized with
18:37 the interface. We have built out the
18:39 actual structure of our project using a
18:41 claw.md file, which is like a system
18:44 prompt. Now, we have our workflows. We
18:46 have our tools and we have actually gone
18:47 through the whole planning stage with
18:50 claude code to build out the initial you
18:52 know workflow automation that we need.
18:53 So what comes next now is we want to
18:55 talk about a few other things. We want
18:57 to talk about superpowers. So MCPS and
18:59 skills and then we're going to test it a
19:00 little bit more and then we're going to
19:02 actually deploy the automation live. So
19:05 to start off with superpowers MCP
19:07 servers. So I'm not going to dive super
19:09 super deep into MCP servers in this
19:10 video but I did want to bring it up. So,
19:12 if you remember in plan mode, I
19:13 basically said, "Hey, I want to scrape
19:15 YouTube data. Can you just go figure out
19:17 if I should use an MCB server or like an
19:19 API?" And it ended up finding out that
19:21 the YouTube API was going to work
19:22 better. So, that's why we did it in this
19:24 workflow. But essentially, just think of
19:27 an MCP server as an app store. So, Gmail
19:29 has an MCP server, Calendar has an MCP
19:32 server, lots of these services do. And
19:33 this is like one of the most common
19:35 visualizations because it's like a
19:39 universal micro USB port because instead
19:41 of having to go to calendar's API and
19:43 have one different API request to create
19:45 an event, one different one to update
19:46 event, one different one to delete an
19:48 event, all we have to do is connect once
19:50 to the whole server and then the agent
19:51 can figure out how to go use different
19:53 endpoints and parameters. It just
19:55 simplifies the whole process. Now, what
19:56 I did want to talk about a little bit
19:58 more was the idea of claude skills
19:59 because this is a little bit newer. So
20:01 essentially skills are instructions or
20:03 resources that claude can load in
20:04 dynamically. And that's kind of the key
20:06 piece here is that instead of just
20:07 reading it every time in its system
20:10 prompt, it basically understands what is
20:12 the request. Let me go look at all the
20:14 skills I have access to. If one of them
20:15 is relevant, I'll pick that one. I'll
20:17 read it all and then I'll take action.
20:19 And this process basically just improves
20:21 Claude's consistency, speed, and
20:23 performance. And also saves you tokens.
20:24 Like I said, when you ask Claude to do
20:26 something, it reviews the available
20:27 skills. It loads in only the relevant
20:28 ones and then it applies those
20:30 instructions. So, we're going to go
20:32 ahead and try to implement a skill into
20:33 this workflow and I'll actually show you
20:35 what the skill document entails. So,
20:37 then it will all start to make a little
20:38 bit more sense. But before we do that, I
20:40 did want to real quick cover the
20:41 difference between skills and projects
20:43 and skills in MCP. So, the first one is
20:46 about projects. You're in a project and
20:47 basically what we have is access to
20:49 whatever is in here. So, it's kind of
20:51 static documents and background
20:52 information. And a lot of times these
20:54 skills are installed globally. So what
20:56 you'll notice actually in our project is
20:57 that we don't have any skills in this
20:59 project. Normally there will be like a
21:01 thing that will be like agents and then
21:02 you drill down in that folder and you'll
21:04 see like agent skills or claude skills.
21:06 And that's more installed on the global
21:07 level. And that's actually really good
21:09 because what that means is if I closed
21:10 out of this project and I opened up a
21:12 different one, I would still have access
21:14 to all the same skills that I've already
21:15 installed. So you can see right here
21:17 that I just asked Claude Code, "What
21:18 skills do you and it came back and
21:20 showed that it has a front-end design.
21:22 It has NN skills and those are the only
21:24 eight that it actually has even though
21:26 we don't see them in this specific
21:28 project. Now we have skills versus MCP
21:30 and these are also very different. MCP
21:32 is basically to get data and take
21:35 action. So like I said if you want to
21:36 connect Claude to something like Gmail
21:39 to read emails or to send emails but
21:41 skills are more like knowledge custom
21:42 instructions. So if you ever find
21:44 yourself constantly repeating something
21:46 to your cloud code agent, then maybe
21:47 that's a good sign to put it either in
21:50 the claw.mmd file or create your own
21:51 custom skill for it. So like the example
21:53 of the front-end design, if you wanted
21:54 to use cloud code to build yourself a
21:56 landing page or a website, using the
21:58 front-end design significantly improves
22:00 its ability to actually design things.
22:02 So, what we're going to be doing in this
22:05 example now is I want to use a skill and
22:06 I'm going to be looking at this cloud
22:08 code templates website which has a bunch
22:10 of agents and commands and MCP servers
22:12 and skills and hooks and I'm going to be
22:14 looking for one that helps us create
22:16 like better looking PDFs. I'll also
22:17 leave a link to this in the description
22:19 of the video. So, I went ahead and
22:20 searched for design and you can see
22:21 there's a skill right here called canvas
22:23 design. And if I view details here, it
22:28 says create beautiful visual art inputs
22:30 using design philosophy. So, we're going
22:31 to go ahead and try this one out. I've
22:32 never used it before. We'll see how it
22:34 works. But this is actually like the
22:37 code of the skill itself. And you can
22:38 see it basically is just natural
22:40 language instructions. So, it's just a
22:42 custom prompt that someone built or you
22:44 built yourself. And now I can load this
22:45 into cloud code. So, when we have it
22:47 design a PDF, it can use this and it
22:49 will probably just come out a lot better
22:50 because it's prompted. So, we've got
22:52 installation right here where we can use
22:53 this code. So, what I would try is just
22:56 copying this, going into VS Code. I'm
22:58 going to go ahead and open up a, you
22:59 know, kind of clear the conversation and
23:00 just paste that in and see what happens
23:02 if I drop that in there. Okay, so I
23:04 dropped it in and then it actually ran
23:05 the command in our terminal to install
23:07 it. And it says that it's been installed
23:09 and we have skill.md for the
23:10 instructions for the skill. And then
23:12 we've also got a bunch of fonts. And
23:14 what it did is it actually created a new
23:16 folder here called Claude. And then we
23:17 do have skills right here. So you can
23:19 see that it put it in this project. So
23:20 now I'm a little confused because I
23:22 don't know, okay, we have a skill here,
23:24 but we also have skills globally. So I
23:26 would literally just say it looks like
23:28 you created this skill in this project.
23:29 Is this going to be installed globally
23:31 or will it only be accessible through
23:33 this project? So right now it basically
23:34 says yeah this was installed just
23:36 locally in this project and that's fine.
23:37 And if you wanted it to be global
23:39 instead you would just say okay actually
23:41 just make that global and then it would.
23:42 So anyways going to clear out this
23:44 conversation one more time. I'm going to
23:45 go back into plan mode and I'm going to
23:47 give it a prompt. And actually one more
23:48 thing before I prompt it. I'm going to
23:51 drag in the AI Automation Society Plus
23:53 logo just over here on the left hand
23:54 side. And you can see it's right here
23:56 and the file pops up, right? So, what
23:58 I'm going to do is prompt it, but I want
24:00 it to actually have this logo on all of
24:02 the PDFs that it generates. Hey, Claude.
24:04 So, I just gave you a skill for canvas
24:06 design. And instead of outputting a
24:08 PowerPoint presentation, I want you to
24:10 now take the same research when you do
24:13 your analysis from YouTube videos, but I
24:15 want you to use that canvas design skill
24:17 to create a PDF. It needs to be
24:18 professional, but it needs to be
24:20 aesthetically pleasing. And what I want
24:22 you to do is make sure you're including
24:25 the AIS Plus logo PNG that I dropped in
24:27 this folder as well because I want the
24:29 whole presentation to be branded so I
24:30 can share it with my team. So, I'm
24:32 shooting this off in plan mode and I'll
24:33 let you know when it comes back with
24:35 some questions. Interesting. So, it came
24:36 back and said that that canvas design
24:38 skill that we just installed creates
24:40 PDFs interactively, which means step
24:42 five of our workflow changes from fully
24:44 automated to semi-automated. So, how do
24:45 we want to handle this? Let's just go
24:46 ahead and just say keep it fully
24:47 automated because that's kind of the
24:49 whole point. We want to be able to push
24:51 this live to run on a schedule trigger.
24:53 Okay. So, the new plan is to replace the
24:55 PowerPoint output with a branded PDF
24:56 report. So, it's going to make a new
24:57 tool to replace the generate slides
24:59 tool. We have our current workflow
25:01 state. We've got our logo. It has some
25:02 proposed changes here. We're going to be
25:04 looking at the PDF structure. And of
25:06 course, what it has to do is update the
25:07 actual workflow. So, it's going to look
25:09 at this YouTube weekly report markdown
25:10 file, which is the actual workflow. Of
25:12 course, it's going to change that. It's
25:13 going to update some of the other tools
25:15 like the email tool. And then of course
25:16 it's got some other implementation steps
25:18 for us. And in this case, what I'm going
25:20 to go ahead and do is just autoaccept
25:21 these changes. And so right now it's
25:23 just setting up a to-do list to actually
25:24 implement those changes. We're not going
25:26 to be running the workflow again. We're
25:27 just going to make the changes and then
25:29 we'll go ahead and test it. And just a
25:30 reminder when you guys are in here
25:32 building your own workflows. Just pay
25:33 attention to what it's actually doing.
25:34 It does some really interesting things.
25:36 Like right here, it installed some
25:37 dependencies to actually be able to
25:39 create the PDF a little bit better. And
25:40 then here it says the PDF was generated,
25:42 but it's using a fallback using whatever
25:44 this is, and it would look better if it
25:46 had proper title and closing pages. So,
25:47 it's going to install something else and
25:49 then try it again. It's just a reminder
25:50 of using this framework of an agent that
25:53 sits between workflows and tools as it's
25:54 building them out, as it's testing them.
25:56 It's continuously improving them, seeing
25:58 errors, seeing things that could be
25:59 improved, and then just going ahead and
26:00 doing that for you. So, that's where
26:02 it's really powerful. And this testing
26:03 and optimization phase is really
26:05 important because once you actually
26:06 deploy your automation, you're not
26:08 deploying the agent. You're just
26:09 basically deploying the workflow that's
26:11 connected to tools. And that's important
26:13 to understand. The workflow itself would
26:14 be put up into the cloud where it could
26:16 run on a schedule trigger, but the agent
26:18 still lives locally in cloud code. Which
26:20 means if a workflow which means if your
26:22 workflow is running every week, it's not
26:23 going to be self improving and
26:25 self-healing. So if you wanted to do
26:27 that, you would come over to cloud code,
26:29 you edit the workflow, you'd improve it,
26:30 and then you just push that version back
26:32 to modal or wherever you're hosting
26:34 them. But anyways, this finished up. So
26:36 it created a new tool. It modified a few
26:38 other things. it changed the actual
26:41 workflow itself. And then what also it
26:42 did is it made a test PDF just to see
26:44 how that worked. And you can see here
26:46 it's stored as a temporary file. So in
26:48 our temp folder, which is right here,
26:49 you can see right there we have a
26:51 YouTube report PDF. And let me just make
26:54 this bigger. We've got our logo right
26:56 here. We've got our AI and automation
26:58 YouTube analytics report and we have the
26:59 thank you slide. So it basically just
27:00 tested to see if it worked. But now
27:01 we're going to go ahead and run that
27:03 full workflow and then we're going to
27:04 see if we're ready to actually push it
27:07 up into production. So I'm on bypass
27:09 permissions and I'm just going to shoot
27:11 off run the YouTube analysis workflow.
27:13 And it's not even called that, but it
27:14 will be able to search through the
27:15 workflows that it has and it's going to
27:17 understand which one to run. It's going
27:19 to execute all of those Python scripts
27:21 in order. And then we should have a
27:23 finished product. Okay. So here's the
27:25 email. It has the similar structure as
27:27 far as the actual body of the email, but
27:28 then at the bottom we should have our
27:30 PDF which we got attached right here.
27:32 But what you'll notice is that it's only
27:33 two pages. So it didn't actually create
27:34 the right type of PDF that we were
27:36 looking for. However, it did update the
27:38 Google sheet. So it added, you know,
27:40 those 30 more videos that we originally
27:43 didn't have on this sheet. It added more
27:44 videos, of course, and then it threw in
27:46 one more weekly summary where it has a
27:49 little bit of a different metrics. And
27:50 what's interesting is that you can see
27:52 that it did generate charts and it did
27:53 do analysis because it actually
27:55 generated all of these images over here,
27:57 top channels, top videos, key
27:58 performance indicators, posting
28:00 patterns, all this kind of stuff. It
28:02 just didn't actually include it. So once
28:03 again, we would go back in natural
28:05 language and say, "Hey, you know, we
28:07 just got that PDF, but it was only two
28:09 slides." So what I did is I said
28:10 everything seemed to work except for the
28:12 PDF that I received was only two slides.
28:14 It was only the title and the thank you
28:16 page. So, it found the issue. It fixed
28:18 it. It changed the workflow. It changed
28:20 the tools. And now, it's shot me off a
28:22 new example with nine pages. And this
28:24 time, we still have the logo. We still
28:26 have the date. And we also now have all
28:27 of the actual slides that we need in
28:29 this PDF with the charts and things like
28:31 that, recommendations, and then we still
28:33 have the closing off slide. So,
28:34 hopefully you guys understand now how
28:37 important the planning really is because
28:39 we did kind of rush through this in this
28:40 example where we auto accepted changes
28:42 and we just kind of like sped through
28:43 things. And it's fine because we're
28:45 still able to go back and forth and let
28:47 Claude Code investigate and fix, but it
28:50 should show the importance of if you are
28:51 really really clear up front and you
28:53 know exactly what you need, it will be a
28:55 lot better off the jump, but it's not
28:57 perfect. Okay, so now let's say we're at
28:58 the spot where we're ready to basically
29:00 make this workflow live where we
29:01 actually want to forget about it and
29:03 just let it run every Monday at 6 a.m.
29:05 or whatever. So, we need to deploy it.
29:06 So, the way that we're going to do that
29:08 is we're going to use modal, which is AI
29:10 infrastructure that developers love.
29:11 Essentially, what modal is is it lets
29:13 you spin up these kind of like computers
29:15 in the cloud where you can host your
29:17 automations and it only charges you when
29:18 they actually run. So, you're not
29:19 getting charged by the minute or by the
29:21 day. You're only getting charged every
29:22 time they actually execute. So, when you
29:24 create an account, you'll get five bucks
29:25 for free. And then if you add a credit
29:27 card, even though it won't charge you
29:29 yet, you'll get 30 bucks. And this 30
29:31 bucks will last you a long, long time.
29:32 Trust me. So, what will happen is this
29:34 screen will probably pop up and it will
29:35 say that you need to download and
29:37 configure the Python client. So you
29:39 could basically copy this exact command
29:41 right here and just put that into cloud
29:42 code or you could just say hey cloud
29:44 code I want to push this workflow to
29:46 modal. So just help me get that
29:48 initialized. But I'll just show you what
29:49 would happen if you copied this and we
29:52 came into cloud code and said awesome. I
29:56 want to push the YouTube analytics
29:58 workflow to modal so that it can
30:00 actually run every single Monday at 6
30:01 a.m. And then I'm going to go ahead and
30:02 paste in those two things that we just
30:04 saw. And let's actually do this in plan
30:06 mode first and just shoot that off. So
30:07 what it's doing is it's going to read
30:08 through the workflow structure and the
30:10 tools and understand how it can package
30:12 everything up so it can actually deploy
30:13 it on modal as an app. So it came back
30:15 with a plan to deploy this on modal. But
30:16 there's one more thing that I want to
30:18 ask it about before we actually do this.
30:21 And this last part is security. So I
30:22 basically told it to run a security
30:24 review and make sure that my API keys
30:25 aren't exposed and that there's no
30:28 vulnerabilities because the reality is
30:30 we just built a ton of code and I don't
30:32 know what the code is actually doing.
30:33 So, it's really important to be thinking
30:35 about this before you put anything out
30:37 there on the web. Are any web hooks
30:39 exposed? And if they are, do you have
30:41 like, you know, proper protection around
30:43 that? Are secrets out there? Are API
30:45 keys out there? What could people do now
30:47 that this is out there? And as you start
30:48 to deploy more workflows, whether that's
30:50 an NEN or whether that's in code like
30:52 this, you'll start to understand the
30:53 things to look out for. But you also
30:55 have one of the smartest reasoning and
30:56 coding models right here in front of
30:58 you. So, you might as well just ask it,
31:00 hey, check the code and let me know if
31:02 there are any risks. So the security
31:03 review came back and it found three
31:05 critical issues that need attention. But
31:08 the good news is nothing is vulnerable
31:09 and there's not a GitHub repo. So
31:11 nothing's been committed out there
31:12 publicly and everything is going to be
31:15 stored as a modal secret. So the API
31:18 keys and the JSON token. So nothing will
31:19 be committed to any repository. So we're
31:21 good to go. And basically from there it
31:23 came back with a plan once more and I
31:25 have approved it. So it's going ahead
31:26 right now and it's creating the
31:27 different tools and the different things
31:29 that we need to actually be able to
31:31 write this over to Modal. and then we'll
31:33 go ahead and test it out over there. So
31:35 our deployment is now complete. It had
31:36 to update the scripts to make sure that
31:37 they could actually have the right
31:39 environment variable path. It had to
31:41 create a modal deployment file. So it
31:42 actually just understands the process of
31:45 what it just did and schedule the cron
31:46 or the schedule trigger. And then it had
31:48 to create modal secrets that we could
31:50 store over there. So it is now deployed
31:52 and scheduled. So if I click on this
31:54 link, this will bring us to our modal
31:56 environment right here. And what you can
31:57 see is that we have two different apps.
32:00 We have the analytics and then we have
32:02 the analytics manual. So it had to do a
32:04 manual run just to see if it worked. So
32:05 this is the actual app. So if I go back
32:06 to the main dashboard, you can see that
32:08 we have this app and there's kind of
32:10 like the two different like endpoints.
32:11 But if I open up the app, we can see the
32:13 overview. We can see deployment history.
32:15 So as you change something in cloud code
32:16 and then push it back over here, you'll
32:18 see a different version. And then you
32:19 can also see the app logs when it's
32:21 running. So when I click into the
32:23 YouTube analytics one, the one that will
32:24 be live, it says the next run will be in
32:26 5 days. So, it's scheduled at 6:00 a.m.
32:29 only on Mondays, America Chicago time.
32:30 But what I'm going to do just to prove
32:31 to you guys that this is working or at
32:33 least test if it is working is we can
32:35 actually just go ahead and run one right
32:37 now. So, I scheduled an immediate run.
32:38 We're going to see this pop open right
32:39 here. And we're going to see the fact
32:41 that it's running right now. As you can
32:43 see, it took 2 seconds to start up and
32:44 now it's running. And then we'll see the
32:46 result of that execution. And actually,
32:48 I'm glad that this just failed cuz I can
32:49 show you what you need to do. But this
32:51 failed, right? So, we'll click into
32:52 this. And when you click into each of
32:54 the runs, you'll basically be able to
32:56 see the logs and the executions. So in
32:58 the log, this is what actually shows us
33:00 like why it failed and what happened. So
33:02 I don't really know what this means,
33:04 right? All I'm going to do is copy this
33:07 entire string of text. We're going to go
33:09 back into cloud code and I'm actually
33:10 going to go ahead and clear this because
33:12 we're at 64% context. So just going to
33:15 restart fresh. So I just tried to do a
33:18 manual run of our YouTube weekly report
33:20 app in modal and this is the error that
33:21 I got. And then I paste in all that
33:25 messy stuff and shoot it off. Okay, so
33:26 because we tested so much and we were
33:28 using the free tier of the YouTube data
33:30 API, we actually just hit the daily
33:32 limit which was about 10,000 units and
33:33 we exceeded that because we were doing
33:35 so much testing to see how well this
33:37 thing would work. The good news is if
33:39 this is actually running weekly, we will
33:40 never hit that daily quota limit. So
33:43 we're fine. The bad news is we're not
33:44 going to test this one right now. But at
33:46 least it does suggest other options and
33:48 some longerterm fixes. But it's okay
33:50 because I did want to end off by showing
33:52 how you could deploy something with a
33:54 web hook trigger rather than a schedule
33:55 trigger. So what I did is I came into
33:56 this other workflow that I built the
33:58 other day which is a very simple lead
34:01 web hook notification. So it has a web
34:03 hook as the trigger. We would see a
34:05 company name and some other data. We
34:06 would research the company with
34:08 perplexity and then send an email
34:09 notification. And so I basically just
34:11 said, "Hey Cloud Code, can you push this
34:14 workflow onto modal as we did earlier?"
34:16 And now we have this app in our modal as
34:18 you can see lead-web hook. So what I'm
34:20 going to do is go to Postman. So we can
34:22 actually hit that web hook just to
34:23 simulate what would happen. We've got
34:25 the address. We've got the body. And
34:27 I'll shoot this off. And what this is
34:28 going to do is it's going to trigger
34:31 this form endpoint in modal. So I'll
34:32 click into that one. And you can see
34:34 right now we have a status of pending.
34:36 This one's going to start running. And
34:38 then it will show that we actually get
34:40 the email in Gmail. And so this is
34:41 really just to show that once you have
34:43 your stuff up and running in modal, it
34:45 will work. And you can also do it based
34:47 on web hooks rather than just doing it
34:48 on a cron. So that looks like it
34:50 finished up. We can see that we just got
34:51 this email for the new lead Chipotle
34:53 where it did some research about them
34:54 and then obviously it gave us a
34:56 notification here. And now what you
34:57 could do is because you just went
34:58 through the process of deploying a
35:00 workflow to modal and you know that it
35:01 works because you just validated that
35:03 it's working. You have all of that
35:05 history right there. And what you could
35:08 do is say, "Okay, cool. Keep this stored
35:10 either in my claw.md file or let's
35:12 create this as a skill so that every
35:13 time later when you're building a
35:14 workflow and you want to actually push
35:16 it to modal, you have all that
35:17 information already there, whether
35:19 that's a skill or whether it's in the
35:21 system prompt of claude.md." So, I hope
35:24 you guys at this point can see how cloud
35:25 code makes this stuff really, really
35:27 easy to get automations up and running.
35:29 Whether that means an automation that
35:30 you want to be there for and you trigger
35:32 kind of to use as like a personal
35:34 assistant or an automation that you
35:36 actually want to host somewhere and have
35:38 it run on some sort of trigger and you
35:39 can tap into all of the skills that
35:40 other people have been building and
35:42 using because you can find those
35:44 publicly and then just add those to your
35:46 own instance. So now you have the super
35:49 smart model like Sonnet 4.5, Opus 4.5
35:51 paired with all of these really good
35:53 prompts and really good like MCP
35:54 servers. So you can pretty much do
35:56 anything in that environment. The more
35:57 you start to use it, the more you'll
35:58 realize that you don't have to actually
35:59 switch around to a bunch of different
36:01 Chrome tabs and different apps on your
36:02 desktop. You can do a lot of the stuff
36:05 that you need to do just in the cloud
36:06 code environment itself. So once again,
36:08 [snorts] that claw.md file that you guys
36:10 can access for free will be in my free
36:11 school community. The link for that will
36:12 be down in the description. And if
36:13 you're looking to dive deeper into this
36:14 kind of stuff and connect with over
36:17 3,000 members who are also kind of allin
36:19 on AI and building businesses with AI,
36:20 then definitely check out my plus
36:21 community. The link for that is also
36:23 down in the description. We've got full
36:25 courses in here starting with Agent Zero
36:26 for the beginners and then moving all
36:28 the way up to actually monetizing AI
36:30 automation knowledge. And I promise you
36:31 guys, I'm going to be bringing a lot
36:33 more of like anti-gravity and cloud code
36:36 content into this plus community course
36:38 as well. I also run one live Q&A every
36:40 week, so you can ask me questions about
36:43 nitn cloud code or building an AI
36:44 business, all that kind of stuff. And
36:46 I'd love to see you guys in the
36:47 community in those live calls. But that
36:49 is going to do it for today's video. So
36:50 if you enjoyed or you learned something
36:51 new, please give it a like. It
36:52 definitely helps me out a ton. And as
36:53 always, I appreciate you guys making it
36:55 to the end of the video. I'll see you on
