Skip to content
Skills Library
AI & agents · Building & coding

plugin-creator

/plugin-creator

This skill should be used when creating, modifying, or managing Claude Code plugins and plugin marketplaces. Trigger when working with plugin manifests (plugin.json, marketplace.json), creating plugin directory structures, adding plugin components (commands, skills, agents, hooks), version bumping, or when discussing plugin development workflows.

Author
lttr ↗
Licence
MIT
Last repository change
22.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
2
HTML comments
0
URLs in SKILL.md
3
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 2 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/bump_version.py, scripts/create_plugin.py

What it does and when to use it

This skill should be used when creating, modifying, or managing Claude Code plugins and plugin marketplaces. Trigger when working with plugin manifests (plugin.json, marketplace.json), creating plugin directory structures, adding plugin components (commands, skills, agents, hooks), version bumping, or when discussing plugin development workflows.

Original author description

This skill should be used when creating, modifying, or managing Claude Code plugins and plugin marketplaces. Trigger when working with plugin manifests (plugin.json, marketplace.json), creating plugin directory structures, adding plugin components (commands, skills, agents, hooks), version bumping, or when discussing plugin development workflows.

How it works

  1. Overview
  2. Prerequisites
  3. When to Use This Skill
  4. Quick Start
  5. Plugin Development Workflow
  6. Plugin Structure Patterns
  7. Command Naming Convention
  8. Version Management
  9. Git Workflow
  10. Resources
Original SKILL.md headings · 247 lines, 677 words
SKILL.md preview
---
name: plugin-creator
description: This skill should be used when creating, modifying, or managing Claude Code plugins and plugin marketplaces. Trigger when working with plugin manifests (plugin.json, marketplace.json), creating plugin directory structures, adding plugin components (commands, skills, agents, hooks), version bumping, or when discussing plugin development workflows.
disable-model-invocation: true
---

# Plugin Creator

Official docs: <https://code.claude.com/docs/en/plugins.md>, <https://code.claude.com/docs/en/plugins-reference.md>, <https://code.claude.com/docs/en/plugin-marketplaces.md>. Fetch when unsure about manifest schema, distribution, or recent features.

## Overview

Create and manage Claude Code plugins with proper structure, manifests, and marketplace integration. This skill provides workflows, automation scripts, and reference documentation for plugin development.

## Prerequisites

- `python3` for the bundled scripts

## When to Use This Skill

Trigger this skill when:

- Creating new plugins for a marketplace
- Adding or modifying plugin components (commands, skills, agents, hooks)
- Updating plugin versions
- Working with plugin or marketplace manifests
- Setting up local plugin testing
- Publishing plugins to marketplaces

## Quick Start

### Creating a New Plugin

Use the `create_plugin.py` script to generate plugin structure:

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/create_plugin.py plugin-name \
  --marketplace-root /path/to/marketplace \
  --author-name "Your Name" \
  --author-email "your.email@example.com" \
  --description "Plugin description" \
  --keywords "keyword1,keyword2" \
  --category "productivity"
```

This automatically:

- Creates plugin directory structure
- Generates `plugin.json` manifest
- Creates README template
- Updates `marketplace.json`

### Bumping Plugin Version

Use `bump_version.py` to update versions in both manifests:

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/bump_version.py plugin-name major|minor|patch \
  --marketplace-root /path/to/marketplace
```

Semantic versioning rules:

- **major**: Breaking changes (1.0.0 → 2.0.0)
- **minor**: New features, refactoring (1.0.0 → 1.1.0)
- **patch**: Bug fixes, docs only (1.0.0 → 1.0.1)

## Plugin Development Workflow

### 1. Create Plugin Structure

Manual approach if not using `create_plugin.py`:

```bash
mkdir -p plugins/plugin-name/.claude-plugin
mkdir -p plugins/plugin-name/commands
mkdir -p plugins/plugin-name/skills
```

### 2. Create Plugin Manifest

File: `plugins/plugin-name/.claude-plugin/plugin.json`

```json
{
  "name": "plugin-name",
  "version": "0.1.0",
  "description": "Plugin description",
  "author": {
    "name": "Your Name",
    "email": "your.email@example.com"
  },
  "keywords": ["keyword1", "keyword2"]
}
```

### 3. Register in Marketplace

Update `.claude-plugin/marketplace.json` by adding to `plugins` array:

```json
{
  "name": "plugin-name",
  "source": "./plugins/plugin-name",
  "description": "Plugin description",
  "version": "0.1.0",
  "keywords": ["keyword1", "keyword2"],
  "category": "productivity"
}
```

### 4. Add Plugin Components

Create components in their respective directories:

**Commands:** `commands/` - Markdown files with frontmatter
**Skills:** `skills/` - Subdirectories containing `SKILL.md`
**Agents:** `agents/` - Markdown agent definitions
**Hooks:** `hooks/hooks.json` - Event handler configurations
**MCP Servers:** `.mcp.json` - External tool integrations

### 5. Local Testing

```bash
# Add marketplace
/plugin marketplace add /path/to/marketplace-root

# Install plugin
/plugin install plugin-name@marketplace-name

# After changes: uninstall, reinstall, restart Claude Code
/plugin uninstall plugin-name@marketplace-name
/plugin install plugin-name@marketplace-name
```

