Over the previous chapters you've set up Claude Code, learned how to give it instructions, and picked up ways to get unstuck. Now let's take a step further and talk about supercharging Claude Code itself. It's already plenty powerful out of the box, but there are entry points for extending it — connecting to external tools, automating your work, dividing tasks across multiple AIs, and being able to roll changes back. In this chapter we'll map out what each one is and when it's useful.
Grow your capabilities across "connect, automate, delegate, safety net, deliverables"
What extensions are — expanding in five directions
Claude Code's extensions each grew out of separate mechanisms, but the moment you view them through the lens of "extending the AI's abilities in a particular direction," the whole picture snaps into focus. Before memorizing the fine details of each setting, first build a map of which feature solves which problem. Keep the table below in mind and every section that follows will click into place.
Connect to external data and services the AI can't reach on its own (databases, issue trackers, internal tools, and the like). Clears up the "the AI doesn't know that" problem.
Instead of leaving "the routine you always do" or "repetitive work" to the AI, run it reliably through a mechanism. Cuts down on manual effort and forgetting.
Assign a big job across multiple AIs, running research, implementation, and review in parallel. Effective at a scale one AI can't hold on its own.
Make it so you can roll back the AI's changes at any time. The foundation that makes "boldly handing off" feel safe.
Package the procedures, deliverables, and extension sets you use often into a reusable form, then distribute and share them.
📌 How to read this chapter. Here it's enough to grasp the big picture of "what's possible." We won't dive deep into individual setup steps or concrete examples — those are left to the dedicated articles linked at the end of each section. For now, learn the names and roles so you can come back when you need them.
Connect — MCP
Smart as it is, the AI doesn't know the data on your machine or what's inside your company's tools. The current values in a database, tickets in an issue tracker, the contents of a design file — MCP (Model Context Protocol) is what bridges the AI to this "outside world." It helps to think of it as a standard for a shared "plug socket."
What: A "connection standard" that links the AI to external tools and data through a shared protocol. Add a compatible server and Claude Code can operate that tool directly.
When it helps: When you want to implement while looking at what's in a database, integrate with an issue tracker or design tool, or let the AI use information from an internal system.
💡 The key to solving "the AI doesn't know that." MCP is especially versatile among the extensions, and many tools are building support for it. We explain how it works and how to set it up in detail in What is MCP — how it works and where to use it. For now it's enough to remember that "there's a shared standard for connecting the AI to external sources."
Automate — hooks and loop
Asking the AI every single time to "run the tests too" and "apply the formatter too" is easy to forget, and frankly tedious. It's safer to run routine processes reliably through a mechanism. This is where hooks and the loop command come in. The former "runs automatically tied to a moment," while the latter "bundles and automates repetitive work."
What: A mechanism that lets you slot your own scripts in "before" or "after" the AI runs a tool. For example, you can automate "always run the formatter after editing a file."
When it helps: When you want to reliably enforce routine steps you always want done — lint/format on save, pre-commit checks, blocking dangerous commands in advance.
What: A mechanism that runs the same instruction repeatedly at a set interval, or until a condition is met. You can hand off repetition like "check the deploy status every five minutes."
When it helps: When you want to run repetition that doesn't need a person watching — periodic checks, keeping an eye on long-running processes, repeating the same task.
✅ Reduce "forgetting" and "manual work." For hooks, see What are Claude Code hooks; for the loop command, see What is the loop command — both cover setup and real examples. hooks in particular are prized in team development, because they let the mechanism guarantee the quality checks that "tend to slip when left to the AI."
Divide the work — subagents / agent teams
When you cram everything into a single AI, the longer the conversation runs the thinner its context gets and the more accuracy drops. That's why the idea behind subagents is to split a big job across multiple AIs. Divide up roles — a "researcher," an "implementer," a "reviewer" — and each can focus on its own task, raising the overall quality.
What: A mechanism where a parent AI hands a specific job to a dedicated "child AI." The child works in its own context and returns only the result to the parent. You can split the AI up by role.
When it helps: Broad research, implementation spanning multiple files, running independent tasks in parallel. Handles big jobs without polluting the context.
What: A more advanced approach that coordinates multiple agents as a full-fledged "team." It organizes role division and collaboration around even larger units of work.
When it helps: Ongoing, large-scale development that a one-off division of labor can't cover. Choose it once you understand how it differs from subagents.
⚠️ Don't overdo the count. There's a limit on how many AIs you can run in parallel, and greedily launching too many at once can actually make things unstable or leave you waiting. Start with dividing work across just one or two. We compare the difference between subagents and agent teams and how to choose in detail in The difference between subagents and agent teams.
Give it procedures — skills
Isn't there a task you always want done "this same way, following these steps"? Explaining it from scratch every time is wasteful. skills let you equip the AI in advance with the way to do a specific task (procedures, knowledge, rules). When the situation calls for it, the AI invokes that skill itself and works in the prescribed manner.
What: A mechanism that bundles the procedures, knowledge, and reference files for a specific task into a set and equips the AI with it. It's invoked automatically in the relevant situation and processed in the way you've defined.
When it helps: When you want to enforce "the same way every time" — internal coding conventions, document templates, recurring routine tasks.
💡 Make "the explanation you give every time" reusable. Whereas hooks are "processes that run automatically at a certain moment," skills are "procedure manuals the AI decides to invoke" — framing it that way makes them easy to tell apart. We explain how they work and how to build them in What are Agent Skills.
Bundle and share — plugins / marketplace
MCP, hooks, skills, and the rest are handy, but setting them up "one at a time" is also a chore. plugins and the marketplace let you bundle them into a single package that's easy to add and share. You can pull in a whole set of useful extensions someone else has built, all at once.
What: An "extension package" that bundles skills, commands, hooks, MCP settings, and more into a set. Just add it and you get a whole batch of functionality at once.
When it helps: When you want to standardize extensions across a team, or quickly pull in a proven configuration.
What: A place to distribute and obtain plugins. You can browse published extensions and install them, or share your own.
When it helps: When you want to take "I want a feature like this" and quickly add it by finding an existing extension.
📦 Put extensions into a "shareable" form. We cover the relationship between plugins and marketplace and how to set them up in What are plugins and marketplace. When you pull in an external extension, always confirm whether the source is trustworthy before using it.
Safety net — checkpointing and rewind
The more you hand over to the AI, the scarier it gets that it might "accidentally make a change you didn't intend." That's where a safety net that lets you roll changes back comes in. Record milestones in your work with checkpointing, and if you can rewind back to them, you can hand off to the AI without hesitation. The reassurance of "I can go back" becomes the courage to delegate boldly.
What: A mechanism that automatically records the progress of your work so you can later roll changes back to any point. It grants "I want a do-over" in a single move.
When it helps: When handing the AI a sizable change, when you want to shift direction through trial and error, or when you want to undo an unexpected edit.
✅ Reassuring only when paired with Git. Checkpointing is powerful for rolling back within a session, but it's no substitute for version control (Git). The safe two-tier approach is to commit regularly while using rewind to undo the fine-grained trial and error. We explain how it works in What are checkpointing and rewind.
Show the result — artifacts
Beyond just writing code, sometimes you want to shape a result into something you can show on the spot. A quick web page, a diagram or data visualization, a UI prototype — artifacts let you generate and preview these "results you can see and check." They shine in moments where showing a working thing at a glance beats explaining it in prose.
What: A mechanism to generate and preview on the spot the results the AI produces (web pages, diagrams, visualizations, prototype UIs, and so on). Easy to see, check, and share.
When it helps: When you want to show a first-draft UI, share data as a diagram, or confirm the finished look with "the real thing" rather than words.
🎨 Make "show and check" faster. We cover where to use it and how to build it in What are artifacts. When you want to refine a design through dialogue, it's worth also glancing at the related Claude Design / Design Sync to broaden your toolkit for creating deliverables.
Extensions are power-user tools
We've raced through eight extensions. They're all appealing, but there's absolutely no need to reach for all of them from the start. These are "power-user" tools that only come alive when stacked on top of the fundamentals. Rush toward extensions before your foundation is solid and you'll get jerked around by configuration — a detour that costs you more time.
Get comfortable with setup, permissions, and giving instructions using the content of Chapter 2.
Once the error handling from Chapter 5 is second nature, glitches during extension use won't rattle you.
When you think "I want to solve this specific problem," add just the one extension that addresses it.
⚠️ Extensions can wait until you're actually stuck. Adopt them preemptively just because they look handy, and all you gain is configuration complexity. Only once a concrete frustration arises (you keep forgetting this step, the AI can't reach this information, and so on) should you bring in one extension to solve it. Keep to this order and extensions will always be on your side.
- Extensions expand in five directions — connect (MCP) / automate (hooks, loop) / delegate (subagents, agent teams) / safety net (checkpointing, rewind) / procedures and deliverables (skills, artifacts, plugins).
- MCP connects the AI to external data, hooks automate routine processes, and loop automates repetition.
- subagents divide the work, and because you have checkpointing / rewind you can delegate boldly. skills, artifacts, and plugins make procedures and deliverables reusable.
- These are for power users. The right move is to solidify the basics first, then add them one at a time, once a problem actually arises.
With the tools for expanding your capabilities lined up, next comes the topic of "using it wisely over the long haul." In the next Chapter 7, "Cost and Efficiency," we'll get a handle on managing tokens and usage limits, plus tips for using it without waste.