Power User

Simple: A workshop has hand tools, a socket for plugging in new machines, a house rulebook, written recipes, and apprentices you can send on errands. Nobody confuses a recipe with a socket — and that is the whole slide.

Technical: The eight pieces differ along two axes: whether they add capability (tools, MCP) or instruction (CLAUDE.md, skills, hooks), and whether they execute inside your context window or in one of their own (subagents, custom agents).

Simple: The recipe is in charge. It can pick up any tool, phone any supplier, and hand chopping to an assistant — but the recipe is what decides the order.

Technical: Skills sit at the orchestration layer. A slash command is the entry point; the skill body composes built-in tools, MCP-provided tools and delegated subagents into one sequence, so the composition is authored once rather than re-prompted each time.

Simple: Four ways to answer the same question, and they cost different amounts of desk space. Running one command leaves a sticky note; asking a helper to read the whole filing cabinet leaves you one paragraph.

Technical: The four tabs differ by an order of magnitude in tokens added to the caller’s window — roughly 50 for a direct tool call, 1,200 for injected MCP documents, 800 for a skill that chains three calls, and 200 for a subagent whose own 15K of reading never crosses back.

Simple: Your desk is a fixed size, and it is not empty when you sit down — the reference books, the house style guide and the list of who to phone are already on it. Only the rest of the surface is yours.

Technical: The commands themselves are Lab 1’s material; what matters here is the bill. The system prompt, every connected server’s tool definitions, your skills and your CLAUDE.md are all charged before your first word, and on every turn thereafter, not once at startup. That is why a session with a dozen servers connected feels slower and costs more than a bare one doing identical work — and why turning one off is a real optimisation rather than tidying.

Simple: Instead of explaining your house style from scratch every time, you write it down once and point at it. The note does not do the work — it tells the worker how you want the work done.

Technical: A skill is a versioned prompt package: instructions, tool permissions and trigger conditions in one folder. It is invoked either explicitly by a slash command or implicitly when its trigger matches the task.

Simple: You are fitting a new plug on an appliance you already own. The appliance already works; the plug is what lets anything in the house switch it on without knowing how it was built.

Technical: An MCP server declares a named tool with a typed parameter schema and a handler. The protocol layer supplies discovery, JSON serialisation and error propagation, so the same server is usable by any conforming client with no client-side code.

Simple: Almost nobody builds their own kettle. You buy one that fits the socket. The interesting exception is the thing only your household owns — nobody sells that, so you wire it yourself.

Technical: The ecosystem splits three ways: vendor-maintained servers for common SaaS surfaces, community servers of varying quality, and internal servers wrapping systems with no public equivalent. The third category is where MCP earns its keep, because it exposes proprietary workflows through the same interface.

Simple: Every appliance you plug in comes with a manual, and the manual sits on your desk whether or not you ever use the appliance. Plug in enough of them and the manuals leave no room to work.

Technical: Each connected server injects its full tool-schema catalogue into the system prompt on turn one — roughly roughly 150–200 tokens per tool, so a 42-tool server lands near 8,000 and a 2-tool server near 1,500. That is a standing cost, paid before any query, and it is retained through auto-compaction because it describes what the next turn can still call.

Simple: You send someone to the library instead of hauling the library to your desk. They read the shelf; you get the note.

Technical: Delegation is a context-isolation mechanism, not a speed one. The subagent runs in a separate window, so its intermediate reads are never charged against the caller’s budget — only the returned summary is.

Simple: The helper goes away, does the job, comes back and tells you how it went. They cannot tap you on the shoulder halfway through to ask a question — so the brief has to be complete when you hand it over.

Technical: The lifecycle is spawn → isolated execution → single return. There is no mid-task turn back to the user, which is why the four properties on this slide — fresh context, parallelism, narrow scope and a restricted tool allow-list — all have to be fixed at spawn time.

Simple: A job description, written down. Who they are, what they are for, and which keys they are allowed to hold.

Technical: A custom agent is a named triple: a routing description, a system prompt that fixes the role, and an allowedTools allow-list. The reviewer here has no write tool at all — the restriction is enforced by configuration, not by asking the model nicely.

Simple: Tell them what “done” looks like, what to leave alone, and to speak up if they get stuck. Every one of these five rules is something you would say to a new colleague on their first morning.

Technical: All five patterns exist because a subagent cannot ask a clarifying question mid-run. A declared return schema makes the output parseable, an obstacle-reporting clause turns silent failure into a reported one, and scope and tool limits shrink the space in which it can go wrong unsupervised.

Simple: Delegating has a cost too — the briefing, the wait, the handover. For a two-minute job you just do it yourself. But if it is a long job, you hand it over and go and do something else, rather than standing there watching.

Technical: The decision is a ratio, not a preference: delegate when the intermediate output a task generates is large relative to the summary it yields. Tasks that need the caller’s accumulated context, or that require a mid-run clarification, cannot be delegated at any size. Backgrounding is the orthogonal axis — it changes whether you have to wait, not whether the work is delegable, and branching a session is what makes an irreversible-looking experiment cheap to abandon.

Simple: Three people painting three different rooms finish in the time it takes to paint one room — as long as none of them needs the ladder the others are standing on.

Technical: Wall-clock time approaches that of the slowest branch rather than the sum, but only for genuinely independent subtasks. Shared state or an ordering dependency between branches serialises them again, and each branch still spends its own tokens even though the caller never sees them.

Simple: Watch the bar that measures your desk. Three people are working flat out and your desk barely fills up. That is the whole trick.

