Create plugins

Create custom plugins to extend Claude Code with skills, agents, hooks, and MCP servers.

Plugins 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.

Looking to install existing plugins? See Discover and install plugins. For complete technical specifications, see Plugins reference.

When to use plugins vs standalone configuration

Claude Code supports two ways to add custom skills, agents, and hooks:

Use standalone configuration when:

• You're customizing Claude Code for a single project
• The configuration is personal and doesn't need to be shared
• You're experimenting with skills or hooks before packaging them
• You want short skill names like /hello or /review

Use plugins when:

• You want to share functionality with your team or community
• You need the same skills/agents across multiple projects
• You want version control and easy updates for your extensions
• You're distributing through a marketplace
• You're okay with namespaced skills like /my-plugin:hello (namespacing prevents conflicts between plugins)

Quickstart

This 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.

Prerequisites

• Claude Code installed and authenticated
• Claude Code version 1.0.33 or later (run claude --version to check)

Create your first plugin

mkdir my-first-plugin

mkdir my-first-plugin/.claude-plugin

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

mkdir -p my-first-plugin/skills/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.

claude --plugin-dir ./my-first-plugin

/my-first-plugin:hello

---
description: Greet the user with a personalized message
---

# Hello Command

Greet the user named "$ARGUMENTS" warmly and ask how you can help them today. Make the greeting personal and encouraging.

/my-first-plugin:hello Alex

You've successfully created and tested a plugin with these key components:

• Plugin manifest (.claude-plugin/plugin.json): describes your plugin's metadata
• Commands directory (commands/): contains your custom skills
• Skill arguments ($ARGUMENTS): captures user input for dynamic behavior

Plugin structure overview

You've created a plugin with a skill, but plugins can include much more: custom agents, hooks, MCP servers, and LSP servers.

Develop more complex plugins

Once you're comfortable with basic plugins, you can create more sophisticated extensions.

Add Skills to your plugin

Plugins can include Agent Skills to extend Claude's capabilities. Skills are model-invoked: Claude automatically uses them based on the task context.

Add a skills/ directory at your plugin root with Skill folders containing SKILL.md files:

my-plugin/
├── .claude-plugin/
│   └── plugin.json
└── skills/
    └── code-review/
        └── SKILL.md

Each SKILL.md needs frontmatter with name and description fields, followed by instructions:

---
name: code-review
description: Reviews code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
---

When reviewing code, check for:
1. Code organization and structure
2. Error handling
3. Security concerns
4. Test coverage

After installing the plugin, restart Claude Code to load the Skills. For complete Skill authoring guidance including progressive disclosure and tool restrictions, see Agent Skills.

Add LSP servers to your plugin

LSP (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:

{
  "go": {
    "command": "gopls",
    "args": ["serve"],
    "extensionToLanguage": {
      ".go": "go"
    }
  }
}

Users installing your plugin must have the language server binary installed on their machine.

For complete LSP configuration options, see LSP servers.

Organize complex plugins

For plugins with many components, organize your directory structure by functionality. For complete directory layouts and organization patterns, see Plugin directory structure.

Test your plugins locally

Use the --plugin-dir flag to test plugins during development. This loads your plugin directly without requiring installation.

claude --plugin-dir ./my-plugin

As you make changes to your plugin, restart Claude Code to pick up the updates. Test your plugin components:

• Try your commands with /command-name
• Check that agents appear in /agents
• Verify hooks work as expected

Debug plugin issues

If your plugin isn't working as expected:

1. Check the structure: Ensure your directories are at the plugin root, not inside .claude-plugin/
2. Test components individually: Check each command, agent, and hook separately
3. Use validation and debugging tools: See Debugging and development tools for CLI commands and troubleshooting techniques

Share your plugins

When your plugin is ready to share:

1. Add documentation: Include a README.md with installation and usage instructions
2. Version your plugin: Use semantic versioning in your plugin.json
3. Create or use a marketplace: Distribute through plugin marketplaces for installation
4. Test with others: Have team members test the plugin before wider distribution

Once your plugin is in a marketplace, others can install it using the instructions in Discover and install plugins.

Convert existing configurations to plugins

If you already have skills or hooks in your .claude/ directory, you can convert them into a plugin for easier sharing and distribution.

Migration steps

mkdir -p my-plugin/.claude-plugin

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

# Copy commands
cp -r .claude/commands my-plugin/

# Copy agents (if any)
cp -r .claude/agents my-plugin/

# Copy skills (if any)
cp -r .claude/skills my-plugin/

mkdir my-plugin/hooks

{
"hooks": {
"PostToolUse": [
{
"matcher": "Write|Edit",
"hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npm run lint:fix" }]
}
]
}
}

claude --plugin-dir ./my-plugin

What changes when migrating

Next steps

Now that you understand Claude Code's plugin system, here are suggested paths for different goals:

For plugin users

• Discover and install plugins: browse marketplaces and install plugins
• Configure team marketplaces: set up repository-level plugins for your team

For plugin developers

• Create and distribute a marketplace: package and share your plugins
• Plugins reference: complete technical specifications
• Dive deeper into specific plugin components:
  • Skills: skill development details
  • Subagents: agent configuration and capabilities
  • Hooks: event handling and automation
  • MCP: external tool integration