Mastering Claude: The Four Levels

Two people in the same company open the same AI assistant every morning. Dana types a question, copies the answer, and moves on. Sara runs her entire working week through it — documents, decisions, drafts, delegated jobs. Same tool. Same subscription. Sara gets ten times more out of it. Here's the thing: a year ago, Sara worked exactly like Dana. The difference isn't talent. Mastery is patterns, practised until they're boring. This is the ladder — Claude is our example, and the patterns carry to any serious assistant. There are four levels. Level one: chatting. Where everyone starts. Level two: context — teaching Claude what it should already know. Level three: workflow — turning one-off answers into repeatable processes. Level four: delegation — handing over whole jobs, safely. The industry has a name for most of this now: context engineering. The model is rarely the bottleneck anymore. What you feed it almost always is. We'll watch Dana hit a wall at every level — four failures, each with a price tag — and the pattern that turns each wall into a step. By the end, you'll know which level you're on, and the three moves that climb you one. Dana's first wall is one every one of us has hit. One chat thread, three weeks old. The budget discussion is in there. The job ad. The complaint letter. Half a strategy. By week three the answers turn vague, then contradictory. Dana burns a full afternoon arguing with the thread — re-explaining things it knew a fortnight ago. That's not the model getting worse. It's the thread. Old instructions and dead context pile up, and every answer fights through all of it. The community calls it context rot. Dana calls it Tuesday. Before the fix, the mental model that explains everything. Claude doesn't remember you. It reads a desk. Everything it can use right now — your words, your files, its own earlier answers — sits on one desk of fixed size. That desk is the context window. Big, but finite. When new papers arrive, old ones slide toward the edge. Nothing on the desk? It doesn't exist, no matter how clearly you remember telling it. Every pattern in this video is really one skill: deciding what deserves a place on that desk. Now the fix, and it costs nothing. One job, one chat. Finished with the budget? New chat for the job ad. Conversations are free — open them like fresh documents. Nobody drafts a contract in the margins of last month's memo. In Claude Code there are two commands for exactly this. Slash clear wipes the desk completely. Slash compact is smarter — it summarises the session and carries only the summary forward. The context, without the rot. This transfers everywhere: every assistant degrades in an endless thread, whatever the brand on the box. But new chats forget. That's what Projects fix. A Claude Project is a workspace with permanent knowledge. Dana uploads the strategy, the price list, the brand guide — once. Every chat inside that Project starts with those papers already on the desk. And the desk is generous: a small bookshelf of material, hundreds of pages, in working memory. Dana builds one Project per client. Ten minutes each. The Tuesday afternoons come back. Worth pausing on, because the industry split here. ChatGPT has Projects too — and its wider memory is automatic. It quietly learns your preferences from your history in the background. Convenient, and a little unaccountable: you don't fully know what it thinks it knows. Claude's memory is deliberate. The Project box holds exactly what you put in it — nothing more, nothing you can't inspect. Automatic memory is comfort. Curated memory is control. For work that has to be right — audits, clients, boards — curated wins. Know which kind you're relying on, whichever tool you use. Next, Dana writes the rules down — once. Every Project takes custom instructions: who you are, what good looks like, what to never do. Dana's reads: "We write British English. Numbers get tables. Cite the source document for every claim. Never invent a figure." Claude reads it at the start of every conversation. The rules are on the desk before the first word is typed. Developers know this pattern as a file: CLAUDE.md — a plain-text constitution Claude Code reads every session. Team conventions, build commands, the directories it must never touch. One page of written rules beats a hundred repeated reminders. Some rules aren't rules. They're whole routines. The monthly report format. The way your team reviews a contract. The newsletter voice. Explaining those in every chat is level-one behaviour wearing a level-two costume. Claude lets you save a routine as a skill: the steps, the format, the standards — taught once. From then on it triggers itself whenever the situation matches. Ask for "the monthly report" and the whole procedure loads. Rules go in the constitution. Routines become skills. Dana saves three in the first week and never explains the report format again. Level two has a trap, and Dana walks straight into it. Preparing a board pack, Dana asks for market figures and gets a beautifully formatted answer — with a citation. Slide fourteen of the deck. A director checks the source that evening. It doesn't exist. Not wrong data. Invented data — in front of the board. Dana survives the meeting. Barely. The lesson costs one bruised reputation and a weekend. Language models are confident by design. Confidence is not evidence. The next four patterns exist because of that evening. Dana's first new rule: make it show its work. In a Project, ask Claude to quote the source document for every claim — it cites the exact passage from the files you uploaded. If it can't, you want to know that loudly, not smoothly. So Dana adds one line to the constitution: "If you cannot verify it, say so." Claude respects that line remarkably well — it would rather admit a gap than invent a bridge. And anything that leaves the desk gets produced as an artifact — a standalone document you check line by line, not prose scrolling past. ChatGPT does its version inline in the chat; the pattern is identical. Trust, but with receipts. Here's the same request, asked twice. Dana's old way: "Summarise this contract." Dana's new way: "Extract every obligation on our side, with its deadline and penalty. Quote the clause for each. Table format. Flag anything you cannot verify." Same document. Same model. The first gets a book report. The second gets a working tool. Every strong ask has four parts: the exact output you want, the shape it should take, the evidence rule, and the honesty rule. Weak asks get summaries. Strong asks get deliverables. But what about the tasks too fuzzy to specify? Flip the table. Dana's new opener for anything vague: "Interview me about this before you start." Claude asks what the deliverable is for, who reads it, what good looks like, what to avoid — five sharp questions, better than most consultants open with. Then it writes the brief, and the brief is suddenly easy to approve. Specification is the hard part of delegation. This pattern makes the machine do the specifying. Power users swear by it, and it works in every assistant on the market. Pattern eight: know when to pay for depth. Claude has extended thinking — a mode where it reasons visibly before answering. Slower. Noticeably better on hard problems. The skill is knowing when. An email needs none. The contract from the anatomy slide? Turn it on. A pricing model, a migration plan — turn it on. In Claude Code the same philosophy is plan mode: Claude proposes its approach, you approve, then it acts. Think first, touch second — enforced by the tool. ChatGPT sells the same dial as its Thinking models. Different badge, same budget decision. Depth is a budget. Spend it where being wrong is expensive. Level three opens with Dana's most public disaster. The forty-page RFP lands. Deadline Friday. Dana pastes the whole thing into one prompt: "summarise this, compare it with our last three bids, check the legal terms, and draft the response." What comes back is mush. Fluent, confident, and useless — four jobs each done at a quarter of their possible quality. Two days of rework, and the bid nearly misses the deadline. One prompt. Four jobs. Zero checkpoints. The model didn't fail. The workflow did. Sara shows Dana the fix. It's a chain. Step one: extract the requirements — and check them. Ten minutes. Step two: compare against the last three bids — and check the comparison. Step three: draft the response — now it drafts from verified parts. Same work. Same model. An order of magnitude better — because a human inspects every joint. The checkpoint is the pattern. Not the steps — every tutorial has steps. The stopping to look is what separates a workflow from a wish. The rebuilt bid goes out Thursday, a day early. Here's how you know chaining isn't a productivity-blog trick. The entire agent industry is built on it. LangGraph — today's production leader — is exactly this: chained model calls with checkpoints, audit trails, and rollback points. CrewAI, OpenAI's Agents SDK: same shape, different dress. Even ChatGPT's Deep Research is this pattern in a box — research, verify, then write. What engineers formalise in code, you just did by hand in three chats. You're not learning a trick. You're learning the industry's architecture — from the civilian side. Pattern ten: stop being the courier. Claude connects directly to the tools where work lives — the drive, the calendar, the databases, the dashboards — through connectors built on MCP, the Model Context Protocol. The part worth knowing: Anthropic created MCP and gave it away as an open standard. Today every major AI framework supports it. A connector built for Claude works across the industry. That's the deepest answer to "does this transfer?" — the patterns don't just transfer. The plumbing itself is shared now. Live data beats pasted data, every day of the week. Level four is where the leverage lives — and Dana's sharpest lesson. Friday, five o'clock. Dana hands an agent a vague goal — "clean up the customer records" — and goes home. Monday: the records are clean. Also merged. Deduplicated. Overwritten. Three thousand rows of history, gone — technically, exactly what was asked. Restoring the backup costs the team a day. Explaining it costs Dana more. An agent without checkpoints isn't an employee. It's an intern with admin rights. Delegation is a skill precisely because it can go this wrong. So Dana learns to delegate like a manager, not a gambler. The mission comes in three parts, written down. The goal — what done looks like, concretely. "Duplicates flagged for review", not "records cleaned". The boundaries — what must never be touched. The red lines the agent cannot cross even if crossing them would "help". And the escalation rule — where to stop and ask a human. Vague goals produce confident disasters. Bounded goals produce reviewable work. ChatGPT's Agent mode will drive a browser and desktop apps for you — which makes this pattern more urgent there, not less. The more an agent can touch, the more the boundaries matter. And then the ritual that makes delegation safe enough to repeat. In Claude Code it's built into the tool's shape. Plan mode: the agent proposes before it acts. You approve the plan — or fix it while it's still words. It executes. Then you review the diff — the exact, complete list of everything that changed — before anything ships. Propose. Approve. Execute. Review. Four beats, every time, until it's boring. For bigger jobs, Claude runs subagents — scouts that research in parallel and report back while the main desk stays clean. The gold star goes on after the review. Never before. Pattern twelve: the assistant can build its own tools — and yours. Dana describes a utility in plain English: "a calculator for our pricing tiers." Claude builds it as an artifact — a working little app, right in the conversation, shareable with the team. Developers get the industrial version: point Claude Code at a repository, type slash init, and it writes its own CLAUDE.md map of the codebase — the tool orienting itself in your world. Within a month, Dana's team runs four tiny internal tools nobody "built". They were described into existence. Everything so far multiplies the person. This slide multiplies the team. Projects can be shared: one 'Client North' box, every account manager drawing from the same curated knowledge. New joiners inherit the desk on day one. Skills can be shared: the contract-review routine, taught once by your best reviewer, run by everyone at their standard. Connectors are shared by nature — one MCP integration, the whole team plugged in. A team where only one person climbs the ladder has a hero. A team that shares its patterns has an operating system. So — is any of this Claude-only? The patterns, no. The furniture changes name. Projects exist in ChatGPT too. Custom instructions exist everywhere. Extended thinking is ChatGPT's Thinking models. Delegation is its Agent mode. And MCP connectors are already cross-industry — Claude-born, universally adopted. What differs is emphasis. Claude's edge today: the long context, the instruction-following, curated memory, and Claude Code's propose-approve-review workflow. Master the twelve patterns and you can sit down at any of these machines. You're not learning a product. You're learning how to run a machine colleague. For the Claude users: the whole video on one card. Projects hold the knowledge. The constitution holds the rules. Skills hold the routines. Extended thinking for anything expensive to get wrong. Artifacts for anything that leaves your desk. Connectors for live data. And in Claude Code: slash init to orient it. Plan mode before it acts. Slash compact when the session runs long. Slash clear when the job is done. Subagents for the research. And the diff review before anything ships. Pause here. This card is the course. What does all of this look like on an ordinary Tuesday? Here's Sara's. Eight forty. Opens the client Project. The desk is already set — nothing re-explained. Eight fifty. Reviews two chains that ran yesterday: checks the seals, approves one, sends one back with a note. Nine fifteen. One hard decision — a pricing change — goes to extended thinking, with receipts demanded. Nine forty. Two missions delegated, each with its three-part brief. By ten, Sara has done what used to be a day's coordination. The rest of the day is the actual work — the judgement, the relationships, the parts that were never the machine's to do. Now look at the ladder honestly — analyst, manager, or developer, the rungs are the same. If your chats are one endless thread — you're at level one. No shame; that was Dana in March. If you re-paste the same context every week — level two is waiting, and it costs ten minutes. If your big tasks go in as one giant prompt — level three will change your output more than any model upgrade you're waiting for. And if you've never delegated a whole job with a written brief and a review — level four is where the hours come back. Nobody skips levels. Everybody can climb one this month. Don't attempt all twelve patterns. Do three things Monday morning. One: make a Project for your biggest client, product, or codebase. Upload five documents. Write ten lines of constitution. Two: take one decision you're facing — a contract, a hire, a technical choice — turn on extended thinking, and ask for the analysis with receipts. Three: take one recurring task and split it into a three-step chain with a checkpoint after each step. An analyst, a manager and a developer can each do all three before their second coffee. That's the entry fee to level three. It's smaller than the excuse. Back to the two desks — six months on. Dana's desk has the Project boxes now. The constitution. The skills box. The chains with their green seals. A small robot that proposes before it acts. Dana lost an afternoon to a rotten thread, a weekend to an invented citation, two days to mush, and a Monday to a runaway agent — and turned each one into a rung. Sara wasn't more talented. Sara had just already paid the same four tuitions. Mastery is patterns, practised until they're boring. And boring, practised patterns are what productivity actually looks like. Four levels. Twelve patterns. Four failures that taught them. Chat cleanly. Mind the desk. Give it memory — curated. Write the constitution. Save the routines. Demand receipts. Ask with anatomy. Make it interview you. Buy thinking where it matters. Chain with checkpoints. Plug in live context. Delegate with a brief, and review before the star goes on. It's Claude today. It transfers tomorrow. Pick your level. Climb one. If this was useful, subscribe — one short analysis every week, no noise.