plugins.md +0 −483 deleted
File Deleted View Diff
1> ## Documentation Index
2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
3> Use this file to discover all available pages before exploring further.
4
5# Create plugins
6
7> Create custom plugins to extend Claude Code with skills, agents, hooks, and MCP servers.
8
9Plugins let you extend Claude Code with custom functionality that can be shared across projects and teams. This guide covers creating your own plugins with skills, agents, hooks, and MCP servers.
10
11Looking to install existing plugins? See [Discover and install plugins](/docs/en/discover-plugins). For complete technical specifications, see [Plugins reference](/docs/en/plugins-reference).
12
13## When to use plugins vs standalone configuration
14
15Claude Code supports two ways to add custom skills, agents, and hooks:
16
17| Approach | Skill names | Best for |
18| :-------------------------------------------------------------------------------------------------------------- | :------------------- | :---------------------------------------------------------------------------------------------- |
19| **Standalone** (`.claude/` directory) | `/hello` | Personal workflows, project-specific customizations, quick experiments |
20| **Plugins** (self-contained directories with skills, agents, hooks, or a `.claude-plugin/plugin.json` manifest) | `/plugin-name:hello` | Sharing with teammates, distributing to community, versioned releases, reusable across projects |
21
22<Tip>
23 Start with standalone configuration in `.claude/` for quick iteration, then [convert to a plugin](#convert-existing-configurations-to-plugins) when you're ready to share.
24</Tip>
25
26## Quickstart
27
28This quickstart walks you through creating a plugin with a custom skill. You'll create a manifest (the configuration file that defines your plugin), add a skill, and test it locally using the `--plugin-dir` flag.
29
30### Prerequisites
31
32* Claude Code [installed and authenticated](/docs/en/quickstart#step-1-install-claude-code)
33
34### Create your first plugin
35
36<Steps>
37 <Step title="Create the plugin directory">
38 Every plugin lives in its own directory containing your skills, agents, or hooks, optionally alongside a `.claude-plugin/plugin.json` manifest. The location doesn't matter for this quickstart because you'll point Claude Code at the directory with `--plugin-dir` in the test step. Create it anywhere convenient, such as a scratch folder or a projects directory:
39
40 ```bash theme={null}
41 mkdir my-first-plugin
42 ```
43
44 The remaining steps run from the parent directory and reference paths like `my-first-plugin/...` relative to it.
45 </Step>
46
47 <Step title="Create the plugin manifest">
48 The manifest file at `.claude-plugin/plugin.json` defines your plugin's identity: its name, description, and version. Claude Code uses this metadata to display your plugin in the plugin manager.
49
50 Create the `.claude-plugin` directory inside your plugin folder:
51
52 ```bash theme={null}
53 mkdir my-first-plugin/.claude-plugin
54 ```
55
56 Then create `my-first-plugin/.claude-plugin/plugin.json` with this content:
57
58 ```json my-first-plugin/.claude-plugin/plugin.json theme={null}
59 {
60 "name": "my-first-plugin",
61 "description": "A greeting plugin to learn the basics",
62 "version": "1.0.0",
63 "author": {
64 "name": "Your Name"
65 }
66 }
67 ```
68
69 | Field | Purpose |
70 | :------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
71 | `name` | Unique identifier and skill namespace. Skills are prefixed with this (e.g., `/my-first-plugin:hello`). |
72 | `description` | Shown in the plugin manager when browsing or installing plugins. |
73 | `version` | Optional. If set, users only receive updates when you bump this field, except for a [`command` source](/docs/en/plugin-marketplaces#command-sources) or a plugin [loaded in place](/docs/en/plugins-reference#plugin-caching-and-file-resolution); see [version management](/docs/en/plugins-reference#version-management). If omitted, the version comes from the next source in [version management](/docs/en/plugins-reference#version-management). |
74 | `author` | Optional. Helpful for attribution. |
75
76 For additional fields like `homepage`, `repository`, and `license`, see the [full manifest schema](/docs/en/plugins-reference#plugin-manifest-schema).
77 </Step>
78
79 <Step title="Add a skill">
80 Skills live in the `skills/` directory. Each skill is a folder containing a `SKILL.md` file. The folder name becomes the skill name, prefixed with the plugin's namespace (`hello/` in a plugin named `my-first-plugin` creates `/my-first-plugin:hello`).
81
82 Create a skill directory in your plugin folder:
83
84 ```bash theme={null}
85 mkdir -p my-first-plugin/skills/hello
86 ```
87
88 Then create `my-first-plugin/skills/hello/SKILL.md` with this content:
89
90 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
91 ---
92 description: Greet the user with a friendly message
93 disable-model-invocation: true
94 ---
95
96 Greet the user warmly and ask how you can help them today.
97 ```
98 </Step>
99
100 <Step title="Test your plugin">
101 Run Claude Code with the `--plugin-dir` flag to load your plugin:
102
103 ```bash theme={null}
104 claude --plugin-dir ./my-first-plugin
105 ```
106
107 Once Claude Code starts, try your new skill:
108
109 ```shell theme={null}
110 /my-first-plugin:hello
111 ```
112
113 You'll see Claude respond with a greeting. Run `/help` and open the **Custom commands** tab to see your skill listed under the plugin namespace.
114
115 <Note>
116 **Why namespacing?** Plugin skills are always namespaced (like `/my-first-plugin:hello`) to prevent conflicts when multiple plugins have skills with the same name.
117
118 To change the namespace prefix, update the `name` field in `plugin.json`.
119 </Note>
120 </Step>
121
122 <Step title="Add skill arguments">
123 Make your skill dynamic by accepting user input. The `$ARGUMENTS` placeholder captures any text the user provides after the skill name.
124
125 Update your `SKILL.md` file:
126
127 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
128 ---
129 description: Greet the user with a personalized message
130 ---
131
132 # Hello Skill
133
134 Greet the user named "$ARGUMENTS" warmly and ask how you can help them today. Make the greeting personal and encouraging.
135 ```
136
137 Run `/reload-plugins` to pick up the changes. Then try the skill with your name:
138
139 ```shell theme={null}
140 /my-first-plugin:hello Alex
141 ```
142
143 Claude will greet you by name. For more on passing arguments to skills, see [Skills](/docs/en/skills#pass-arguments-to-skills).
144 </Step>
145</Steps>
146
147<Tip>
148 The `--plugin-dir` flag is useful for development and testing. When you're ready to share your plugin with others, see [Create and distribute a plugin marketplace](/docs/en/plugin-marketplaces).
149</Tip>
150
151## Develop a plugin in your skills directory
152
153Instead of passing `--plugin-dir` on every launch, you can keep a plugin in your skills directory and have Claude Code load it automatically. `claude plugin init` scaffolds one:
154
155```bash theme={null}
156claude plugin init my-tool
157```
158
159This creates `~/.claude/skills/my-tool/` with a `.claude-plugin/plugin.json` manifest and a starter `SKILL.md`. On the next session it loads as `my-tool@skills-dir` with no marketplace or install step.
160
161For the auto-load rules, personal vs. project scope, the workspace-trust requirement, and how to update or remove one, see [Skills-directory plugins](/docs/en/plugins-reference#skills-directory-plugins).
162
163## Plugin structure overview
164
165You've created a plugin with a skill, but plugins can include much more: custom agents, hooks, MCP servers, LSP servers, and background monitors.
166
167<Warning>
168 **Common mistake**: Don't put `commands/`, `agents/`, `skills/`, or `hooks/` inside the `.claude-plugin/` directory. Only `plugin.json` goes inside `.claude-plugin/`. All other directories must be at the plugin root level.
169
170 The plugin root is the individual plugin's own directory, such as `my-first-plugin/` from the [quickstart](#quickstart). It is never `~/.claude/`. For example, Claude Code doesn't read a `.mcp.json` placed at `~/.claude/.mcp.json`.
171</Warning>
172
173| Directory | Location | Purpose |
174| :---------------- | :---------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
175| `.claude-plugin/` | Plugin root | Contains `plugin.json` manifest (optional if components use default locations) |
176| `skills/` | Plugin root | Skills as `<name>/SKILL.md` directories |
177| `commands/` | Plugin root | Skills as flat Markdown files. Use `skills/` for new plugins |
178| `agents/` | Plugin root | Custom agent definitions |
179| `hooks/` | Plugin root | Event handlers in `hooks.json` |
180| `.mcp.json` | Plugin root | MCP server configurations |
181| `.lsp.json` | Plugin root | LSP server configurations for code intelligence |
182| `monitors/` | Plugin root | Background monitor configurations in `monitors.json` |
183| `bin/` | Plugin root | Executables added to the Bash tool's `PATH` while the plugin is enabled. You can't include this directory in a plugin you [distribute through claude.ai organization settings](/docs/en/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |
184| `settings.json` | Plugin root | Default [settings](/docs/en/settings) applied when the plugin is enabled |
185
186A plugin that ships exactly one skill can place `SKILL.md` directly at the plugin root instead of creating a `skills/` directory. Claude Code loads it as a single skill and uses the frontmatter `name` field for the invocation name. Use the `skills/` layout for plugins that may grow to more than one skill.
187
188## Develop more complex plugins
189
190Once you're comfortable with basic plugins, you can create more sophisticated extensions.
191
192### Add Skills to your plugin
193
194Plugins can include [Agent Skills](/docs/en/skills) to extend Claude's capabilities. Skills are model-invoked: Claude automatically uses them based on the task context.
195
196Add a `skills/` directory at your plugin root with Skill folders containing `SKILL.md` files:
197
198```text theme={null}
199my-plugin/
200├── .claude-plugin/
201│ └── plugin.json
202└── skills/
203 └── code-review/
204 └── SKILL.md
205```
206
207Each `SKILL.md` contains YAML frontmatter and instructions. Include a `description` so Claude knows when to use the skill:
208
209```yaml theme={null}
210description: Reviews code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
211
212When reviewing code, check for:
2131. Code organization and structure
2142. Error handling
2153. Security concerns
2164. Test coverage
217```
218
219After you install the plugin, check the install summary: if it reports `Run /reload-plugins to activate.`, see [Apply plugin changes without restarting](/docs/en/discover-plugins#apply-plugin-changes-without-restarting) to load the Skills in your current session. For complete Skill authoring guidance including progressive disclosure and tool restrictions, see [Agent Skills](/docs/en/skills).
220
221### Add LSP servers to your plugin
222
223<Tip>
224 For common languages like TypeScript, Python, and Rust, install the pre-built LSP plugins from the official marketplace. Create custom LSP plugins only when you need support for languages not already covered.
225</Tip>
226
227LSP (Language Server Protocol) plugins give Claude real-time code intelligence. If you need to support a language that doesn't have an official LSP plugin, you can create your own by adding an `.lsp.json` file to your plugin:
228
229```json .lsp.json theme={null}
230{
231 "go": {
232 "command": "gopls",
233 "args": ["serve"],
234 "extensionToLanguage": {
235 ".go": "go"
236 }
237 }
238}
239```
240
241Users installing your plugin must have the language server binary installed on their machine.
242
243To confirm the server starts, launch Claude Code with the plugin enabled and check the `/plugin` Errors tab: a language server that fails to start appears there, for example with `Executable not found in $PATH` when the binary isn't installed. An entry with an invalid configuration is skipped instead; run `claude --debug` to see why.
244
245For complete LSP configuration options, see [LSP servers](/docs/en/plugins-reference#lsp-servers).
246
247### Add background monitors to your plugin
248
249Background monitors let your plugin watch logs, files, or external status in the background and notify Claude as events arrive. Claude Code starts each monitor automatically when the plugin is active, so you don't need to instruct Claude to start the watch.
250
251Add a `monitors/monitors.json` file at the plugin root with an array of monitor entries:
252
253```json monitors/monitors.json theme={null}
254[
255 {
256 "name": "error-log",
257 "command": "tail -F ./logs/error.log",
258 "description": "Application error log"
259 }
260]
261```
262
263Each stdout line from `command` is delivered to Claude as a notification during the session. For the full schema, including the `when` trigger and variable substitution, see [Monitors](/docs/en/plugins-reference#monitors).
264
265### Ship default settings with your plugin
266
267Plugins can include a `settings.json` file at the plugin root to apply default configuration when the plugin is enabled. Currently, only the `agent` and `subagentStatusLine` keys are supported.
268
269Setting `agent` activates one of the plugin's [custom agents](/docs/en/sub-agents) as the main thread, applying its system prompt, tool restrictions, and model. This lets a plugin change how Claude Code behaves by default when enabled.
270
271```json settings.json theme={null}
272{
273 "agent": "security-reviewer"
274}
275```
276
277This example activates the `security-reviewer` agent defined in the plugin's `agents/` directory. Settings from `settings.json` take priority over `settings` declared in `plugin.json`. Unknown keys are silently ignored.
278
279### Organize complex plugins
280
281For plugins with many components, organize your directory structure by functionality. For complete directory layouts and organization patterns, see [Plugin directory structure](/docs/en/plugins-reference#plugin-directory-structure).
282
283### Test your plugins locally
284
285Use the `--plugin-dir` flag to test plugins during development. This loads your plugin directly without requiring installation.
286
287```bash theme={null}
288claude --plugin-dir ./my-plugin
289```
290
291The flag also accepts a `.zip` archive of the plugin directory.
292
293```bash theme={null}
294claude --plugin-dir ./my-plugin.zip
295```
296
297When a `--plugin-dir` plugin has the same name as an installed marketplace plugin, the local copy takes precedence for that session. This lets you test changes to a plugin you already have installed without uninstalling it first. The exception is plugins that managed settings force-enable or force-disable: `--plugin-dir` cannot override those.
298
299As you make changes to your plugin, run `/reload-plugins` to pick up the updates without restarting. This reloads plugins, skills, agents, hooks, plugin MCP servers, and plugin LSP servers; in a session without an interactive terminal, plugin MCP server changes [wait for your next session](/docs/en/discover-plugins#apply-plugin-changes-without-restarting). Test your plugin components:
300
301* Try your skills with `/plugin-name:skill-name`
302* Check that agents appear in `/context` under Custom Agents, or @-mention one by its scoped name
303* Trigger the event each hook matches, such as asking Claude to edit a file for a `PostToolUse` hook, and confirm its effect. Claude Code records which hooks matched, their exit codes, and their output in the [debug log](/docs/en/hooks#debug-hooks)
304
305<Tip>
306 You can load multiple plugins at once by specifying the flag multiple times:
307
308 ```bash theme={null}
309 claude --plugin-dir ./plugin-one --plugin-dir ./plugin-two
310 ```
311
312 To test a plugin together with a plugin it depends on, see [Test a plugin and its dependency locally](/docs/en/plugin-dependencies#test-a-plugin-and-its-dependency-locally).
313</Tip>
314
315To load plugins in a session where you can't add the flag, list their absolute paths in the [`CLAUDE_CODE_PLUGIN_DIRS`](/docs/en/env-vars#variables) environment variable instead. Claude Code loads each path as it loads a `--plugin-dir` path. These plugins load in addition to any you pass with `--plugin-dir`. [Project and local settings can't set this variable](/docs/en/settings-reference#variables-claude-code-ignores-in-env). `CLAUDE_CODE_PLUGIN_DIRS` requires Claude Code v2.1.280 or later.
316
317Trying the plugin with `--plugin-dir` tells you it can work. To find out how often Claude actually reaches for it and gets the right result, run it against a set of test prompts with [`claude plugin eval`](/docs/en/plugin-evals). Each prompt runs several times with and without the plugin loaded, so you can see what the plugin contributes and catch regressions when you change it or a new model ships.
318
319To load several plugins from one place, pass a folder that holds them, such as `--plugin-dir ./plugins`. Loading a folder of plugins requires Claude Code v2.1.265 or later. Claude Code reads the folder's top level to decide which plugins load, and in an interactive session it also watches the folder for later changes:
320
321* **What loads**: if the folder has no manifest or plugin components at its top level, Claude Code treats it as a folder of plugins. Each immediate subfolder that has a `.claude-plugin/plugin.json` manifest loads as a separate plugin. Claude Code skips everything else in the folder without reporting an error, including plugins that have no manifest.
322* **Changes during an interactive session**: a subfolder you add loads as a new plugin once its manifest is in place, and when you remove a subfolder, its plugin unloads. Claude Code prints a line in the session for each change. If applying a change mid-conversation would [invalidate the prompt cache](/docs/en/prompt-caching#enabling-or-disabling-a-plugin), Claude Code holds it, and the line says to run `/reload-plugins` to apply it.
323
324To test a plugin that is already packaged as a `.zip` archive and hosted at a URL, such as a CI build artifact, use `--plugin-url` instead. Claude Code fetches the archive at startup and loads it for that session only. If Claude Code can't fetch the archive, or the archive is invalid, it starts without the plugin and records a plugin load error that you can review in the `/plugin` manager's **Errors** tab. The same [trust considerations](/docs/en/discover-plugins#security) apply as for any plugin source: only point this flag at archives you control or trust.
325
326To load multiple plugins, repeat the flag for each URL:
327
328```bash theme={null}
329claude --plugin-url https://example.com/my-plugin.zip --plugin-url https://example.com/other.zip
330```
331
332Or pass space-separated URLs as one quoted argument:
333
334```bash theme={null}
335claude --plugin-url "https://example.com/my-plugin.zip https://example.com/other.zip"
336```
337
338### Debug plugin issues
339
340If your plugin isn't working as expected:
341
3421. **Check the structure**: Ensure your directories are at the plugin root, not inside `.claude-plugin/`
3432. **Test components individually**: Check each skill, agent, and hook separately
3443. **Use validation and debugging tools**: See [Debugging and development tools](/docs/en/plugins-reference#debugging-and-development-tools) for CLI commands and troubleshooting techniques
345
346### Share your plugins
347
348When your plugin is ready to share:
349
3501. **Add documentation**: Include a `README.md` with installation and usage instructions
3512. **Choose a versioning strategy**: Decide whether to set an explicit `version` or rely on the fallback described in [version management](/docs/en/plugins-reference#version-management).
3523. **Create or use a marketplace**: Distribute through [plugin marketplaces](/docs/en/plugin-marketplaces) for installation
3534. **Test with others**: Have team members test the plugin before wider distribution
354
355Once your plugin is in a marketplace, others can install it using the instructions in [Discover and install plugins](/docs/en/discover-plugins). To keep a plugin internal to your team, host the marketplace in a [private repository](/docs/en/plugin-marketplaces#private-repositories).
356
357### Submit your plugin to the community marketplace
358
359Anthropic maintains two public marketplaces for Claude Code plugins:
360
361* **`claude-plugins-official`**: a curated set of plugins maintained by Anthropic. Claude Code registers it automatically the first time you start Claude Code interactively. If you run Claude Code non-interactively before that first interactive launch, or a [marketplace policy](/docs/en/plugin-marketplaces#managed-marketplace-restrictions) blocked an earlier attempt, register it yourself with `claude plugin marketplace add anthropics/claude-plugins-official`.
362* **`claude-community`**: the public community marketplace where third-party submissions land after review. Users add it with `/plugin marketplace add anthropics/claude-plugins-community` and install from it as `@claude-community`.
363
364To submit your plugin for community-marketplace review, use one of the in-app forms:
365
366* **claude.ai**: [claude.ai/admin-settings/directory/submissions/plugins/new](https://claude.ai/admin-settings/directory/submissions/plugins/new)
367* **Console**: [platform.claude.com/plugins/submit](https://platform.claude.com/plugins/submit)
368
369The claude.ai form requires a Team or Enterprise organization and directory management access; organization Owners have this access by default. Individual authors who aren't part of a Team or Enterprise organization can use the Console form instead.
370
371Run `claude plugin validate ./your-plugin` locally before you submit, replacing `./your-plugin` with the path to your plugin directory. The review pipeline runs the same check on every submission, along with automated safety screening. When validation passes, Claude Code prints `✔ Validation passed`, or `✔ Validation passed with warnings` if there are warnings. Warnings don't fail validation; add `--strict` to treat them as errors.
372
373Approved plugins are pinned to a specific commit SHA in the [`anthropics/claude-plugins-community`](https://github.com/anthropics/claude-plugins-community) catalog, and CI bumps the pin automatically as you push new commits to your repository. The public catalog syncs nightly from the review pipeline, so there can be a delay between approval and your plugin appearing in `marketplace.json`. To check whether your plugin is installable yet, search for its name in the [community catalog](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json).
374
375The official marketplace, `claude-plugins-official`, is curated separately. Anthropic decides which plugins to include at its discretion. There is no application process, and the submission form does not add plugins to the official marketplace.
376
377If Anthropic lists your plugin in the official marketplace, your CLI can prompt Claude Code users to install it. See [Recommend your plugin from your CLI](/docs/en/plugin-hints).
378
379## Convert existing configurations to plugins
380
381If you already have skills or hooks in your `.claude/` directory, you can convert them into a plugin for easier sharing and distribution.
382
383### Migration steps
384
385<Steps>
386 <Step title="Create the plugin structure">
387 Create a new plugin directory in your project root, alongside the existing `.claude/` folder, so the relative `cp` paths in the next step resolve:
388
389 ```bash theme={null}
390 mkdir -p my-plugin/.claude-plugin
391 ```
392
393 Create the manifest file at `my-plugin/.claude-plugin/plugin.json`:
394
395 ```json my-plugin/.claude-plugin/plugin.json theme={null}
396 {
397 "name": "my-plugin",
398 "description": "Migrated from standalone configuration",
399 "version": "1.0.0"
400 }
401 ```
402 </Step>
403
404 <Step title="Copy your existing files">
405 Copy each configuration directory you have to the plugin root. You might not have all three: if a directory doesn't exist, `cp` prints `No such file or directory` and copies nothing, so skip that command or ignore the error.
406
407 ```bash theme={null}
408 cp -r .claude/commands my-plugin/
409
410 cp -r .claude/agents my-plugin/
411
412 cp -r .claude/skills my-plugin/
413 ```
414
415 Your plugin now contains copies of the directories you had under `.claude/`. Run `ls my-plugin` to confirm: you should see each directory you copied.
416 </Step>
417
418 <Step title="Migrate hooks">
419 If you have hooks in your settings, create a hooks directory:
420
421 ```bash theme={null}
422 mkdir my-plugin/hooks
423 ```
424
425 Create `my-plugin/hooks/hooks.json` with your hooks configuration. Copy the `hooks` object from your `.claude/settings.json` or `settings.local.json`, since the format is the same. The command receives hook input as JSON on stdin, so use `jq` to extract the file path:
426
427 ```json my-plugin/hooks/hooks.json theme={null}
428 {
429 "hooks": {
430 "PostToolUse": [
431 {
432 "matcher": "Write|Edit",
433 "hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npm run lint:fix" }]
434 }
435 ]
436 }
437 }
438 ```
439 </Step>
440
441 <Step title="Test your migrated plugin">
442 Load your plugin to verify everything works:
443
444 ```bash theme={null}
445 claude --plugin-dir ./my-plugin
446 ```
447
448 Test each component: run your commands, check that agents appear in `/context`, and trigger the event each hook matches to confirm its effect. Claude Code records which hooks matched and how they exited in the [debug log](/docs/en/hooks#debug-hooks).
449 </Step>
450</Steps>
451
452### What changes when migrating
453
454| Standalone (`.claude/`) | Plugin |
455| :---------------------------- | :------------------------------- |
456| Only available in one project | Can be shared via marketplaces |
457| Files in `.claude/commands/` | Files in `plugin-name/commands/` |
458| Hooks in `settings.json` | Hooks in `hooks/hooks.json` |
459| Must manually copy to share | Install with `/plugin install` |
460
461<Note>
462 After migrating, remove the original files from `.claude/` to avoid duplicates. Project and user `.claude/agents/` definitions override same-named plugin agents, so the plugin version only takes effect once the originals are removed. Plugin skills are namespaced as `/plugin-name:skill-name`, so the original `/skill-name` and the plugin copy both remain available rather than one overriding the other.
463</Note>
464
465## Next steps
466
467Now that you understand Claude Code's plugin system, here are suggested paths for different goals:
468
469### For plugin users
470
471* [Discover and install plugins](/docs/en/discover-plugins): browse marketplaces and install plugins
472* [Configure team marketplaces](/docs/en/discover-plugins#configure-team-marketplaces): set up repository-level plugins for your team
473
474### For plugin developers
475
476* [Test plugins with evals](/docs/en/plugin-evals): measure what your plugin changes and gate CI on it
477* [Create and distribute a marketplace](/docs/en/plugin-marketplaces): package and share your plugins
478* [Plugins reference](/docs/en/plugins-reference): complete technical specifications
479* Dive deeper into specific plugin components:
480 * [Skills](/docs/en/skills): skill development details
481 * [Subagents](/docs/en/sub-agents): agent configuration and capabilities
482 * [Hooks](/docs/en/hooks): event handling and automation
483 * [MCP](/docs/en/mcp): external tool integration