One command.
A whole setup.

01The big picture: one box, one command

What. A plugin is a folder that Claude Code installs and loads as one unit. Inside can be skills, subagents, hooks, MCP servers and a few other things. Instead of setting up each piece by hand, you run one install command and everything arrives together, with a name, a version and a way to update.

Why it matters. Until now every extra you added lived in its own place: a skill folder, an agent file, a hooks block in settings, an MCP entry. That is fine for you on one project. It falls apart the moment you want the same setup on a second project, on a teammate's laptop, or after you reinstall your machine. A plugin turns "my setup" into something you can hand over.

How this article is organised.

02What a plugin is, in plain words

What. Think of a phone. The phone is Claude Code. An app is a plugin: something you add, that brings its own screens and abilities, that you can switch off or delete, and that updates itself. The difference is that a plugin app is made of the parts you already know from this series.

Plugin or standalone? Everything above works on its own without a plugin. Keep it standalone while the setup serves only you or one project. Make or install a plugin when you want several pieces packaged as one, installed in many projects, shared with a team, or released with versions.

03Marketplaces: where plugins come from

What. A marketplace is a catalog: a file named marketplace.json in a Git repository that lists plugins and where to fetch each one. It is not a hosted store. You add a marketplace once, then install plugins from it by name, written plugin-name@marketplace-name, for example commit-commands@claude-plugins-official.

Why it matters. The marketplace is what makes installs and updates one command, and it tells you who publishes the catalog. Knowing the three kinds helps you decide how much to trust a plugin.

One more name to know: Claude Marketplace at claude.com/marketplace is a website for browsing, not something you add with /plugin marketplace add. Its plugin pages have a Claude Code button that copies the install command for you.

04Install your first plugin in the terminal

What and why. We will install commit-commands, a small official plugin that adds commands for committing, pushing and opening pull requests (it pairs with Day 6). It is a safe first choice because everything it adds is a skill. How: start Claude Code in a project, then:

# 1. open the plugin's details page (nothing is installed yet)
> /plugin install commit-commands@claude-plugins-official

# or browse instead: the Discover tab lists plugins, type to search
> /plugin

In a session, /plugin install does not install straight away. It opens the /plugin panel on that plugin so you can review it and pick a scope first. The panel has four tabs you will use: Discover (browse), Installed (manage), Marketplaces (catalogs) and Errors (what failed to load).

Then use it: /commit-commands:commit writes a commit message from your changes. If the install fails with Marketplace "claude-plugins-official" not found, add the marketplace by hand (section 07).

No session open? You can install from any shell, for example in a setup script: claude plugin install commit-commands@claude-plugins-official. It installs at user scope unless you add --scope project or --scope local, and the plugin loads the next time you start Claude Code (or after /reload-plugins).

05Scopes: who gets the plugin

What. The scope you pick when installing decides who the plugin is turned on for, and which settings file records it.

Why it matters. Choosing project scope is how a team gets the same setup without a wiki page of instructions. One catch worth knowing: committing the entry turns the plugin on for teammates but does not download it to their machines, so each person also runs claude plugin install <name>@<marketplace> --scope project once. When the same plugin is set at several scopes, local beats project, and project beats user.

06Install a plugin in VS Code

What and why. Most readers of this series live in VS Code, and the extension has its own plugin screen, so you never need a terminal. How:

