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