You use AI every day. Beat. But that doesn't
actually mean you're an advanced user. Right.
I mean, it definitely feels advanced, but daily
casual use is really just the beginning. I think
about this a lot. We type a quick prompt into
a chat box. We get a really solid answer. We
feel incredibly productive. Oh, yeah. Totally.
Beat. But we are barely scratching the surface
of what is possible. Welcome to this deep dive.
Today, we're charting a very specific path. We
are exploring the five levels of cloud proficiency.
We're going to move step by step through this
entire framework. We'll start with those simple
everyday chats that will climb all the way up.
We'll explore fully autonomous background workflows.
Our goal is to help you pinpoint exactly where
you are right now. Right. And more importantly,
we want to show you how to level up safely. So
let's start at the absolute baseline. Level one.
the enthusiast. Yeah, which is honestly where
most people tend to live right now. You might
assume you're a total power user just because
you chat with the AI every single morning. But
realistically, this is just the ground floor.
Level one is really built for quick daily tasks.
You know, you need a fast email draft. You need
a short summary of a long article. Right. Or
maybe you just need a simple explanation of a
complex topic. It just gives you a much faster
starting point. You paste in some rough meeting
notes. You ask the AI for a clean version. Yeah.
A few minutes later, you have something totally
useful. It helps you think faster. You create
a solid first draft. And then you just finish
the actual work yourself. There is a very specific
tactic here that I love. One that works incredibly
well when you're at level one. What's that? Uploading
screenshots directly into the chat. Oh, yeah.
That is a fantastic habit to build. You really
need to stop typing out every single detail.
It just takes way too much time. Exactly. Because
you might accidentally miss something important.
Just share exactly what you see on your screen.
Exactly. So imagine you get a really confusing
dashboard error, or you see a weird error message
during your work. Right. You panic a little.
Yeah. But you don't try to transcribe the code.
You just snap a quick screenshot. You upload
the image directly. Then you ask it to explain
the error in simple English, and you ask for
the very next step to fix it. It also works incredibly
well for visual content, too. Say you're designing
a new newsletter layout, you take a quick screenshot
of the draft, you ask the AI to check the title
length, or you ask if the call -to -action placement
needs clearer wording. It's working straight
from the real visual data. But there's a really
massive limitation at this stage. a severe lack
of ongoing context. Oh, completely. One -off
chats are perfectly fine for single isolated
tasks, but repeated ongoing work is entirely
different. Exactly. Repeated work requires a
very specific, consistent tone. It requires deeply
knowing the target audience. You have internal
company rules. Yeah. You have past business decisions
to consider. And in a quick chat, the AI... basically
forgets all of that. It has total amnesia. You
have to repeat your tone and rules every single
time. Honestly, I have a vulnerable admission
to make here. Okay, let's hear it. Beep beep.
I still wrestle with starting every repeated
task in a blank chat. Oh, we all do it sometimes.
It just feels faster in the heat of the moment.
You just want an answer right now. Yeah, I do.
But over a month you waste countless hours re
-explaining yourself. It really makes me wonder
about the true value here. Is level one basically
just using Claude as a glorified short -term
search engine? Pretty much. It's a fast starter,
but it forgets everything by the next day. Which
perfectly highlights the core problem we need
to solve. We have to fix that blank chat amnesia.
Yes. So let's step up to level two, the beginner.
We fix this by building a persistent workspace.
Level two is entirely focused on creating continuity.
Your important work continues across multiple
conversations. It continues across your files
and your connected data sources. This level relies
heavily on three core features, projects, memory,
and past chat search. Right. Memory naturally
retains your specific working preferences over
time. Past chat search lets you easily find older
conversations. If you can just open a chat and
say, find the campaign direction from last week.
Exactly. Then you ask it to prepare the final
outline based on that. It seamlessly maintains
the historical thread. But it gets really interesting
when we bring in connectors. You can actually
connect the AI to the information you already
use. Yeah, this is a huge step up. Google Drive,
Gmail, Slack, Google Calendar, Microsoft 365.
Wow, that's a lot. Your real... actionable context
already sits inside those apps. Connectors pull
that securely approved information right into
your active conversation. So you don't have to
manually collect every single detail anymore.
You don't have to constantly switch tabs to copy
and paste. You can just ask it to review a specific
client email thread. Right. Or review the latest
strategic brief directly from Google Drive. Let's
look at a very specific, practical example here.
Creating a highly structured meeting summary.
You upload your messy, raw client notes. Yeah,
we've all been there. And you want a professional
Word document out of it. The prompt for this
needs to be very deliberate. You ask it to clearly
include the meeting background. You explicitly
ask for the confirmed decisions. You ask for
a list of questions that still need confirmation.
And finally, you demand a next actions table.
That table must include the responsible person.
and the specific deadline. But here is absolutely
the most important part of that workflow. You
give the AI a very strict, unbreakable rule.
Which is? If any information is missing, Claude
must write, not confirmed. It is absolutely not
allowed to guess or fill in the blanks. I like
to think about it this way. Level one is a public
whiteboard that gets wiped clean every night.
I like that. Level two is a dedicated office
desk where your files stay exactly where you
left them. That's a perfect way to picture the
difference. It reliably turns messy inputs into
clearly structured files of files you can actually
review, trust, and use in your job. But I do
have a lingering concern here. With all those
connected apps, can we trust it not to just invent
information? It's safer, but you still must review
the structured output before sending it anywhere.
Okay, so we've got our files beautifully structured
on our metaphorical desk, but I'm still the one
opening the folders and doing the actual manual
labor. Right. I'm still clicking and dragging.
Exactly. And that bottleneck is why you have
to level up again. Welcome to level three, the
intermediate. We've mastered text outputs. Now
we give the AI actual hands. We're talking about
a feature called Claude Cowork. This is where
it actively starts operating your computer for
you. It handles complex multi -step tasks directly.
It moves way beyond just reading your text files.
It actually starts manipulating the files on
your machine. Okay. So imagine you have a wildly
messy downloads folder. It's just stuffed with
random invoices, notes, and PDFs. You can give
Cowork a very specific multi -step directive.
You literally tell it to sort that folder by
file type. You tell it to rename every single
file to a standard format, like year, month,
day. Then you ask it to summarize the contents
of all those files. And if a file is unreadable
or unclear, it doesn't just crash, it neatly
moves it to a dedicated folder. Like a needs
review folder. Exactly. It does all the tedious
heavy lifting for you. But we really need to
talk about safe file access here. This is absolutely
crucial. When you give an AI direct file access,
you must start small. You have to set up isolated,
protected folders. Specifically, you should have
three distinct folders for this. Right. Source
files, working files, and outputs. Let's break
that down. Source files are the read -only documents
it can look at. Working files are the temporary
sandbox where it actively processes data. Outputs
are the final finished results for you to manually
check. Exactly. You never let it loose on your
main hard drive. That's just asking for a disaster.
This isolated structure leads to something really
powerful, though. Reusable skills. Oh, yeah.
When a tedious task repeats every single week,
you save it as a skill. Let's use a weekly client
report generator as a solid example. You build
a custom skill to process marketing data every
Friday. OK. You establish strict rules for the
output. You require five specific sections every
single time it runs. So you'd tell it, I need
an executive summary at the very top. It's a
short, crisp summary of the week's performance.
Right. And then you force it to extract the key
results. It pulls the important, verified metrics
directly from the uploaded data. Right. And you
want to compare those numbers to the previous
week. So you add a section for important changes.
Yeah, exactly. You're building a reliable, repeatable
template. And you'd probably want it to flag
anything that's missing, too. Definitely. That's
your open questions section. It lists any unclear
data points. Then it always ends with a clear
next actions table. Action, owner, and deadline.
Once you save that specific skill, your weekly
workflow changes entirely. How so? You just upload
the fresh raw data each week. You hit run on
the skill. It automatically follows the exact
same five -step process without you managing
it. You can even schedule these simple tasks
to run automatically. Say you're using a cloud
desktop application. Yeah. You could easily set
up a customized briefing for 7 .30 p .m. every
weekday. It quietly checks your connected sources
in the background. It stands Gmail. It checks
your calendar. It reads your Slack messages.
It pulls all that context together. Then it prepares
a short summary of tomorrow's meetings and any
pending actions. It feels incredibly powerful.
But I really have to ask this. Isn't giving AI
direct file access a recipe for accidentally
deleting your hard drive? Only if you're reckless.
Always use copy files in isolated folders to
test first, sponsor. We're back! So we just covered
automating desktop chores in Level 3. Now we
really scale things up. We do. Welcome to Level
4, the Advanced Builder. This is a major jump.
This is where we introduce Claude code. We're
moving away from simple folder sorting tasks.
We're getting into complex multi -file project
engineering. This requires a real dedicated project
structure. And crucially, it requires a Claude
.md file. Let's quickly define that jargon, a
simple text file that tells the AI your project
rules. It basically acts like a strict working
guide for the system. It clearly defines the
overarching project goal. It explicitly explains
what all the main folders are actually used for.
Right. It lists the specific files the AI is
allowed to edit. And crucially, it lists the
files it must absolutely leave unchanged. It
also tells the AI exactly how to run your internal
tests. And it defines what the final report format
should look like. But there is a very critical
step here that you cannot skip. You must ask
the AI to plan and explain its approach first.
Yes. It has to do this before it makes any actual
edits. It's like asking a contractor for blueprints
before they knock down a wall. You prompt it
to read the folder structure. You ask for a detailed
step -by -step plan. It needs to explain which
files will change and exactly why. You review
that plan. You approve it. Only then does the
actual coding work begin. As these projects get
bigger, things naturally get much more complicated.
One single session can quickly become overloaded
and confused. Yeah, for sure. So we have to deliberately
split the workout. We split big work into parallel
sessions. We use specialized tools like sub -agents
and work trees. One stream handles the front
-end layout. Another stream prepares the backend
tests. A third stream carefully reviews the overall
logic. This keeps the different work streams
entirely separate and clean. They happen at the
exact same time. but they don't accidentally
interfere with each other's code. And you always
have a mandatory non -negotiable review step
built in. The AI absolutely must check the result
before you accept the files. It must run all
the available system checks. If a check fails,
it has to explicitly explain the issue. It fixes
the error itself. It runs the check again. Finally,
it prints out a list of every single changed
file. You carefully look at that list. You verify
the changes. Then you formally consider the task
complete. But I'm genuinely curious about the
mechanics of this process. Why bother splitting
tasks into parallel sessions instead of just
one giant prompt? To keep the AI focused, preventing
it from getting confused, and mixing up changes.
That makes perfect sense. Clear rules. Clear
inputs. Clear safety checks. Which finally brings
us to the absolute summit of this framework.
Level five, the architect. This is fully autonomous
infrastructure. We're completely removing the
human from the active day -to -day loop. We're
finally entering the realm of true background
automation. You've already set the strict rules
in Level 4. Now, the complex workflow runs without
you even sitting at the screen. But the hardest
part of Level 5 isn't actually technical. Beat.
It's trust. Trust is incredibly difficult here.
You're letting an AI touch real files and critical
business data in the background. Giving up that
control is scary. You have to build this autonomy
very, very slowly. At this advanced stage, tasks
start from automatic triggers. a time schedule,
a brand new email arriving, a specific GitHub
event, or an external API call. We use a system
called Cloud Routines for this. These are secure
cloud -based workflows. They run entirely on
Anthropic's own back -end infrastructure. They
don't rely on your local desktop being turned
on. So you can set a routine to automatically
review changed files when a pull request opens.
Or you could have it create a massive weekly
project summary every Friday afternoon. But we
desperately need safety mechanisms here. This
is exactly where hooks come in. Let's define
that term clearly. Safety gates that check the
AI's actions before and after. Right. There's
a pre -tool use hook. It acts just like a strict
security gate. Before the AI actually runs a
command, the hook checks it. If the proposed
action is risky, like deleting important files,
it blocks it instantly. It asks the AI to rethink
and correct the action. Then there's the post
tool use hook. After the tool successfully finishes,
this hook handles the necessary cleanup. It might
automatically format a text file. Or it might
send you a quick Slack notification that the
background task is done. The entire workflow
is fully automated. But those precise hooks keep
it tightly and safely controlled. You still want
to start this process very safely though. We
highly recommend starting with a daily private
morning briefing. Yes. Just let it run quietly
every morning at 6 a .m. It checks your upcoming
calendar. It safely scans your important emails.
Right. It reviews your missed slack threads.
It prepares a comprehensive summary. But it sends
that summary only to you. It doesn't email your
boss. You review it over coffee before taking
any action. Yeah, you let it run like this for
a full week. You check if it misses nuances or
messes up your actual priorities. You carefully
adjust the background instructions. Only after
definitively proved reliable do you give it a
more important workflow. Exactly. Beat. Whoa.
I mean, imagine truly scaling this up. Imagine
an AI autonomously running your complex workflows
in the background while you sleep. It's wild.
Perfect checks. Perfect balance. Waking up to
finished work. It's an absolutely amazing thought,
but it clearly demands immense caution in planning.
Which naturally raises a really big question
for me. How do we stop an autonomous system from
going rogue and sending a bad email? You use
those hooks to block risky actions and strictly
require human review first. Okay, let's bring
this all back down to earth for a minute. We
need a big idea recap to tie this together. The
core insight from all of this source material
is surprisingly clear. Advanced use isn't really
about writing better, more clever prompts. It's
entirely about clearer workflow design. You don't
just magically jump to level five. You don't
blindly rush into full automation. You have to
build the foundational structure first. Yeah,
you add proper folder structure, you add firm
safety limits, you add mandatory review steps.
That's how this technology becomes truly, reliably
useful. So here is your practical takeaway for
today. Look closely at your own workflow. Pick
just one repeated week task that annoys you.
Just one task and upgrade it by exactly one single
level. If you're stuck at level one, make a project.
If you already have a project, connect one live
data source. If you have connected sources, try
a basic co -work task. Build a safer, more structured
workflow. Add a mandatory review step. One single
intentional upgrade will teach you way more than
trying to build a massive autonomous system on
day one. It forces you to truly understand the
underlying mechanics. It forces you to actually
build trust with the tool. Step by step, level
by level. That's how you actually get advanced.
It's been a truly fascinating journey through
these five levels today, from the eager enthusiast
all the way up to the architect. But I want to
leave you with a final slightly provocative thought
to mull over. Beat. Let's say you successfully
level up. You reach a point where AI flawlessly
remembers your context, where it perfectly plans
your complex projects, where it autonomously
executes your daily routines with perfect hooks
and safety checks.