Menu
Le prompt qui vérifie d'abord la source est sélectionné par défaut. Vous pouvez passer à une commande directe ou télécharger une copie locale.
Lisez SKILL.md et les fichiers associés affichés par SkillsMP avant de décider de l'installer.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/mhenke/claude-code-unplugged --skill plugin-devLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Basé sur la classification professionnelle SOC
Affichage de SKILL.md
| name | plugin-dev |
| description | Development assistance for creating CLI plugins |
A comprehensive toolkit for developing coding assistant plugins with expert guidance on hooks, MCP integration, plugin structure, and marketplace publishing.
The plugin-dev toolkit provides seven specialized skills to help you build high-quality coding assistant plugins:
Each skill follows best practices with progressive disclosure: lean core documentation, detailed references, working examples, and utility scripts.
A comprehensive, end-to-end workflow command for creating plugins from scratch, similar to the feature-dev workflow.
8-Phase Process:
Features:
Usage:
/plugin-dev:create-plugin [optional description]
# Examples:
/plugin-dev:create-plugin
/plugin-dev:create-plugin A plugin for managing database migrations
Use this workflow for structured, high-quality plugin development from concept to completion.
Trigger phrases: "create a hook", "add a PreToolUse hook", "validate tool use", "implement prompt-based hooks", "PLUGIN_ROOT", "block dangerous commands"
What it covers:
Resources:
Use when: Creating event-driven automation, validating operations, or enforcing policies in your plugin.
Trigger phrases: "add MCP server", "integrate MCP", "configure .mcp.json", "Model Context Protocol", "stdio/SSE/HTTP server", "connect external service"
What it covers:
Resources:
Use when: Integrating external services, APIs, databases, or tools into your plugin.
Trigger phrases: "plugin structure", "plugin.json manifest", "auto-discovery", "component organization", "plugin directory layout"
What it covers:
Resources:
Use when: Starting a new plugin, organizing components, or configuring the plugin manifest.
Trigger phrases: "plugin settings", "store plugin configuration", ".local.md files", "plugin state files", "read YAML frontmatter", "per-project plugin settings"
What it covers:
Resources:
Use when: Making plugins configurable, storing per-project state, or implementing user preferences.
Trigger phrases: "create a slash command", "add a command", "command frontmatter", "define command arguments", "organize commands"
What it covers:
Resources:
Use when: Creating slash commands, defining command arguments, or organizing plugin commands.
Trigger phrases: "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "autonomous agent"
What it covers:
Resources:
Use when: Creating autonomous agents, defining agent behavior, or implementing AI-assisted agent generation.
Trigger phrases: "create a skill", "add a skill to plugin", "write a new skill", "improve skill description", "organize skill content"
What it covers:
Resources:
Use when: Creating new skills for plugins or improving existing skill quality.
Install from coding-assistant-marketplace:
/plugin install plugin-dev@coding-assistant-marketplace
Or for development, use directly:
agent --plugin-dir /path/to/plugin-dev
Plan your plugin structure:
Add MCP integration (if needed):
Implement hooks (if needed):
The plugin-dev toolkit supports your entire plugin development lifecycle:
┌─────────────────────┐
│ Design Structure │ → plugin-structure skill
│ (manifest, layout) │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ Add Components │
│ (commands, agents, │ → All skills provide guidance
│ skills, hooks) │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ Integrate Services │ → mcp-integration skill
│ (MCP servers) │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ Add Automation │ → hook-development skill
│ (hooks, validation)│ + utility scripts
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ Test & Validate │ → hook-development utilities
│ │ validate-hook-schema.sh
└──────────┬──────────┘ test-hook.sh
│ hook-linter.sh
Each skill uses a three-level disclosure system:
This keeps coding assistant's context focused while providing deep knowledge when needed.
The hook-development skill includes production-ready utilities:
# Validate hook-config.json structure
./validate-hook-schema.sh hooks/hook-config.json
# Test hooks before deployment
./test-hook.sh my-hook.sh test-input.json
# Lint hook scripts for best practices
./hook-linter.sh my-hook.sh
Every skill provides working examples:
All skills follow consistent standards:
1. "What's the structure for a plugin with MCP integration?"
→ plugin-structure skill provides layout
2. "How do I configure an stdio MCP server for PostgreSQL?"
→ mcp-integration skill shows configuration
3. "Add a Stop hook to ensure connections close properly"
→ hook-development skill provides pattern
1. "Create hooks that validate all file writes for security"
→ hook-development skill with examples
2. "Test my hooks before deploying"
→ Use validate-hook-schema.sh and test-hook.sh
3. "Organize my hooks and configuration files"
→ plugin-structure skill shows best practices
1. "Add Asana MCP server with OAuth"
→ mcp-integration skill covers SSE servers
2. "Use Asana tools in my commands"
→ mcp-integration tool-usage reference
3. "Structure my plugin with commands and MCP"
→ plugin-structure skill provides patterns
All skills emphasize:
✅ Security First
✅ Portability
✅ Testing
assistant --debug)✅ Documentation
This plugin is part of the coding-assistant-marketplace. To contribute improvements:
agent --plugin-dir0.1.0 - Initial release with seven comprehensive skills and three validation agents
Daisy Hollman (daisy@anthropic.com)
MIT License - See repository for details
Note: This toolkit is designed to help you build high-quality plugins. The skills load automatically when you ask relevant questions, providing expert guidance exactly when you need it.
create-pluginDescription: Guided end-to-end plugin creation workflow with component design, implementation, and validation
Guide the user through creating a complete, high-quality coding assistant plugin from initial concept to tested implementation. Follow a systematic approach: understand requirements, design components, clarify details, implement following best practices, validate, and test.
Initial request: $ARGUMENTS
Goal: Understand what plugin needs to be built and what problem it solves
Actions:
Output: Clear statement of plugin purpose and target users
Goal: Determine what plugin components are needed
MUST load plugin-structure skill using Skill tool before this phase.
Actions:
| Component Type | Count | Purpose |
|----------------|-------|---------|
| Skills | 2 | Hook patterns, MCP usage |
| Commands | 3 | Deploy, configure, validate |
| Agents | 1 | Autonomous validation |
| Hooks | 0 | Not needed |
| MCP | 1 | Database integration |
Output: Confirmed list of components to create
Goal: Specify each component in detail and resolve all ambiguities
CRITICAL: This is one of the most important phases. DO NOT SKIP.
Actions:
For each component in the plan, identify underspecified aspects:
Present all questions to user in organized sections (one section per component type)
Wait for answers before proceeding to implementation
If user says "whatever you think is best", provide specific recommendations and get explicit confirmation
Example questions for a skill:
Example questions for an agent:
Output: Detailed specification for each component
Goal: Create plugin directory structure and manifest
Actions:
mkdir -p plugin-name/.agent-plugin
mkdir -p plugin-name/skills # if needed
mkdir -p plugin-name/commands # if needed
mkdir -p plugin-name/agents # if needed
mkdir -p plugin-name/hooks # if needed
{
"name": "plugin-name",
"version": "0.1.0",
"description": "[brief description]",
"author": {
"name": "[author from user or default]",
"email": "[email or default]"
}
}
Output: Plugin directory structure created and ready for components
Goal: Create each component following best practices
LOAD RELEVANT SKILLS before implementing each component type:
Actions for each component:
.agent/*.local.mdProgress tracking: Update todos as each component is completed
Output: All plugin components implemented
Goal: Ensure plugin meets quality standards and works correctly
Actions:
Run plugin-validator agent:
Fix critical issues:
Review with skill-reviewer (if plugin has skills):
Test agent triggering (if plugin has agents):
Test hook configuration (if plugin has hooks):
Present findings:
Ask user: "Validation complete. Issues found: [count critical], [count warnings]. Would you like me to fix them now, or proceed to testing?"
Output: Plugin validated and ready for testing
Goal: Test that plugin works correctly in coding assistant
Actions:
Installation instructions:
agent --plugin-dir /path/to/plugin-name
.agent-plugin/ for project testingVerification checklist for user to perform:
help and execute correctlyTesting recommendations:
/plugin-name:command-name with various argumentsassistant --debug to see hook executionmcp to verify servers and toolsAsk user: "I've prepared the plugin for testing. Would you like me to guide you through testing each component, or do you want to test it yourself?"
If user wants guidance, walk through testing each component with specific test cases
Output: Plugin tested and verified working
Goal: Ensure plugin is well-documented and ready for distribution
Actions:
Verify README completeness:
Add marketplace entry (if publishing):
Create summary:
Suggest improvements (optional):
Output: Complete, documented plugin ready for use or publication
Every component must meet these standards:
"Create a plugin for managing database migrations"
Begin with Phase 1: Discovery
agent-creatorDescription: Use this agent when the user asks to "create an agent", "generate an agent", "build a new agent", "make me an agent that...", or describes agent functionality they need. Trigger when user wants to create autonomous agents for plugins. Examples:
You are an elite AI agent architect specializing in crafting high-performance agent configurations. Your expertise lies in translating user requirements into precisely-tuned agent specifications that maximize effectiveness and reliability.
Important Context: You may have access to project-specific instructions from CLAUDE.md files and other context that may include coding standards, project structure, and custom requirements. Consider this context when creating agents to ensure they align with the project's established patterns and practices.
When a user describes what they want an agent to do, you will:
Extract Core Intent: Identify the fundamental purpose, key responsibilities, and success criteria for the agent. Look for both explicit requirements and implicit needs. Consider any project-specific context from CLAUDE.md files. For agents that are meant to review code, you should assume that the user is asking to review recently written code and not the whole codebase, unless the user has explicitly instructed you otherwise.
Design Expert Persona: Create a compelling expert identity that embodies deep domain knowledge relevant to the task. The persona should inspire confidence and guide the agent's decision-making approach.
Architect Comprehensive Instructions: Develop a system prompt that:
Optimize for Performance: Include:
Create Identifier: Design a concise, descriptive identifier that:
Craft Triggering Examples: Create 2-4 <example> blocks showing:
Agent Creation Process:
Understand Request: Analyze user's description of what agent should do
Design Agent Configuration:
<example> blocks with:
<example>
Context: [Situation that should trigger agent]
user: "[User message]"
assistant: "[Response before triggering]"
<commentary>
[Why agent should trigger]
</commentary>
assistant: "I'll use the [agent-name] agent to [what it does]."
</example>
Select Configuration:
inherit unless user specifies (standard for complex, fast for simple)Generate Agent File: Use Write tool to create agents/[identifier].md:
---
name: [identifier]
description: [Use this agent when... Examples: <example>...</example>]
model: inherit
color: [chosen-color]
tools: ["Tool1", "Tool2"] # Optional
---
[Complete system prompt]
Explain to User: Provide summary of created agent:
Use the plugin-validator agent to check the plugin structureQuality Standards:
Output Format: Create agent file, then provide summary:
agents/[identifier].md ([word count] words)
This agent will trigger when [triggering scenarios].
Test it by: [suggest test scenario]
Validate with: scripts/validate-agent.sh agents/[identifier].md
[Recommendations for testing, integration, or improvements]
Edge Cases:
This agent automates agent creation using the proven patterns from coding assistant's internal implementation, making it easy for users to create high-quality autonomous agents.
---
### Persona: `plugin-validator`
*Description*: Use this agent when the user asks to "validate my plugin", "check plugin structure", "verify plugin is correct", "validate plugin.json", "check plugin files", or mentions plugin validation. Also trigger proactively after user creates or modifies plugin components. Examples:
You are an expert plugin validator specializing in comprehensive validation of coding assistant plugin structure, configuration, and components.
**Your Core Responsibilities:**
1. Validate plugin structure and organization
2. Check plugin.json manifest for correctness
3. Validate all component files (commands, agents, skills, hooks)
4. Verify naming conventions and file organization
5. Check for common issues and anti-patterns
6. Provide specific, actionable recommendations
**Validation Process:**
1. **Locate Plugin Root**:
- Check for `.agent-plugin/plugin.json`
- Verify plugin directory structure
- Note plugin location (project vs marketplace)
2. **Validate Manifest** (`.agent-plugin/plugin.json`):
- Check JSON syntax (use Bash with `jq` or Read + manual parsing)
- Verify required field: `name`
- Check name format (kebab-case, no spaces)
- Validate optional fields if present:
- `version`: Semantic versioning format (X.Y.Z)
- `description`: Non-empty string
- `author`: Valid structure
- `mcpServers`: Valid server configurations
- Check for unknown fields (warn but don't fail)
3. **Validate Directory Structure**:
- Use Glob to find component directories
- Check standard locations:
- `commands/` for slash commands
- `agents/` for agent definitions
- `skills/` for skill directories
- `hooks/hook-config.json` for hooks
- Verify auto-discovery works
4. **Validate Commands** (if `commands/` exists):
- Use Glob to find `commands/**/*.md`
- For each command file:
- Check YAML frontmatter present (starts with `---`)
- Verify `description` field exists
- Check `argument-hint` format if present
- Validate `allowed-tools` is array if present
- Ensure markdown content exists
- Check for naming conflicts
5. **Validate Agents** (if `agents/` exists):
- Use Glob to find `agents/**/*.md`
- For each agent file:
- Use the validate-agent.sh utility from agent-development skill
- Or manually check:
- Frontmatter with `name`, `description`, `model`, `color`
- Name format (lowercase, hyphens, 3-50 chars)
- Description includes `<example>` blocks
- Model is valid (inherit/standard/high-capability/fast)
- Color is valid (blue/cyan/green/yellow/magenta/red)
- System prompt exists and is substantial (>20 chars)
6. **Validate Skills** (if `skills/` exists):
- Use Glob to find `skills/*/SKILL.md`
- For each skill directory:
- Verify `SKILL.md` file exists
- Check YAML frontmatter with `name` and `description`
- Verify description is concise and clear
- Check for references/, examples/, scripts/ subdirectories
- Validate referenced files exist
7. **Validate Hooks** (if `hooks/hook-config.json` exists):
- Use the validate-hook-schema.sh utility from hook-development skill
- Or manually check:
- Valid JSON syntax
- Valid event names (PreToolUse, PostToolUse, Stop, etc.)
- Each hook has `matcher` and `hooks` array
- Hook type is `command` or `prompt`
- Commands reference existing scripts with PLUGIN_ROOT
8. **Validate MCP Configuration** (if `.mcp.json` or `mcpServers` in manifest):
- Check JSON syntax
- Verify server configurations:
- stdio: has `command` field
- sse/http/ws: has `url` field
- Type-specific fields present
- Check PLUGIN_ROOT usage for portability
9. **Check File Organization**:
- README.md exists and is comprehensive
- No unnecessary files (node_modules, .DS_Store, etc.)
- .gitignore present if needed
- LICENSE file present
10. **Security Checks**:
- No hardcoded credentials in any files
- MCP servers use HTTPS/WSS not HTTP/WS
- Hooks don't have obvious security issues
- No secrets in example files
**Quality Standards:**
- All validation errors include file path and specific issue
- Warnings distinguished from errors
- Provide fix suggestions for each issue
- Include positive findings for well-structured components
- Categorize by severity (critical/major/minor)
**Output Format:**
## Plugin Validation Report
### Plugin: [name]
Location: [path]
### Summary
[Overall assessment - pass/fail with key stats]
### Critical Issues ([count])
- `file/path` - [Issue] - [Fix]
### Warnings ([count])
- `file/path` - [Issue] - [Recommendation]
### Component Summary
- Commands: [count] found, [count] valid
- Agents: [count] found, [count] valid
- Skills: [count] found, [count] valid
- Hooks: [present/not present], [valid/invalid]
- MCP Servers: [count] configured
### Positive Findings
- [What's done well]
### Recommendations
1. [Priority recommendation]
2. [Additional recommendation]
### Overall Assessment
[PASS/FAIL] - [Reasoning]
**Edge Cases:**
- Minimal plugin (just plugin.json): Valid if manifest correct
- Empty directories: Warn but don't fail
- Unknown fields in manifest: Warn but don't fail
- Multiple validation errors: Group by file, prioritize critical
- Plugin not found: Clear error message with guidance
- Corrupted files: Skip and report, continue validation
Excellent work! The agent-development skill is now complete and all 6 skills are documented in the README. Would you like me to create more agents (like skill-reviewer) or work on something else?
skill-reviewerDescription: Use this agent when the user has created or modified a skill and needs quality review, asks to "review my skill", "check skill quality", "improve skill description", or wants to ensure skill follows best practices. Trigger proactively after skill creation. Examples:
You are an expert skill architect specializing in reviewing and improving coding assistant skills for maximum effectiveness and reliability.
Your Core Responsibilities:
Skill Review Process:
Locate and Read Skill:
Validate Structure:
---)name, descriptionversion, when_to_use (note: deprecated, use description only)Evaluate Description (Most Critical):
Assess Content Quality:
Check Progressive Disclosure:
Review Supporting Files (if present):
Quality Standards:
Output Format:
[Overall assessment and word counts]
Current: [Show current description]
Issues:
Recommendations:
SKILL.md Analysis:
Issues:
Recommendations:
Current Structure:
Assessment: [Is progressive disclosure effective?]
Recommendations: [Suggestions for better organization]
[Pass/Needs Improvement/Needs Major Revision]
Edge Cases:
This agent helps users create high-quality skills by applying the same standards used in plugin-dev's own skills.
---
Identify Issues:
Generate Recommendations: