Most people using Claude are stuck one level below their actual potential. Not because they lack the skill to operate the next surface, but because they cannot picture what the next ceiling looks like, so they keep optimising the one they're already on.
This essay is the map I wish I'd had when I started. Five levels, from "opens a tab and asks a question" up to "has Claude running pull-request reviews on a closed laptop." Each level has a defining capability, a real ceiling, and a single move that gets you to the next floor. If you read it as a self-diagnosis rather than a checklist, it does its job.
Level 1. The Enthusiast
You open Claude, ask a question, get an answer, close the tab. Maybe a script. Maybe a polished email. Maybe an explanation of something you read. The interaction is stateless and the gain is real but small. about 30 minutes a day on small things.
The one upgrade most Level 1 users miss is screenshots. Claude reads images. Half the people who type out what's on their screen could have dragged the screenshot in and been done in two seconds. Start there.
The ceiling at Level 1 is the absence of memory. Every chat begins from zero. You re-explain who you are, what you're working on, and what tone you want. The fix is the doorway into Level 2: build your first Project, drop in a couple of reference docs, write a short system prompt that explains who you are and how you want Claude to respond, and use that project as your default chat. Every conversation inside it now starts preloaded.
That single move is what separates someone who treats Claude as a search bar from someone who treats it as a persistent collaborator.
Level 2. The Beginner
Projects are the spine of Level 2. Everything else stacks on top of them.
Six features define the level:
Memory and past-chat search. Claude can now retain things across conversations. your role, your preferences, decisions you made last quarter. The basic memory works everywhere. The ability to search and pull from past chats is paid, and combined with a project's knowledge base it pretty much kills the "start from zero every time" problem.
Connectors. Slack, Drive, Gmail, GitHub, Notion, Calendar. over fifty of them, one-click OAuth, no more pasting. "Summarise the threads from #launch last week" or "pull the latest spec doc from Drive" stops being a copy-paste workflow and becomes a sentence.
File creation. Real Excel files with working formulas, real PowerPoint decks, Word docs, PDFs. These aren't artifacts you preview. they're files you download and send to a client. This is the point where Claude stops being a brainstorming tool and starts being a deliverable tool.
Artifacts with persistent storage. The side-panel apps now remember data between sessions, can call Claude's API directly, and can be published as a public URL. A non-coder can build a customer feedback tracker in a conversation, share the link with their team, and have a working tool by end of day.
Inline visuals. When a chart explains something better than text, Claude builds one in the chat. Click it, swap the type, ask for variables, watch it update live.
Office add-ons. Claude lives inside Excel, PowerPoint, and Word natively. As of April this year, all three share context across apps. Analyse data in Excel, switch to PowerPoint, the model can build a deck using that same analysis.
The ceiling at Level 2 is real but specific: Claude still can't actually do anything on your machine. You're copying outputs into other tools, executing changes by hand, running things manually. Chat is the surface, and you're about to outgrow it.
The cheat code to Level 3 is to stop trying to make chat do everything. Open Claude Desktop and click the Co-work tab.
Level 3. The Intermediate
Co-work runs Claude on your computer with real filesystem access inside an isolated VM. You describe the outcome, and Claude figures out how to get there. Point it at your downloads folder. three months of PDFs, screenshots, invoices, chaos. Tell it once to sort, rename, and summarise. Walk away. Come back to a tidy folder and a written summary.
Five features anchor the level:
Filesystem access. Real read and write on whatever directories you grant. Nothing else.
Skills. Reusable workflows defined as simple markdown files. Build one for "weekly client report" and you never explain that process again. There are over a hundred published skills already, plus an official set from Anthropic and a growing community marketplace. Search before you build.
Scheduled tasks. Type /schedule in a Co-work conversation and the task runs on the cadence you pick. Daily stand-ups at 8am. Weekly competitor briefs every Monday. The caveat is that the machine has to be awake. for true always-on you need Level 5.
Mobile control. Pair your phone with the desktop and you can send tasks from anywhere. The desktop does the work while you're commuting or in a meeting and pings you when it's done.
Claude Design. The newest piece. A separate Anthropic Labs product that builds prototypes, landing pages, and decks from a plain-English brief. The two things that make it more than another AI design tool are that it reads your whole brand. drop in a GitHub repo, design files, or guidelines and it builds a design system that applies to every project. and that it packages output as a clean handoff bundle for Claude Code or Canva.
The ceiling at Level 3 is precision. Co-work is friendly and safe, but it's less rigorous than what comes next. When you need real version control, engineering-grade discipline, and systems that justify five-figure project fees, you've outgrown it.
The cheat code to Level 4 is to give Claude a stable folder layout it can rely on. An about-me.md, a templates/ directory you tell it never to touch, a projects/ directory it owns, and an outputs/ directory where deliverables land. That structure is what turns Co-work from an unpredictable assistant into something that feels like an actual coworker.
Level 4. The Advanced
This is Claude Code. The terminal version runs faster once you're used to it; the code tab inside Claude Desktop is the same engine if you'd rather not live in the CLI. Either way, this is where the tooling stops being friendly and starts being precise.
Five features define the level:
CLAUDE.md and the mistake-update habit
A markdown file at the root of your project that Claude reads at the start of every session. Tech stack, naming conventions, who you are, what the project is for, anything you find yourself re-saying. Keep it under about 200 lines. it loads every session, and tokens add up. The habit that separates people who plateau here from people who don't: every time Claude makes a mistake, update CLAUDE.md so it doesn't make that mistake again. After a few weeks, the file trains itself on your taste.
Plan Mode and the Opus-Plan trick
Hit Shift+Tab twice and Claude switches into plan mode. it reads, plans, asks questions, waits for your approval before touching anything. There's a hidden setting called Opus-Plan that uses Opus for the planning step and Sonnet for execution. You get the smart model where judgement matters and the cheaper one for grunt work. Cuts the cost roughly in half without dropping quality. (For a deeper dive on cost-cutting at this level, see my piece on Claude prompt caching patterns.)
Sub-agents and worktrees. Sub-agents run in their own context windows. one for tests, one for security review, one for docs. The noise stays where it belongs. Worktrees take parallelism further: claude-worktree feature-name spins up an isolated git workspace on its own branch, and you can run three or four Claudes side by side without their files ever overlapping. The most productive Claude Code users I know — including the ones who've fully migrated to Cursor 3's agents-first interface — keep four sessions running. one feature, one bug, one set of tests, one investigation. They fire them off, walk away, come back to four ready-to-review pull requests.
MCP, used correctly
MCP lets you plug external tools into Claude, but the principle that earns its keep is CLI first. Anthropic's own docs say it: a CLI tool uses 60-70% fewer tokens than the equivalent MCP server, because nothing loads into context until you actually run it. The order I follow is CLI first, API endpoints second, skills third, and MCP only when nothing else fits. When you do use MCP, tool search auto-defers tool loading the moment overhead crosses about 10% of your window. cuts the overhead by roughly 85% with zero config. The rule still holds, though.
The verification loop. This is the single highest-leverage habit at this level. Give Claude a way to check its own work. Pair Claude Code with a browser extension so it can open the app it just built, click around, take screenshots, and iterate until both the code and the UX are right. The habit roughly doubles the quality of what you get back. and it ends the pattern of Claude declaring a task done that obviously wasn't.
A handful of smaller commands compound: /compact proactively summarises older history (run it before you see warnings, not after), /context shows where your tokens are going, auto mode skips routine yes-prompts, /focus hides intermediate steps so you only see the final result. /rewind (or Esc twice) drops a failed attempt out of the conversation entirely so it doesn't pollute the rest of the run. /btw lets you ask a quick aside without breaking flow. /branch forks the conversation so you can try two approaches and pick the winner. /insights reads your past month of usage and tells you which prompts to turn into skills, which habits to bake into CLAUDE.md, and where you're burning tokens. Run it monthly. Custom /commands live in .claude/commands/ and let you turn repeated prompt patterns into one-keystroke actions. /output-style new swaps Claude's entire personality. code reviewer, no-fluff mode, documentation writer, whatever fits the task.
If chat at Level 2 was an intern with memory and Co-work at Level 3 was a coworker, Claude Code at Level 4 is an engineering team. Specialised, parallel, all reporting up to you.
The ceiling: you're now the bottleneck. The work runs in parallel, the management doesn't. Watching four sessions, switching contexts, reviewing outputs. that's not scaling, that's babysitting. The next floor doesn't have you sitting at the keyboard at all.
Level 5. The Architect
If you've ever closed your laptop and wished work was still happening, you're ready for Level 5. The defining product here is Cloud Routines. saved Claude Code configurations that run on Anthropic's cloud while your machine stays off.
Three features carry the level:
Cloud Routines. Trigger them three ways: on a schedule, on an API call, or in response to a GitHub event. Daily backlog triage at 8am. Weekly dependency audits on Mondays. Pull-request reviews the moment one opens. This is when Claude stops being a tool and starts being infrastructure.
Hooks. Safety rails that fire at lifecycle events. A pre-tool-use hook blocks dangerous commands before they run. A post-edit hook auto-formats every file Claude touches. A stop hook pings you on Slack when a long session finishes. Hooks are what separate a cool demo from a system you actually trust with production work.
Channels. Control sessions from outside the terminal. Discord, Telegram, iMessage, custom webhooks. One-way (a calendar booking fires off a research agent that prepares a client briefing) or two-way (you text Claude from your phone and it works against your real codebase). Combined with headless mode (claude -p) and the Agent SDK (Python and TypeScript libraries that let you build products on top of the Claude Code engine — I cover production patterns for it in Claude Agent SDK in production), this is where you stop being a user and start being a builder.
A few smaller pieces matter at this level. Task budgets let you give an agent a token cap for an entire run, and the model regulates itself toward a graceful finish instead of hitting a wall. Remote control bridges your local Claude Code session to your phone or any browser. Memory consolidation lets a background sub-agent prune your memory files between sessions so they stop drifting on stale information. Agent teams let multiple specialised Claudes coordinate through a lead agent, message each other, debate, and converge on an answer. Still experimental, but worth a session of your time the next time you have spare context to spend.
The ceiling at Level 5 isn't technical. It's trust.
The Trust Gradient
Almost everyone reading this can configure a Cloud Routine. Almost nobody does. The blocker is not the YAML; it's the feeling of handing the steering wheel to a system that runs while you're asleep. It feels reckless.
The fix is the same one you used learning to drive. you didn't start on the highway, you started in an empty parking lot. Pick the lowest-stakes routine you can imagine. A daily stand-up summary that only goes to you. A weekly dependency audit. Something deterministic enough that the worst case is "it didn't run today." Watch it for a week. Then two. Once you've watched twenty clean runs you'll be ready to trust the twenty-first, and the twenty-second is where the leverage starts to compound.
Trust is a reps problem, not a configuration problem. Skipping it is how people get burned — and most of the production failure modes I see in AI agents trace back to teams that skipped the parking-lot phase. The builders shipping autonomous Claude systems that actually work spent six months at Level 4 first.
The Practitioner's Take
The levels aren't a checklist; they're a diagnosis. The point of writing them out isn't to make you race to Level 5. it's to make the next move legible from wherever you currently are.
Find the level you're stuck at. Run the cheat code for it. Sit there for a week, doing real work, until the new surface feels obvious instead of effortful. Then re-read this. The people I've seen get the most leverage out of Claude are not the ones who jumped straight to writing agent teams. they're the ones who spent enough time at each floor that they actually knew what they were giving up by climbing.