Jonathon's AI Wiki

Every Level of Claude — 5-Level Mastery Framework (Nate Herk)

18 min read

Source: raw/Every_Level_of_Claude_Explained_in_21_Minutes.md — YouTube tutorial ZRb7D6R64hM, ~21 min. Creator presumed Nate Herk (AIS+ “plus group” branding signals match — “free school community” + “path to making your first dollar with AI” tagline; see Open Questions for verification).

A taxonomy-driven walkthrough of the entire Claude product surface as a 5-level mastery ladder — Enthusiast → Beginner → Intermediate → Advanced → Architect — each level with explicit “cheat code” transitions that unlock the next stage. Distinct from the existing Nate Herk corpus (AIOS masterclass, Codex 1-hour course) in that this video is a surface-spanning overview rather than a single-product deep-dive — its value is the level-progression model itself, not the feature catalog underneath.

The 5 levels at a glance

LevelSurfaceStuck patternCheat code to next levelTime-savings claim
1. Enthusiastclaude.ai chatTreats Claude as a smarter search bar; doesn’t know about projects, context, or toolsCreate your first project — drop in reference docs + a system prompt~30 min/day on small tasks
2. Beginnerclaude.ai chat + projects + connectorsStill copying outputs into other tools; runs everything by handOpen Claude Desktop, click the Cowork tab5+ hr/week
3. IntermediateCoworkCowork ceiling — friendly but less precise than CLI; managing parallel work manuallySet up a folder structure (about_me, templates/, projects/, outputs/) and tell Cowork the rules10+ hr/week — “minimum bar for selling AI automation as a service”
4. AdvancedClaude Code (terminal or Desktop “code” tab)Babysitting parallel sessions — becomes their own bottleneckFind the most repetitive weekly thing → build it as your first cloud automation$5K–15K freelance/agency projects
5. ArchitectRoutines + Hooks + Channels + Agent TeamsTrust — “handing the steering wheel to a system that runs while you’re asleep feels reckless”Build trust gradually — start with a low-stakes routine, watch it run for weeks, then add the next 1024/7 work happens without you

Key Takeaways

Level 1 — Enthusiast (claude.ai chat, single-turn)

  • Stuck-here signal: treats Claude as a smarter search bar that returns paragraphs; doesn’t know context persists, doesn’t know about projects or tools.
  • Quick upgrade most miss: paste screenshots — Claude reads images natively, half the people stuck here are still typing out what’s on the screen.
  • Cheat code to L2: create your first project. Pick something recurring (business, side hustle), drop in reference docs, write a system prompt about who you are and how Claude should respond. Every chat in that project now starts preloaded.

Level 2 — Beginner (claude.ai projects + connectors + Microsoft Office)

  • Projects are the spine. Continuity across conversations — “what did we decide about the Q2 launch last week?” → Claude pulls it up with citation. Six features stack on top:
  • Memory and past-chat search. Cross-conversation recall of role/preferences/decisions. Memory works on every plan including free; past-chat search is paid-tier.
  • Connectors (50+). Slack / Google Drive / Gmail / GitHub / Notion / Calendar. One-click OAuth. Replaces paste-to-prompt workflow with “summarize threads from marketing last week” or “pull the latest spec doc.”
  • File creation (free for everyone). Real Excel with working formulas, PowerPoint decks, Word docs, PDFs — straight from chat. Downloadable, client-shippable. “Chat stops being a brainstorming tool and starts being a deliverable tool.”
  • Artifacts with persistent storage + API access. Build a customer-feedback tracker in chat, save it, send a public link — “no lovable, no bolt, no custom development, just a conversation.” Refreshes data on each open.
  • Inline visuals (different from artifacts). Charts/diagrams built inside the conversation; click to swap type, ask Claude to add variables, drop in CSVs. Ephemeral — live in chat, don’t save as files. Free on every plan; came to Cowork the same week as the video.
  • Microsoft Office native add-ons. Claude inside Excel/PowerPoint/Word — reads multi-tab workbooks with cell-level citations; PowerPoint reads slide master/fonts/layouts/brand colors. As of April 2026, all three share context — analyze in Excel, switch to PowerPoint, deck builds from that analysis.
  • Free vs paid split at L2: memory + file creation + inline visuals = everyone. Past-chat search + persistent artifact storage + Office add-ons = Pro and up.
  • Ceiling: Claude can’t do anything on your machine — you’re still copying outputs into other tools, still running things by hand. Cheat code to L3: open Claude Desktop, click Cowork.