## Plugin Structure Patterns

### Framework Plugin

For framework-specific guidance (React, Vue, Nuxt):

```
plugins/framework-name/
├── .claude-plugin/plugin.json
├── skills/
│   └── framework-name/
│       ├── SKILL.md              # Quick reference
│       └── references/           # Library patterns
├── commands/
│   └── prime/
│       ├── components.md
│       └── framework.md
└── README.md
```

### Utility Plugin

For tools and commands:

```
plugins/utility-name/
├── .claude-plugin/plugin.json
├── commands/
│   ├── action1.md
│   └── action2.md
└── README.md
```

### Domain Plugin

For domain-specific knowledge:

```
plugins/domain-name/
├── .claude-plugin/plugin.json
├── skills/
│   └── domain-name/
│       ├── SKILL.md
│       ├── references/
│       │   ├── schema.md
│       │   └── policies.md
│       └── scripts/
│           └── automation.py
└── README.md
```

## Command Naming Convention

Commands use subdirectory-based namespacing with `:` separator:

- File: `commands/namespace/command.md` → `/namespace:command`
- File: `commands/simple.md` → `/simple`

Examples:

- `commands/prime/vue.md` → `/prime:vue`
- `commands/docs/generate.md` → `/docs:generate`

## Version Management

**Critical:** Always update version in BOTH locations:

1. `plugins/<name>/.claude-plugin/plugin.json`
2. `.claude-plugin/marketplace.json` (matching entry)

Use `bump_version.py` to automate this.

## Git Workflow

Use conventional commits:

```bash
git commit -m "feat: add new plugin"
git commit -m "fix: correct plugin manifest"
git commit -m "docs: update plugin README"
git commit -m "feat!: breaking change to plugin API"
```

## Resources

This skill includes detailed reference documentation:

### references/plugin-structure.md

Complete plugin directory structure, manifest schema, component types, and path requirements.

### references/marketplace-schema.md

Marketplace manifest format, plugin entry schema, source specifications, and team distribution setup.

### references/workflows.md

Step-by-step workflows for creating plugins, version bumping, local testing, publishing, and common plugin patterns.

### scripts/create_plugin.py

Automates plugin creation with proper structure and manifest generation.

### scripts/bump_version.py

Updates version in both plugin.json and marketplace.json simultaneously.

## Key References

When Claude needs detailed information about specific aspects:

- **Plugin structure details**: Read `references/plugin-structure.md`
- **Marketplace schema**: Read `references/marketplace-schema.md`
- **Development workflows**: Read `references/workflows.md`

These references provide comprehensive information without cluttering the main skill context.
Files in this package (6)
  • SKILL.md 7 KB
  • references/marketplace-schema.md 2 KB
  • references/plugin-structure.md 3 KB
  • references/workflows.md 4 KB
  • scripts/bump_version.py 3 KB
  • scripts/create_plugin.py 5 KB

Versions

RepositoryScoreLicence
This page · lttr/claude-marketplace100MIT
jeremylongshore/tons-of-skills-marketplace100MIT
openjiuwen-ai/jiuwenswarm100Apache-2.0
fengchen122123-sudo/xingyao-y-code100MIT
krzysztofsurdy/code-virtuoso100MIT
HaizhuAI/Zkali100Apache-2.0
liyunxuanyu/dsh-zcode-port100MIT
jscraik/Agent-Skills100Apache-2.0
fx/cc100MIT

Database snapshot: 13.11.2026 · package version 4b69f291ad15 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100plugin-forge
    Create and manage Claude Code plugins with proper structure, manifests, and marketplace integration. Use when creating plugins for a marketplace, adding plugin components (commands, agents, hooks), bumping plugin versions, or working with plugin.json/marketplace.json manifests.
  • 100plugin-forge
    Create and manage Claude Code plugins with proper structure, manifests, and marketplace integration. Use when creating plugins for a marketplace, adding plugin components (commands, agents, hooks), bumping plugin versions, or working with plugin.json/marketplace.json manifests.
  • 100claude-plugins
    Reference for building and distributing Claude Code plugins — plugin.json and marketplace.json structure, bundling commands, agents, skills and hooks, versioning, and publishing a marketplace. Use when creating or packaging a plugin, setting up a marketplace, or debugging why a…
  • 95plugin-dev
    Use this skill when creating or refining Claude Code plugins. Plugins are bundled collections of agents, skills, commands, hooks, and MCP servers that provide cohesive functionality. Helps design proper directory structures, plugin.json configuration, marketplace distribution,…
  • 100plugin-authoring
    Use when creating, modifying, or debugging Claude Code plugins. Triggers on .claude-plugin/, plugin.json, marketplace.json, commands/, agents/, skills/, hooks/ directories. Provides schemas, templates, validation workflows, and troubleshooting.
  • 100plugin-authoring
    Use when creating, modifying, or debugging Claude Code plugins. Triggers on .claude-plugin/, plugin.json, marketplace.json, commands/, agents/, skills/, hooks/ directories. Provides schemas, templates, validation workflows, and troubleshooting.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.