Because the terminal and the VS Code extension read the same settings files, a plugin you install at user scope in either one is available in the other. The integrated terminal (Ctrl+`) is also handy for the shell commands in this article. Two places behave differently: cloud sessions (including claude.ai/code in the browser) do not load your local plugins at all, and non-interactive claude -p runs cannot run /plugin (plugins you already installed still load, so manage them from a shell).

07Add a marketplace that is not built in

What and why. A coworker or an open-source author publishes a plugin in their own marketplace. Claude Code has to know that catalog before you can install from it. You add it once. How: inside a session use /plugin marketplace add (the short form /plugin market add also works). From a shell use claude plugin marketplace add. The source can be any of these:

# one step: add the marketplace and install a plugin from it
claude plugin install deploy-helper --marketplace your-org/plugins

# or two steps
claude plugin marketplace add your-org/plugins
claude plugin install deploy-helper@plugins

# see what you have added, and where each one came from
claude plugin marketplace list

The one-step form needs a recent Claude Code (the in-session form v2.1.275 or later, the shell form v2.1.292 or later). Run claude --version and update if yours is older. Include https:// on every URL. For a private repository, Claude Code uses the git credentials already on your machine and never prompts, so sign in first (for example gh auth login for HTTPS, or an SSH key that works without a passphrase prompt).

08Code intelligence plugins: a plugin you will actually keep

What. A code intelligence plugin connects Claude Code to a language server, the same technology behind red squiggles and go-to-definition in your editor. Why it matters. After every edit Claude then sees the type errors and missing imports its own change introduced, without running a build, and can look up symbols precisely instead of searching text. For a beginner this is one of the highest-value plugins because it catches mistakes early.

How. The plugin does not include the language server. Install the binary first, then the plugin. Official plugins exist for C and C++, C#, Go, Java, Kotlin, Lua, PHP, Python, Ruby, Rust, Swift and TypeScript or JavaScript. For TypeScript:

# 1. the language server (needs Node.js)
npm install -g typescript-language-server typescript
Get-Command typescript-language-server     # confirm it is on PATH

# 2. the plugin, inside Claude Code
> /plugin install typescript-lsp@claude-plugins-official

Other languages follow the same pattern: pyright-lsp (Python), gopls-lsp (Go), rust-analyzer-lsp (Rust) and so on, each with its own binary listed in the plugin's README. The server starts the first time Claude edits a matching file. You know it works when a line like Found 1 new diagnostic issues in 1 files appears under an edit (press Ctrl+O to read them). If it does not, open /plugin, check the Errors tab, and look for Executable not found in $PATH, which names the binary to install. These plugins work in terminal sessions, not in cloud sessions. Claude Code may also pop up an LSP plugin recommendation offering the plugin when it sees the binary on your machine.

09Using what you installed

What and why. Everything a plugin adds is prefixed with the plugin's name, so two plugins can both have a review skill without a clash. Knowing the naming tells you where to look when something is missing. How:

10Manage: update, switch off, remove

What and why. Plugins are not install-and-forget. You will want to turn one off for a while, update it, or remove it. How: open /plugin and press Tab to reach the Installed tab. Type to filter, press Space to enable or disable the selected plugin, and Enter to open its details with Update now and Uninstall. When you close the panel with pending changes, Claude Code reloads plugins for you.

claude plugin list                                        # what is installed, with scope and status
claude plugin disable commit-commands@claude-plugins-official
claude plugin enable  commit-commands@claude-plugins-official
claude plugin update  commit-commands@claude-plugins-official
claude plugin uninstall commit-commands@claude-plugins-official --scope user
claude plugin details commit-commands                   # what it adds and what it costs

# in a running session, after editing a plugin or changing settings
> /reload-plugins

11What a plugin costs you

What. An enabled plugin is part of every session, even ones where you never touch it. For each skill and agent that Claude may use on its own, a short name and description sits in Claude's context on every turn. Its hooks fire on their events and its servers run alongside the session. Why it matters. Those tokens count toward your usage and take room in the context window you learned to protect on Day 5. Ten plugins you forgot about can quietly make every session a little worse.

How to keep it lean. Before installing, read the Context cost numbers on an official plugin's page: Every turn is what it adds to each message, When invoked is what its skills and agents add once loaded. After installing, run claude plugin details <name> in a shell. The Always-on line is the per-session token cost, and the rows below show which skill or agent contributes most. On the Installed tab, plugins you have not used recently are grouped under Not used recently. Disable or uninstall those. Disabling is the gentle option: the plugin stays installed but stops costing anything.

12Is it safe? Vet a plugin before you install

What. A plugin can run code on your computer with your permissions. Hooks are shell commands, MCP and language servers are programs Claude Code starts, and a bin/ folder puts executables on the PATH. Skills and agents are instructions that steer what Claude does with its tools. Why it matters. Claude Code's permission rules and sandbox cover the tool calls Claude makes, not the code a plugin's hooks and servers run by themselves. So the trust decision is made when you install, and a marketplace's name tells you who publishes the catalog, not what each plugin does. Auto-update also means files you reviewed can change later.

How. A five-minute check that catches most problems:

Changed your mind? claude plugin uninstall <plugin> with the same --scope you installed it at. Its cached files linger for 14 days, and you can delete the folder under ~/.claude/plugins/cache/ yourself to clear them now. If you no longer trust the author, remove the marketplace too.

13Build your first plugin in five minutes

What and why. Building one teaches you the layout, and it is far less work than it sounds: a plugin is a folder, one small JSON file and your existing Markdown. We will make a plugin with a single greeting skill and run it without installing anything, using the --plugin-dir flag, which loads a folder for one session only. How:

mkdir my-first-plugin\.claude-plugin
mkdir my-first-plugin\skills\hello

{
  "name": "my-first-plugin",
  "description": "A greeting plugin to learn the basics",
  "version": "1.0.0",
  "author": { "name": "Your Name" }
}

Only name is required. It also becomes the prefix on everything the plugin adds, so do not use spaces. version is optional: set it and users stay on that version until you change it. Now the skill:

---
name: hello
description: Greet the user with a friendly message
disable-model-invocation: true
---

Greet the user warmly and ask how you can help them today.

The disable-model-invocation: true line means only you can run it, Claude will not trigger it by itself (remove the line for a skill Claude may use on its own). Then check it, run Claude with the plugin loaded, and try it:

claude plugin validate .\my-first-plugin     # prints: Validation passed
claude --plugin-dir .\my-first-plugin       # loads it for this session only

> /my-first-plugin:hello

Edit the skill while the session is open, then run /reload-plugins to see the change. You can pass --plugin-dir more than once to load several plugins, or point it at a folder that contains several plugin folders. In VS Code: create the folders with the Explorer's New Folder and New File, run the commands in the integrated terminal, and use code my-first-plugin to open it as its own window. JSON files get colour and warnings for stray commas, which saves a common mistake.

Let Claude scaffold it. Install Anthropic's plugin-dev plugin from the official marketplace, then run /plugin-dev:create-plugin followed by a description of what you want. Claude walks you through designing, creating and validating it. And if you only want a personal plugin that loads in every session with no flag, claude plugin init my-tool scaffolds one under ~/.claude/skills/.

14The layout: what goes where

What and why. Each kind of component lives in a fixed place under the plugin's root folder. If a piece does not show up, nine times out of ten it is in the wrong folder. How to read this:

my-plugin\
  .claude-plugin\
    plugin.json          manifest: ONLY this file goes in here
  skills\
    review\
      SKILL.md           one folder per skill
  agents\
    security-reviewer.md one file per subagent
  hooks\
    hooks.json           hooks, same shape as settings.json
  scripts\
    protect_files.py       your own helper scripts (any name)
  .mcp.json                MCP servers
  bin\                     optional: programs added to PATH

The classic mistake: putting skills/, agents/ or hooks/ inside .claude-plugin/. Only plugin.json belongs there. Everything else sits next to that folder at the plugin root.

15Convert your existing setup into a plugin

What and why. If you followed Days 7 to 9 you already have skills, agents and hooks under .claude/. You can move them into a plugin without rewriting them, and then reuse them in other projects. How, run these from the project root:

mkdir my-plugin\.claude-plugin
mkdir my-plugin\hooks

# copy whichever folders you have
Copy-Item -Recurse .claude\skills my-plugin\
Copy-Item -Recurse .claude\agents my-plugin\

{
  "name": "my-plugin",
  "description": "Migrated from standalone configuration",
  "version": "1.0.0"
}

Then create my-plugin/hooks/hooks.json and paste in the hooks object from your .claude/settings.json (the format is identical). Test with claude --plugin-dir .\my-plugin. Your skill /deploy is now also /my-plugin:deploy, and the agent reviewer also exists as my-plugin:reviewer. Watch out: while the originals are still in .claude/, skills and agents coexist because of the prefix, but hooks have no prefix, so a hook in both places runs twice. Once the plugin works, delete the originals and remove the hooks object from your settings.

16A real example: one team-standards plugin

What and why. Let us put Days 8 and 9 into one plugin you could give a teammate: a review skill, a read-only reviewer helper, and a hook that refuses edits to your .env. Install it, and a new teammate gets the same guardrails on their first day. How: the folder is

team-standards\
  .claude-plugin\plugin.json
  skills\review\SKILL.md
  agents\code-reviewer.md
  hooks\hooks.json
  scripts\protect_files.py

{
  "name": "team-standards",
  "description": "Review skill, read-only reviewer and a guard for secret files",
  "version": "1.0.0"
}

---
name: review
description: Review my uncommitted changes with the team's standards
disable-model-invocation: true
---

Use the code-reviewer agent on my uncommitted changes.
Then summarise its findings as: must fix, should fix, nice to have.

---
name: code-reviewer
description: Reviews code changes for bugs, security issues and missing tests.
tools: Read, Grep, Glob, Bash
model: sonnet
---

You are a senior code reviewer. Run git diff, review only the changed code,
and report must fix, should fix and nice to have, each with file, line and fix.
Never edit files.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "python \"${CLAUDE_PLUGIN_ROOT}/scripts/protect_files.py\""
          }
        ]
      }
    ]
  }
}

import json, sys

event = json.load(sys.stdin)
path = event.get("tool_input", {}).get("file_path", "").replace("\\", "/")

for pattern in (".env", "package-lock.json", ".git/"):
    if pattern in path:
        print(f"Blocked by team-standards: {path} is protected", file=sys.stderr)
        sys.exit(2)
sys.exit(0)

This is the Day 9 protect-files recipe, now shipped inside the plugin. Notice the hook points at the script with ${CLAUDE_PLUGIN_ROOT}, so it works wherever the plugin is installed. On macOS and Linux the Python command is often python3, so change it there if python is not found. Test it:

claude plugin validate .\team-standards
claude --plugin-dir .\team-standards

> /team-standards:review              # the helper reviews your diff
> add a comment to my .env file          # refused by the hook

Want the plugin to carry a tool connection too? Add a .mcp.json at its root. A server declared as db in a plugin called team-standards appears in /mcp as plugin:team-standards:db. Once you are happy, claude plugin eval can run test cases with and without the plugin to check that it really changes Claude's behaviour.

17Share it with your team

What and why. A plugin on your laptop helps you. A plugin in a marketplace helps everyone. How. You have three routes, from smallest to largest:

Versions. Claude Code only downloads a new copy of a plugin when its version changes, so bump it on every release you want users to receive. Never rename a published plugin, because installs are recorded under the old name.

18For organisations: managed controls

What and why. If you work in a company, plugins are also a governance question. Administrators can use managed settings to allow or block marketplace sources, force-install chosen plugins on every machine, switch off --plugin-dir, and limit hooks to approved ones. As an individual you rarely touch this, but if a plugin you expect is missing or cannot be removed on a work machine, a managed policy is the likely reason. The Managed scope in the Installed tab marks plugins your organisation installed.

19When a plugin does not work

What and why. Plugins have several layers (settings, files on disk, the running session), so the fix depends on which layer failed. How: work through these in order.

20Cheat sheet: I want this, so run that

21Questions beginners ask

22Try this today

That finishes the extending-Claude-Code block of the series: MCP for tools, skills for know-how, subagents and hooks for helpers and rules, and plugins to package and share them all.