Level 3 — Intermediate (Cowork)

  • Paid-only gate. Pro / Max / Team / Enterprise. “If you’re still on free and you’ve gotten this far, this is your sign to upgrade.”
  • File-system access. Cowork runs code in an isolated VM but with read/write access to the folders you grant it. “It can’t touch what you don’t give it permission to touch, but what you do give it, it can completely own.”
  • Skills as reusable workflows. Define once in markdown, never re-explain. 100+ already published — 16+ official from Anthropic plus a marketplace (front-end design, PDF manipulation, Excel work, marketing, accounting, advertising). Same skills work in Cowork, chat, and Claude Code. “Build once, run anywhere.” Caveat: verify provenance before installing community skills.
  • Scheduled tasks (/schedule). Daily stand-ups 8am, weekly competitor briefs, monthly reports. Caveat: machine must be awake + Desktop app open. For 24/7 use → Routines (cloud-based, see L5).
  • Dispatch (mobile control). Pair phone with desktop, fire off tasks from the gym/commute/meeting, Claude works while you’re away and pings when done. “This is when Cowork stops feeling like a tool and starts feeling like a legit co-worker.”
  • Claude Design — “the Figma killer.” Anthropic Labs product, included with Pro. Describe a prototype/deck/landing page in plain English; Claude builds it; refine through natural conversation. Two differentiators:
    1. Reads your whole brand — drop in GitHub repo, design files, brand guidelines → builds a design system (colors, fonts, typography) and applies it to every project.
    2. Handoff bundle — packages output for Claude Code, Canva, or zip. “A non-coder can design a working front end in Claude Design and ship it to production through Claude Code without writing a single line of code.”
  • Plugins. Pre-built bundles of skills + connectors + hooks + agents, one-click install. Whole marketplace exists.
  • Computer Use. For apps without connectors — Claude navigates them visually (click, type, tab, submit). Mac + Windows today.
  • Why some stall here: (a) anything technical feels scary — fair, but the Desktop “code” tab has the same engine as the terminal version, no CLI required; (b) Cowork ceiling — safe and friendly but less precise than what comes next. Need version control / real engineering rigor / $5K+ client systems → outgrow Cowork.
  • Cheat code to L4: set up a folder structure Claude can rely on (about_me, templates/, projects/, outputs/) and tell Cowork the rules: “read about_me first, never edit templates/, always deliver to outputs/.”

