Transcription
So, I spent over 400 hours inside of Claude, and I've mastered it at a pretty high level. So, in this video, I'm going to take you through every level of Claude in just about 20 minutes and cover what challenges you need to overcome in order to break through into the next stage, step by step.
So, let's start with level one, the enthusiast. So, at this level, you open Claude, you ask a question, you get an answer, you close the tab. Maybe you have it help you write an email, maybe a quick script, maybe you ask it to explain something that you read. And that's basically it. That's level one.
A quick upgrade that most people miss at this level: paste screenshots. Claude can read images. Half the people stuck here are typing out what a screenshot would show in two seconds.
Now, here's why most people stay stuck at level one forever. They don't realize that Claude can hold context across conversations, that Claude can organize work into projects or plug into the tools that they already use every day. They keep treating it like a search bar that happens to return paragraphs. It's very useful, but it is the floor. You're saving maybe 30 minutes a day on small things.
So, the cheat code to level two is to create your first project. Pick something that you keep coming back to: your business, a side hustle, a recurring type of work. Drop in a few reference docs, write a quick system prompt about who you are and how you want Claude to respond, and now every chat inside that project starts preloaded. That one move is the doorway into level two, which is the beginner.
If you took the cheat code from level one and you created your first project, congratulations. You've already taken the biggest step, because projects are the spine of level two. Everything else you're about to learn either feeds into a project or builds on top of it.
So, picture this. You open a fresh chat next Tuesday inside of that project and you ask, "What was the thing that we decided about the Q2 launch last week?" And Claude pulls it up. It cites the conversation. It picks up right where you left off, and suddenly Claude isn't a stateless tool anymore. It's something with continuity.
Now, there are six more features that define this level, and they all stack on top of what you just set up. So, first, we have memory and past chat search. Claude can now remember things across conversations, like your role, your preferences, decisions that you made weeks ago. Memory works on every plan, including free. The ability to actually search and pull from past chats is a paid feature, but combined with your project's knowledge base, this is what kills the "starting from zero every time" problem pretty much forever.
Second, we have connectors. Slack, Google Drive, Gmail, GitHub, Notion, Calendar. There's over 50 of them. You just click the plus button in your chat, you pick the tool, you sign in with OAuth, and you're basically done. And now you can stop pasting. You can just start asking Claude to summarize threads from your channel last week, or pull the latest spec doc from Google Drive, or even check what's on your calendar for the week. It just goes and it gets it.
Third, we have file creation. This one's huge, and most people don't know it's shipped to everyone. Claude can now create real Excel spreadsheets with working formulas, PowerPoint decks, Word docs, and PDFs straight from the chat interface. Not just artifacts that you preview, but actual files that you can download and that you could send to a client. And free users have this ability, too. This is when chat stops being a brainstorming tool and starts being a deliverable tool.
Fourth, we have artifacts, but the version most people don't know about yet. You've probably seen artifacts before: the side panel where Claude, you know, builds a quick interactive thing. Most people think of it as like a code preview, but it's not, because now we have artifacts with persistent storage, and they remember data between sessions. They can call Claude's API directly, so the app you build can think for itself, and you can publish them with a public link. And that means a non-coder can sit down in a Claude chat, build a customer feedback tracker for their business, save it, send the link to their team, and have a working tool by launch. No low-code, no boilerplate, no custom development, just a conversation. Every time you open that artifact, it refreshes the data instantly.
Fifth, we have inline visuals. These are different from our artifacts, even though they sound similar. So, when a chart or diagram would explain something better than text, Claude just builds one inside of your conversation. You can click it, you can swap the chart type, you can ask Claude to add variables and update it live. You could also drop in something like a CSV and ask it to visualize what is on that document. You can compare two options side by side. So, the difference from artifacts is that these are ephemeral. They live in the chat, they change as the conversation evolves, and they don't save as files. This comes free on every plan, and they came to co-work last week, too.
Now, the sixth thing here is that Claude also lives inside of Excel, PowerPoint, and Word as native add-ins. These run inside the actual Microsoft apps. So, you could open Excel, you could activate the add-in, and Claude reads your multi-tab workbook, explains formulas with cell-level citations, and it can edit assumptions while preserving every dependency. PowerPoint can read your existing slide master, your fonts, your layouts, your brand colors, and you can build slides that match. Word also does the same thing for Word docs. And as of April 2026, all three share context across these apps. So you can analyze data in Excel, switch over to PowerPoint, and Claude can build the deck using that same analysis. So, if your day lives in Microsoft Office, then this is the integration that can change everything for you.
A quick note here on what's free versus paid in this section. We've got memory, file creation, and inline visuals work for everyone, but past chat search, persistent storage for artifacts, and the Office add-ins are Pro and up. So, if you want the full picture, that's where the upgrade pays for itself.
But think of it like this. Level one was a brilliant intern with no memory. Level two is that same intern, but now they remember every conversation. They've got, you know, a folder and project docs and stuff like that. And they can pull anything from your tools without asking. And at the end of the day, they can hand you a finished deck or a working tool that you can share with your team. And you can do real work here. You can save 5+ hours a week. This is where Claude starts paying for itself.
But here's the ceiling. Claude can't actually do anything on your machine, because you're still copying outputs into other tools. You're still executing changes yourself. You're still running certain things by hand. So, Claude chat is basically the conversation surface, and now you're about to outgrow it.
So, the cheat code to level three is to stop trying to make chat do everything. Open up Claude desktop and click the co-work tab. And that's where this next level starts.
So, level three, the intermediate. If you've ever found yourself thinking, "I wish Claude could just go do this on my computer instead of telling me how," then you're ready for level three.
So, quick note for my end-user folks watching this. Co-work is basically an end-user tool that lives on your computer with full file system access. You describe the outcome, Claude figures out how to get there. And if you're already automation-minded, then you'll feel right at home with Claude co-work.
So, picture this. You point at your downloads folder. Three months of PDFs, screenshots, random things, old invoices, and it's just chaos. But you tell it one time, "Can you go into the downloads folder, sort everything by type, rename everything consistently, write me a summary of what's in there?" And then you can go make a coffee, you can come back, and it'll be done. That is a legit co-worker.
But a quick heads-up before we dive in. Co-work is paid only. It comes with any Pro, Max, Team, or Enterprise plan. So, if you're still on the free and you've gotten this far, this is probably your sign to upgrade.
So, let's talk about five features that define this level. The first one is file system access. Claude Co-work runs the code in an isolated virtual machine, but with real read and write access to whatever folders that you grant it access to. So, it can't touch what you don't give it permission to touch, but what you do give it permission, it can completely own. It can read, edit, create, organize real work on real files.
Second, we have skills. Now, skills are also available in chat, but in this level, skills are reusable workflows that you define as a simple markdown file. You build a skill once, "weekly client reporting," and then you never have to explain that again. You just say, "Hey, generate this week's report." And Claude pulls up the skill, reads it, runs it, and then understands exactly what you want. And here's what's really cool. There are over 100 skills already published. There's 16 or more official ones from Anthropic, plus a whole community marketplace. Front-end design, PDF manipulation, Excel work, document creation, you name it. There's skills for marketing, there's skills for accounting, there's skills for advertising. So, you don't always have to build from scratch. You could search first, install with one command, and then you could customize that skill from there. Just be careful where you're downloading skills from. And same skills work from co-work to chat and Claude code. You build it once, you can run it anywhere.
Third, we have scheduled tasks. You can type `/schedule` in any co-work conversation, and Claude saves the task to run on a certain cadence that you pick. Daily stand-ups at 8 a.m., weekly competitor briefs every Monday or Friday, monthly reports. Now, one caveat with these scheduled tasks is your computer needs to be awake and the desktop app needs to be open. But you could also do routines, which are cloud-based scheduled tasks. And we'll talk more about some of this 24/7 type of stuff in level five.
But the fourth feature here is mobile control. You can pair your phone with your desktop using Dispatch. Now you can send tasks from anywhere. When you're commuting, when you're at the gym, when you're in a meeting, Claude works on your desktop while you're away, and it pings you when it's done. And this is when co-work stops feeling like a tool and it starts feeling like a legit co-worker.
Fifth, we have Claude Design. This is the newest piece of the ecosystem, and it is really cool. It's a separate Anthropic Labs product. It's included with your Pro plan. You describe a prototype, a slide deck, a landing page, or a one-pager in plain English, and Claude builds it and designs it, and then you're just able to through natural conversation refine it. You can do direct edits or you can have different tweaks. When this dropped, people started calling it the Figma killer instantly, and that should tell you something.
So, two things make Claude Design different from a normal AI design tool. First, it can read your whole brand. You can drop in a GitHub repo, your codebase, design files, brand guidelines, and it can build you what's called a design system. Does this from your colors, your fonts, your typography, all that kind of stuff, and then it applies that to every single project automatically. So your output looks like your brand instead of generic AI slop.
Second, when you're done, it packages everything into a handoff bundle for Claude code or for Canva, or just a zip file, whatever you want to do with that whole project, you can take somewhere else. So, a non-coder can design a working front end in Claude Design and then ship it to production through Claude Code without writing a single line of code. And that's a complete pipeline from idea to shipped product all inside of Anthropic.
Two more things worth knowing about. We've got plugins, which are pre-built bundles of skills and connectors and potentially hooks and agents that you just install in one click. And there's a whole marketplace of them now. And we have computer vision. So, for apps that don't have connectors, Claude can navigate them visually the way a human would, by, you know, clicking, typing, hitting tab, submitting. And that's available on Mac and Windows today.
Now, two reasons that people stall at this level. Some people get scared by anything that feels technical, and that's fair, but the next surface has a desktop app with no terminal needed. Others hit the co-work ceiling. It's safe and friendly, but less precise than what comes next. So, when you need like legit version control, real engineering rigor, or systems that clients would pay $5,000+ for, you might outgrow co-work. And this is the first level where you save, you know, 10+ hours a week. The first level where non-coders can sell automation as a service. If you're running an AI automation business, this is your minimum bar.
So, the cheat code to get to level four would be to set up a folder structure that Claude can rely on. You know, like an "about me" file, a templates folder, a projects folder, maybe an outputs folder. And you just tell co-work, "About me first. Never edit my templates. Always deliver to the outputs folder." And that structure is what makes Claude co-work feel like an actual co-worker instead of just an unpredictable virtual assistant.
Which brings us on to level four, where we get a little bit more advanced. So, Boris Churney, the guy who actually built Claude Code at Anthropic, runs five Claude sessions in parallel at the minimum every single day. He's got these on numbered terminal tabs, and each one is in its own isolated workspace, meaning they can't conflict each other, they can't see each other's files. He fires all of them off, and then he walks away, and he comes back to multiple completed pull requests that are ready for his review. And that's not parallel productivity. That's a different category of work.
And before any non-coder clicks off, the code tab inside of Claude Desktop has the same engine as the terminal version. So, you don't have to be in the CLI if you don't want to. The terminal is just faster once you've kind of gotten used to it, at least in my opinion. But stay with me.
Five things make level four click. The first is a `claude.md` file. This is basically just a markdown file in your project folder that Claude reads at the start of every session. It's got things like your tech stack or your naming conventions, who you are, and what this project's goal is. Things like, "Never do X," or "Never write with em dashes." The catch is that Claude reads this file on every single conversation. So, if it blows up, you're going to be paying more tokens for that consistently. So, keep that under about 200 lines. You can also push important details into separate files and reference them with, you know, `@filename`. So, Claude only actually reads them when it needs to read them.
Now, here's the move that separates level four users from everyone else. Every single time Claude makes a mistake, you say, "Hey, update your `claude.md` so that you don't make that mistake again." And Anthropic's own team does this. After a few weeks, it literally trains itself on how you work.
Second, we have plan mode. So, if you hit Shift+Tab twice, Claude will switch into plan mode. It reads your code, it presents a plan, it waits for your approval, it asks you questions. And there's actually a hidden setting called Opus Plan that takes us even further. It basically means that Opus does the planning, and Sonnet does the execution. So, you get the smart model where it matters most, and you get the cheaper model for the grunt work. It cuts your cost in half without losing quality.
Third, we have sub-agents. Specialized Claudes for specialized jobs. One for tests, one for security review, one for documentation. Each runs in its own context window, so the noise of the main session doesn't pollute the sub-agent. And also vice versa. The sub-agent doesn't pollute your main session. And you can have multiple of these sub-agents running in parallel. You're effectively building a small engineering team, but they just can't talk to each other. They communicate through that main session.
Fourth, we have work trees. So, you can type `claude-worktree <feature-name>`. Claude spins up an isolated Git workspace on its own branch. You could open another terminal and you can do it again. And now you've got two, three, or four Claudes working at the same time without their files ever overwriting each other. I think that three or four is usually the comfortable sweet spot when you're working on different features. And you can implement a feature in one, you can fix a bug in another, you can write tests in a third, and all of these, once again, can be running in parallel.
Fifth, we have MCP, but with a big asterisk. MCP, Model Context Protocol, lets you plug pretty much any external tool into Claude. But Anthropic's own docs say something that most people miss, which is when a CLI tool exists for the job, use the CLI instead of the MCP. Like for GitHub, or for AWS, or for Google Workspace. They use 60 to 70% fewer tokens than the equivalent MCP server, because nothing gets loaded into your context until you actually run it. When you do use MCP, Anthropic shipped a feature in January called tool search that auto-defers tool loading the moment your MCP overhead crosses 10% of your window. So, it cuts that overhead by 85% zero config. But the rule still holds: CLI first, API endpoints second, skills third, and MCP only when nothing else fits. At least that's the way I think about it.
Okay, so the power moves. Master your context window. That 1 million token window on Opus 4.7 still gets sloppy past, you know, about 50% capacity. So, two commands fix this. `/compact` summarizes older history into a tight summary so your session keeps going. So, you can run it proactively, not when you see warnings because it's already too late. You can also use `/context`, which shows where your tokens are going. Combine these with prompt caching, which is automatic in Claude Code, and your cost can drop 60 to 90% on long sessions.
You've also got auto mode plus focus. So, stop hitting "yes" 30 times a session. Hit Shift+Tab to cycle into auto mode, and Claude routes safe commands through a classifier instead of asking you. And you can also type `/focus` and it hides the intermediate steps so you only see the final result. And this is exactly how Boris runs his five parallel sessions. Once Claude is cooking, you switch focus to the next one.
We've also got the verification loop. So, Boris, once again from the Claude Code team, says, "This is the single most important thing that you can do at this level. Give Claude a way to check its own work." So, he pairs Claude Code with a Chrome extension so Claude can actually open up a browser, test the UI, and iterate until both the code works and the UX feels right. And he says, "This single habit has two to 3xed the quality of what he's gotten back." You can also have it take screenshots to make sure everything looks right. You can have it just, you know, get in the cycle of not coming to you with a PR until it's tested it itself.
You can also start building some custom `/commands`. So, if you ever find that you're typing the same prompt twice, turn it into a slash command. Boris uses one called `/commit-push-pr` dozens of times a day. It does the entire commit. It does everything just with one slash command now. And these live in the `.cloud` folder in a subfolder called `commands`. And you can share them with your team and you can share them across your organization.
Now, there are some other side tools that I wanted to talk about. So, there's one called `/re` or you can just hit Escape twice, I believe. And this drops a failed attempt out of context completely instead of polluting the session with corrections, and it just reverts back to one of those previous messages that you have sent. You can also do `/btw`, which lets you ask Claude a quick question mid-task. "What does this function do again?" And it doesn't actually break the flow or add any extra noise into that current main session's conversation history. And you can use `/branch`, which I think used to be called `/fork`. And this creates a fork of your current conversation at that exact point. So, you can try one approach in a branch, and you can jump back and you can try a different one. So, it's basically Git for your conversation, and that pairs perfectly with work trees. One for parallel files, one for parallel reasoning.
And then another one you can do: `/insights`. And this one's pretty underrated because it basically reads your past month of Claude usage and it generates a report on your patterns. So, what you do repetitively, where you waste tokens, what prompts you should turn into skills, and what to add to your `claude.md`. Most people have no data on how they actually use the tool. So, run this once a month, and it'll tell you exactly which habits to start building.
You can also play around with output styles. So, if you do `/output style new`, you can swap Claude Code's entire personality. Some built-in modes are default, explanatory, learning. You can kind of describe your own custom one. People build code reviewer models, no-fluff mode, documentation writer mode. It's how you make the same tool fit 10 different jobs.
So, if Claude chat was your intern, and Claude Co-work was an assistant, Claude Code is your engineering team. Each one can be specialized, working in parallel, all reporting to you. And most people stall at level four for one main reason, which is they're managing all the parallel work manually. They become their own bottleneck. They fire off Claudes, they watch them, they switch contexts. And that's not scaling. Everything they're doing requires them to kind of be sitting right there. And that's just babysitting. And this is where freelance and agency work becomes, you know, $5,000 to $15,000 projects. You're not building automations anymore. You're actually building real systems, real software, and clients will obviously pay accordingly.
So, the cheat code to get up to level five is to find the most repetitive thing that you're doing every single week when you're working with Claude Code. Maybe you're doing reviews or dependency checks, or you're manually executing different skills and different commands. And once you find some of those things that you're doing manually and repetitively, that's what's going to be your first Claude automation. And you build that once you get to level five.
So, level five is the architect. If you've ever just closed your laptop or turned off your computer and just wished that work was still happening, then you're ready for this level. Imagine this. Your laptop's closed, your power went out, you're at dinner, you're at the gym, and someone opens up a pull request on your repo, and Claude basically sees that, spins it up in the cloud, reviews the code, and posts detailed feedback with suggestions. And so by the time that you check your phone, everything's already done, and you didn't have to touch anything, and you didn't even know it happened. And that's level five.
So, three things make this real. Claude Routines are saved Claude Code configurations that run on Anthropic's cloud. Your machine stays off. So, earlier we talked about scheduled tasks, which required your machine to stay on, but these don't. And these can be triggered by three different things: on a schedule, on an API call, or in response to a GitHub event. So, a daily backlog triage every day at 8 a.m., you could have a weekly dependency audit on Mondays, or PR reviews the moment a pull request opens. This is when Claude becomes infrastructure besides just being a tool.
We've also got hooks, which are kind of like safety rails. Custom logic that fires at lifecycle events. So, pre-tool use hooks that block dangerous commands before they run, or post-edit hooks that auto-format every file that Claude touches. Or something like a stop hook that pings you on Slack when a long-running session finishes. You could even have hooks set up so that every time Claude responds to you, it sends you a noise notification so that you can actually switch back into your tab and see what happened. These are what make the difference between a cool demo and a production system that you actually trust with real work.
We've also got channels, which lets you control sessions from outside the terminal. So, from things like Discord or Telegram, or even iMessage if you're on Mac. And you could also set up custom webhooks for anything else. So, these come in two flavors. One way is where external events trigger Claude, like a calendar booking firing off a research agent that prepares a client briefing for your call. Or two-way, where you literally text Claude from your phone, and it works against your real codebase. And this is when it starts to feel more like the always-on infrastructure that we've been talking about.
So, there's a few other pieces that can layer on top of this. We've got headless mode and the Agent SDK. So, Claude Code can run with no human session at all. You pass it a prompt with `claude-p` and you get the output back. You can pipe it anywhere, like Slack or DataDog, or another Claude agent if you want. Then we have the Agent SDK, which gives you Python and TypeScript libraries to build your own product on top of Claude Code's engine. This is where you stop being a user and you start becoming more of just a builder.
There's also a cool feature called remote control, which bridges your local Claude Code session to the cloud mobile app and any browser if you want. So, just run `/remote-control`, scan the QR code or open up the link, and then you're in. You could go on a walk with just your phone, and you could still be coding from your phone because the session keeps running on your machine, but the phone is just kind of like the remote control.
So, we also have memory consolidation. So, there's this feature called AutoDream. If you want to check out a full video I made about that, I'll tag that right up here. But the short version is Claude Code can now have a background sub-agent that prunes your memory files between sessions. It can delete contradicted facts, it can merge duplicates, it can convert "yesterday" to actual dates. So, your session stops slowly drifting on stale information. It's basically going to start dreaming, which is exactly the way that humans kind of compress their memories and store things. So, it just does that. Now, you do have to turn the feature on, though.
So, like Opus 4.7 has a beta feature called task budgets. You give the agent a token target for an entire run. So, for thinking, for tool calls, for the result and the output, and that all gets counted against the budget. So, the model will see the budget and it will start to regulate itself and wrap up gracefully as the budget runs out, instead of hitting a wall mid-task. It's the cleanest way to cap autonomous agents that might otherwise run wild. It's not included in Code or Co-work yet. Right now, it's API only, I believe. But if you're shipping production agents, this is the lever for cost control.
You've also got agent teams, which is still experimental, but it's definitely worth knowing about because it's super cool. Multiple specialized Claudes coordinated by a lead agent. And unlike sub-agents, they can message each other. They can talk to each other like a shared channel. They have a shared task list. They share their findings. They challenge each other. You can make them debate. So, whenever I see that I've got a lot of my session left and I'm not going to hit it, I just spin up an agent team and test it out because they do use a lot of your tokens.
Another thing, Anthropic and Google both shipped protocols for this last year. So, MCP for tool access, Ato for agent-agent communication.
One more habit at this level: the highest leverage skill isn't building from scratch, but it's being able to discover and leverage what already exists. So, the community. There's been over 5,000 skills, over 800 MCP servers, probably more, and there's 3,000+ marketplaces out there. So, go on X, go on Reddit, see what people are using for specific use cases, and see how you could pull in an open-source, you know, public repo and then use it in your projects and customize it for your use case.
Now, here's the most important part in this video, and I want you to actually pause on it and think about it for a sec. The stall at level five isn't technical. It's about trust. Because almost everyone can set up a Claude routine, but they won't because handing the steering wheel to a system that runs while you're asleep feels reckless, especially if you don't actually know what's really going on under the hood. The fix to this is the same fix as learning to drive. You don't start on the highway. You start in an empty parking lot. You pick a low-stakes routine, a daily stand-up summary that only goes to you, something that's not sent externally. Weekly dependency audit. You know, watch these things run every day. Watch them run for weeks and don't touch them. And once you trust them enough, you'll learn to trust the next 10 runs. Roll things out responsibly. Roll things out carefully. Just because you publish a Claude routine doesn't mean that you can actually set it and forget it, especially if it's pretty autonomous and pretty agentic. But if you're deploying an automation that literally just takes data from one place and puts it somewhere else, those are the ones that you typically can trust because they're pretty deterministic in nature, rather than a skill or these Claude Code agents that are more non-deterministic, but they're extremely more powerful. So, if you sort of think about it like that, trust is the main thing standing between level four and level five. And that is a skill that just takes some reps and takes some time, rather than just like a feature you could install.
So, there you have it. Those are the five levels of Claude, from enthusiast all the way up to architect. As always, this entire document and every other free resource that I've ever given out on YouTube will be dropped inside of my free school community. And if you want to check out my plus group for comprehensive support and for a path to making your first dollar with AI, then the link for that will also be down in the description. But if you found this video useful, please give it a like and leave a comment down below if you'd want to see another video covering all of the levels of AI this time, rather than just Claude. So, I'll see you guys in the next one.