Technical: The three progress bars track work done inside three separate windows; the context bar underneath tracks only the caller’s. Roughly 17,400 tokens are spent across the branches and about 200 cross back, so the caller’s occupancy is decoupled from the total work performed.

Simple: A door with a guard on each side. One checks what you are carrying in, the other checks what you are carrying out, and neither of them is the agent — they are your rules, and they cannot be talked round.

Technical: Hooks are your own programs fired on lifecycle events. Because a PreToolUse hook can veto the call before it executes, enforcement lives outside the model’s reasoning — a prompt instruction can be overridden by a persuasive context, a non-zero exit status cannot.

Simple: Four small chores nobody wants to remember: tidy up after each edit, keep a diary of what was touched, refuse the genuinely dangerous requests, and tell the team when it is finished.

Technical: The four examples map to three distinct event points. Auto-lint is PostToolUse and feeds its failures back into the same loop pass, so the agent self-corrects; the safety guard is PreToolUse and must return a reason, because a silent block leaves the agent retrying blind.

Simple: How much shopping may someone do on your card before ringing you? The answer is different for a corner shop and a car dealership — and separately, some shops you simply never give them the card for.

Technical: Two different mechanisms, and confusing them is the common mistake. The mode is session state, and you are the gate — it changes when you are asked. An allowlist or a hook is configuration, and a rule is the gate — it holds in an unattended run, where there is nobody to answer a prompt at all. Loosen the mode for speed; rely on the allowlist and the hook for safety. Names and behaviour move between versions, so confirm with claude --help rather than trusting a slide.

Simple: The know-how that normally lives in one experienced colleague’s head, written into a folder anyone can copy. When they go on holiday, the folder stays.

Technical: A skill is a filesystem-level artefact, so it inherits everything the filesystem already gives you: version control, diffs, review and distribution. Because the format is an open specification rather than one vendor’s config, the same folder is portable across conforming agents.

Simple: A recipe card with a label at the top. The label says when to reach for this card; the rest says what to do once you have.

Technical: The YAML frontmatter is machine-read for routing — name, version and trigger globs decide whether the skill is even offered. The Markdown body below is what the model actually reads, and it is only read once the frontmatter has matched.

Simple: Make a folder, write the note, drop in anything the note refers to, then try it and fix what did not land. Step four is the one people skip and the only one that tells you the truth.

Technical: Two of the four steps are placement decisions, not authoring ones. .claude/skills/ in the project makes the skill travel with the repository and apply to collaborators; the same folder under your home directory keeps it personal and applies it to every project you open.

Simple: A cookbook with a contents page. You do not read all 300 pages to make one dish — you read the contents, then the one page you need.

Technical: Installed size and loaded size are different numbers. Only SKILL.md is guaranteed to enter the context window; the resource files are referenced by name and fetched on demand, so a large skill folder has a small resident cost.

Simple: You did not have to name the recipe. You said what you wanted for dinner and the right card came off the shelf — and only the pages that mattered got read aloud.

Technical: Two mechanisms are running at once here. Trigger matching selects the folder from a plain-language request with no slash command; progressive disclosure then loads a subset of that folder’s files, so the green segment grows by what was read rather than by what was installed.

Simple: Like a plug shape that every country agreed on. Your appliance works when you move house, and you are not stuck with one manufacturer because your adapters only fit theirs.

Technical: Adoption across competing vendors is what turns a config format into a standard: the skill folder becomes a portable asset rather than switching-cost. Time-sensitive — the tool list on this slide is a snapshot; treat the count as illustrative, not current.

Simple: It is a folder. You already know four ways to give someone a folder, and all four work here.

Technical: The four routes differ in scope, not mechanism. Committing to the repository binds the skill to one project and its collaborators; publishing as a package decouples the skill’s version from the consuming project’s; the home-directory location applies to every project but travels with you rather than with the code.

Simple: When a skill does nothing, it is almost never the writing — it is the filing. Wrong drawer, wrong label on the front, or a label so vague that it opens for everything.

Technical: Three of the four failure modes are discovery failures, not instruction failures: path, filename and frontmatter parsing all happen before the body is ever read. The fourth is over-broad globs, where the skill loads correctly and simply should not have.

Simple: The recipe card does not contain the cake. It tells you which tin, which oven setting and where the icing instructions are kept — so changing the icing changes every cake without rewriting the card.

Technical: Separating routing from content is what makes the skill maintainable. Output format lives in a resource file, so one edit to style-guide.md propagates to every artefact the skill produces, and SKILL.md stays under the size where it competes for context.

Simple: Somebody has to be the site manager. Not because they lay the bricks, but because someone must decide who starts now and who waits for the walls.

Technical: The coordinator holds the dependency graph. It decomposes the request, dispatches independent branches concurrently, blocks dependent ones until their inputs land, and synthesises the returns — which is why the test agent shows Waiting while backend and frontend show Running.

Simple: Every piece in this module, in one picture, with your question walking through it. Follow the dot: it goes in one end as a sentence and comes out the other as an answer.

Technical: Two loops carry the whole architecture. The inner one is model ↔ runtime — the agent loop from Module 4. The outer one is runtime ↔ the world, reaching skills for instruction, MCP servers for data, and subagents for work that should not be charged to this window.

Simple: You are now the person who says what the building should do and walks round at the end to check it. Someone else is holding the trowel. Saying what you want and checking you got it are still your job — and they are the hard parts.

Technical: Karpathy’s framing (2025) is that natural language becomes the authoring layer while generated code remains the artefact that runs. The verification burden does not move with the typing: the reviewer still needs enough of the underlying model to tell working output from plausible output.