Level 4 — Advanced (Claude Code terminal or Desktop “code” tab)

  • Anchor data point: Boris Cherny (Anthropic, built Claude Code) runs 5 parallel Claude sessions minimum daily — numbered terminal tabs, each in an isolated workspace so they can’t conflict. Fires them off, walks away, returns to multiple PRs ready for review. Parallel productivity → different category of work.
  • Five things make L4 click:
    1. [[claude-ai/claude-md|CLAUDE.md]] file. Markdown loaded every session — tech stack, naming conventions, project goal, “never do X” rules. Keep under ~200 lines (cost per session). Push details into separate files referenced with @filename so Claude reads them only on demand. The L4-vs-everyone-else move: every time Claude makes a mistake, say “update your CLAUDE.md so you don’t make that mistake again.” Anthropic’s own team does this. After weeks, it literally trains itself on how you work.
    2. Plan Mode (Shift+Tab Shift+Tab). Reads code, presents plan, waits for approval, asks clarifying questions. Hidden “Opus Plan” setting — Opus does the planning, Sonnet does the execution. Smart model where it matters, cheap model for grunt work. “Cuts cost in half without losing quality.”
    3. Sub-agents. Specialized Claudes for specialized jobs — tests, security review, documentation. Each runs in its own context window so noise doesn’t pollute. Multiple sub-agents can run in parallel. “A small engineering team that can’t talk to each other but communicates through the main session.”
    4. Worktrees (claude --worktree feature-name). Isolated git workspace on its own branch. Open another terminal, do it again. Two/three/four Claudes working in parallel without ever overwriting each other’s files. Implement a feature in one, fix a bug in another, write tests in a third — all simultaneously. Sweet spot: 3-4 parallel.
    5. MCP — with a big asterisk. Lets you plug any external tool into Claude. But Anthropic’s own docs say: when a CLI exists, use the CLI instead of MCP. Source: GitHub / AWS / Google Workspace CLIs use 60-70% fewer tokens than equivalent MCP servers (nothing loaded into context until you run it). When you do use MCP, tool search (shipped Jan 2026) auto-defers tool loading once MCP overhead crosses 10% of the window → cuts overhead 85% zero-config. Decision order: CLI first → API endpoints second → skills third → MCP only when nothing else fits. This is the third independent data point for the CLI-over-MCP thesis, alongside TinyFish’s 87% reduction and Printing Press’s 35× / 100%→72% reliability measurement (see also Moritz Kremb’s Claudia OS for operator confirmation).
  • Power moves at L4:
    • Context window mastery. Opus 4.7’s 1M window “still gets sloppy past about 50% capacity.” /compact proactively (not when warnings appear — already too late). /context shows token allocation. Combined with auto prompt caching → 60-90% cost drop on long sessions.
    • Auto mode + focus. Shift+Tab cycles into auto mode → safe commands route through a classifier instead of asking. /focus hides intermediate steps. “This is exactly how Boris runs 5 parallel sessions — once Claude is cooking, switch focus to the next one.”
    • Verification loop (Boris’s “single most important habit”). Give Claude a way to check its own work. Boris pairs Claude Code with a Chrome extension so Claude opens a browser, tests UI, iterates until both code works and UX feels right. “2-3× the quality.” Variations: screenshots, “don’t come to me with a PR until you’ve tested it yourself.”
    • Custom slash commands. Typed the same prompt twice? Turn it into a slash command. Boris uses /commit-push-pr dozens of times daily. Live in .claude/commands/. Shareable across team.
    • Side-tools worth knowing: /re (or Escape Escape) — drops a failed attempt out of context completely, reverts to a previous message (no correction-pollution). /btw — quick question mid-task without breaking flow or adding noise to history. /branch (formerly /fork) — fork conversation at exact point; “git for your conversation; pairs perfectly with worktrees — one for parallel files, one for parallel reasoning.” /insights — reads past month of Claude usage, generates report on patterns (what you repeat, where you waste tokens, what to convert to skills, what to add to CLAUDE.md). “Most people have no data on how they actually use the tool. Run once a month.” /output-style new — swap Claude Code’s entire personality (default / explanatory / learning / custom — code-reviewer mode, no-fluff mode, documentation-writer mode). “How you make the same tool fit 10 different jobs.”
  • Why people stall at L4: they manage parallel work manually → become their own bottleneck. Fire off Claudes, watch them, switch contexts. “That’s not scaling — that’s babysitting.”
  • L4 economic claim: “$5K-15K freelance/agency projects. You’re not building automations anymore — you’re building real systems, real software, and clients pay accordingly.”
  • Cheat code to L5: find the most repetitive weekly thing you’re doing manually → that’s your first cloud automation.

