plugin-dev-guide

Plugin Development Guide

This meta-skill provides an overview of Claude Code plugin development and routes to specialized skills based on the task at hand.

Plugin Development Skills Overview

The plugin-dev toolkit provides 9 specialized skills for building Claude Code plugins, plus this guide. Each skill handles a specific domain of plugin development.

Skill Quick Reference

Skill	Purpose
plugin-structure	Directory layout, manifest, component organization
command-development	Simple prompts (single .md files in commands/)
agent-development	Autonomous subagents
skill-development	Complex prompts with bundled resources (skills/)
hook-development	Event-driven automation
mcp-integration	Model Context Protocol servers
lsp-integration	Language Server Protocol for code intelligence
plugin-settings	User configuration via .local.md
marketplace-structure	Plugin marketplace creation

When to Use Each Skill

Starting a New Plugin

Skill: plugin-structure

Use when the user needs to:

• Create a new plugin from scratch
• Understand plugin directory layout
• Configure plugin.json manifest
• Learn about component auto-discovery
• Use ${CLAUDE_PLUGIN_ROOT} for portable paths

Adding User-Facing Commands

Skill: command-development

Use when the user needs to:

• Create slash commands (/command-name)
• Configure command frontmatter (description, allowed-tools, model)
• Use dynamic arguments ($ARGUMENTS, $1, $2)
• Reference files with @ syntax
• Execute bash inline with [BANG] backticks

Creating Autonomous Agents

Skill: agent-development

Use when the user needs to:

• Create subagents for complex tasks
• Write agent system prompts
• Configure agent triggering (description with examples)
• Choose agent models and colors
• Restrict agent tool access

Building Skills

Skill: skill-development

Use when the user needs to:

• Create skills that extend Claude's capabilities
• Write SKILL.md with proper frontmatter
• Organize skill content with progressive disclosure
• Create references/, examples/, scripts/ directories
• Write effective trigger phrases

Implementing Event Hooks

Skill: hook-development

Use when the user needs to:

• React to Claude Code events (PreToolUse, Stop, SessionStart, etc.)
• Create prompt-based or command-based hooks
• Validate tool inputs before execution
• Enforce completion standards
• Block dangerous operations

Integrating External Services via MCP

Skill: mcp-integration

Use when the user needs to:

• Add MCP servers to plugins
• Configure stdio, SSE, HTTP, or WebSocket servers
• Set up authentication (OAuth, tokens)
• Use MCP tools in commands and agents
• Discover existing MCP servers on PulseMCP

Adding Code Intelligence via LSP

Skill: lsp-integration

Use when the user needs to:

• Add Language Server Protocol servers to plugins
• Enable go-to-definition and find-references
• Configure language-specific servers (pyright, gopls, rust-analyzer)
• Set up extensionToLanguage mappings
• Enhance Claude's code understanding

Managing Plugin Configuration

Skill: plugin-settings

Use when the user needs to:

• Store user-configurable settings
• Use .claude/plugin-name.local.md pattern
• Parse YAML frontmatter in hooks
• Create temporarily active hooks
• Manage agent state

Creating Plugin Marketplaces

Skill: marketplace-structure

Use when the user needs to:

• Create a marketplace for multiple plugins
• Configure marketplace.json
• Set up plugin sources (relative, GitHub, git URL)
• Distribute plugins to teams
• Organize plugin collections

Decision Tree for Skill Selection

User wants to...
├── Create/organize a plugin structure? → plugin-structure
├── Add a simple slash command (no bundled resources)? → command-development
├── Create an autonomous agent? → agent-development
├── Add a complex skill with scripts/references? → skill-development
├── React to Claude Code events? → hook-development
├── Integrate external service/API? → mcp-integration
├── Add code intelligence/LSP? → lsp-integration
├── Make plugin configurable? → plugin-settings
└── Distribute multiple plugins? → marketplace-structure

Common Multi-Skill Workflows

Building a Complete Plugin

1. Start: Load plugin-structure skill to create directory layout
2. Add features: Load command-development for user-facing commands
3. Automation: Load hook-development for event-driven behavior
4. Configuration: Load plugin-settings if user configuration needed
5. Validation: Use plugin-validator agent to validate structure

Creating an MCP-Powered Plugin

1. Start: Load plugin-structure for basic structure
2. Integration: Load mcp-integration to configure MCP servers
3. Commands: Load command-development to create commands that use MCP tools
4. Agents: Load agent-development for autonomous MCP workflows

Building a Code Intelligence Plugin

1. Start: Load plugin-structure for basic structure
2. LSP: Load lsp-integration to configure language servers
3. Commands: Load command-development for commands using LSP features

Building a Skill-Focused Plugin

1. Start: Load plugin-structure for basic structure
2. Skills: Load skill-development to create specialized skills
3. Validation: Use skill-reviewer agent to validate skill quality

Available Agents

The plugin-dev plugin also provides 3 agents:

Agent	Purpose
plugin-validator	Validates plugin structure and manifests
skill-reviewer	Reviews skill quality and triggering
agent-creator	Generates new agents from descriptions

Use agents proactively after creating components to ensure quality.

Available Commands

Command	Purpose
/plugin-dev:plugin-dev-guide	Overview and skill routing
/plugin-dev:start	Entry point - choose plugin or marketplace creation
/plugin-dev:create-plugin	8-phase guided plugin creation workflow
/plugin-dev:create-marketplace	8-phase guided marketplace creation workflow

---

User Request

$ARGUMENTS

If the user provided a request above, analyze it and either:

1. Route to a specific skill if the request clearly matches one domain
2. Answer directly using this guide's overview information
3. Ask for clarification if the request is ambiguous

If no request was provided, summarize the available plugin development capabilities and ask what the user wants to build or learn about.