Level 5 — Architect (Routines + Hooks + Channels + Agent Teams)

  • “You closed your laptop and wish work was still happening” signal. PR opens on repo while you’re at dinner → Claude spins up in cloud, reviews code, posts feedback. By the time you check your phone, done. You didn’t touch anything and didn’t know it happened.
  • Three core pieces:
    • Routines. Saved Claude Code configurations that run on Anthropic’s cloud — your machine stays off. Trigger on schedule, API call, or GitHub event. Daily backlog triage 8am; weekly dependency audit Mondays; PR reviews the moment a PR opens. “This is when Claude becomes infrastructure, not just a tool.”
    • Hooks (safety rails). Custom logic at lifecycle events. Pre-tool-use hook blocks dangerous commands before they run. Post-edit hook auto-formats every file Claude touches. Stop hook pings you on Slack when a long-running session finishes. Notification hook so every response → notification → switch tabs to see what happened. “The difference between a cool demo and a production system you trust with real work.”
    • Channels. Control sessions from outside the terminal — Discord, Telegram, iMessage (Mac), custom webhooks. Two flavors: (a) external → Claude — calendar booking fires a research agent that prepares a briefing for your call; (b) two-way — text Claude from your phone, it works against your real codebase. “When it feels like always-on infrastructure.”
  • Additional L5 layers:
    • Headless mode + Agent SDK. claude -p runs Claude Code with no human session, pipe output anywhere (Slack, DataDog, another Claude agent). Agent SDK (Python + TypeScript) lets you build products on top of Claude Code’s engine. “Stop being a user, start being a builder.”
    • Remote Control. Bridges local Claude Code session to mobile app or browser. /remote-control → QR code → walking with just your phone, still coding against the session running on your machine. “Phone is just the remote control.”
    • Memory consolidation (autodream). Background sub-agent prunes memory files between sessions — deletes contradicted facts, merges duplicates, converts “yesterday” to actual dates. “Stops slowly drifting on stale information.” (Feature must be turned on.)
    • Task budgets (Opus 4.7 beta). Give the agent a token target for an entire run — thinking + tool calls + output all count. Model sees the budget, regulates itself, wraps up gracefully at limit instead of hitting a wall mid-task. API only currently, not Claude Code or Cowork yet. “Cleanest way to cap autonomous agents.”
    • Agent Teams (experimental). Multiple specialized Claudes coordinated by a lead agent. Unlike sub-agents, they can message each other — shared channel, shared task list, shared findings, can debate. Heavy token spend. Anthropic + Google both shipped protocols last year: MCP for tool access, A2A for agent-to-agent communication.
  • Highest-leverage skill at L5: discover and leverage what already exists, not build from scratch. 5,000+ skills, 800+ MCP servers, 3,000+ marketplaces in the community. Search X / Reddit for use-case-specific picks; pull open-source repos and customize for yours.
  • The L5 stall is trust, not tech. “Almost everyone can set up a routine, but they won’t — handing the steering wheel to a system that runs while you’re asleep feels reckless.” Fix is the driving-instructor analogy: don’t start on the highway. Pick a low-stakes routine (daily stand-up summary that only goes to you), watch it run for weeks, don’t touch it. Trust the next 10 runs. Deterministic data-mover routines are safer to trust early; non-deterministic skill/agent runs need more reps. “Trust takes reps, not features you install.”

Where it fits in the wiki

  • Third Nate Herk overview in the claude-ai topic alongside Build & Sell Claude Code Operating Systems (Claude-Code-side AIOS masterclass) and Master 97% of Codex in One Hour (Codex super-app walkthrough). Same operator, three framings: (a) build AIOSes for clients, (b) master OpenAI’s harness, (c) map the entire Claude surface as a 5-stage ladder (this article).
  • L4 confirms the Karpathy techniques thesis that CLAUDE.md + verification loops + iterative correction is the unlock. Boris Cherny’s “update CLAUDE.md so it doesn’t repeat” is the same pattern Karpathy describes; this article is operator confirmation that Anthropic-internal teams use it too.
  • L4 includes the third independent data point for CLI > MCP > API tool hierarchy (after TinyFish’s 87% reduction, Printing Press’s 35× / 100→72% reliability, and Moritz Kremb’s Claudia OS operator stance). Anthropic-doc-cited 60-70% token reduction quantifies the CLI advantage.
  • L5’s “trust is the gate, not features” framing sits next to Dixon Dick’s W17 keynote talk on auto-mode permission classifiers and the “no more 1 1 1” autonomy thread.
  • Sister content to W20 release digest — that article covers the v2.1.139 agent view feature; this article gives the level-progression context for why agent view matters at L4.

Operational details worth promoting from L4

  • Boris Cherny’s daily pattern: 5 numbered terminal tabs, isolated workspaces, fire-and-walk-away, returns to multiple PRs for review. The minimum bar for L4 productivity, per the video.
  • /insights once a month. Highest-ROI command most people never run.
  • /branch formerly /fork. Anyone with prior notes referencing /fork should update.
  • /output-style new for personality swaps. Built-in: default / explanatory / learning. Custom: code-reviewer, no-fluff, documentation-writer.

Implementation

  • Tool/Service: Claude product surface — claude.ai (L1-L2) → Claude Desktop’s Cowork tab (L3) → Claude Code CLI or Desktop “code” tab (L4) → Routines + Hooks + Channels + Agent Teams (L5).
  • Required for each level:
    • L1-L2: Claude free or Pro account.
    • L3: Pro / Max / Team / Enterprise (Cowork is paid-only).
    • L4: Same plan; CLI install via npm install -g @anthropic/claude-code (or Desktop code tab — same engine).
    • L5: Same plan; Routines + Hooks documented in Routines and Hooks articles.
  • Folder discipline (L3 → L4 transition): about_me/ + templates/ (read-only) + projects/ + outputs/. State the rules to Claude explicitly.
  • L4 cost optimization: Plan Mode → Opus Plan (Opus plans, Sonnet executes) → /compact proactively → automatic prompt caching = 60-90% cost reduction on long sessions.
  • L5 trust calibration: start with deterministic data-mover routines, low-stakes outputs (private summaries), watch run for weeks before scaling.

Open Questions

  • Creator attribution confirmation. Branding signals (AIS+ “plus group”, “free school community”, framing match) suggest Nate Herk, but the transcript doesn’t name the creator. Verify via channel name / YouTube metadata before treating attribution as authoritative.
  • “3,000+ marketplaces” figure (L5). Aggressive — typical published counts are 1,000+ for marketplaces specifically. Possible the creator conflated marketplaces + plugins + repos. Cross-check against plugin marketplace coverage.
  • /insights availability. Mentioned as a Claude Code slash command but not yet visible in cli-reference or release digests. Confirm it’s a public command vs an unreleased feature.
  • Microsoft Office “shared context across apps” (April 2026). Claim that all three add-ons share context across Excel / PowerPoint / Word. No dedicated wiki article on Office add-ons yet — surface as a coverage gap.
  • Inline visuals dedicated article. Mentioned distinctly from artifacts (“ephemeral, live in chat, don’t save”) — coverage gap; only artifacts has its own article.
  • Memory + past-chat-search free/paid split. Verify against Anthropic pricing page — claim is memory is free, past-chat search is paid.

Try It

  1. Self-assess your current level. Honest reading of the 5-level table — which surface do you actually use day-to-day?
  2. Apply your level’s cheat code. L1 → create a project. L2 → open Cowork. L3 → set up the 4-folder structure (about_me/, templates/, projects/, outputs/). L4 → find your most repetitive weekly task and turn it into your first Routine.
  3. L4 power-move starter pack: add CLAUDE.md (under 200 lines), run /insights once, build one custom slash command for something you type twice, try Plan Mode (Shift+Tab Shift+Tab) on your next non-trivial task.
  4. L5 trust experiment: create one Routine that only outputs to you (daily stand-up summary). Don’t touch it for a week. Then add the next.
  5. Cross-tool composition (advanced): read the Codex companion and run Claude Code in the terminal inside a Codex project to mix-and-match models on the same files.

Graph View

Backlinks