plugin-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.
Best use case
plugin-forge is best used when you need a repeatable AI agent workflow instead of a one-off prompt. It is especially useful for teams working in multi. 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.
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.
Users should expect a more consistent workflow output, faster repeated execution, and less time spent rewriting prompts from scratch.
Practical example
Example input
Use the "plugin-forge" skill to help with this workflow task. Context: 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.
Example output
A structured workflow result with clearer steps, more consistent formatting, and an output that is easier to reuse in the next run.
When to use this skill
- Use this skill when you want a reusable workflow rather than writing the same prompt again and again.
When not to use this skill
- Do not use this when you only need a one-off answer and do not need a reusable workflow.
- Do not use it if you cannot install or maintain the related files, repository context, or supporting tools.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/plugin-forge/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How plugin-forge Compares
| Feature / Agent | plugin-forge | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
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.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
SKILL.md Source
# CC Plugin Forge
## Purpose
Build and manage Claude Code plugins with correct structure, manifests, and marketplace integration. Includes workflows, automation scripts, and reference docs.
## When to Use
- Creating new plugins for a marketplace
- Adding/modifying plugin components (commands, skills, agents, hooks)
- Updating plugin versions
- Working with plugin or marketplace manifests
- Setting up local plugin testing
- Publishing plugins
## Getting Started
### Create New Plugin
Use `create_plugin.py` to generate plugin structure:
```bash
python 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`
### Bump Version
Use `bump_version.py` to update versions in both manifests:
```bash
python scripts/bump_version.py plugin-name major|minor|patch \
--marketplace-root /path/to/marketplace
```
Semantic versioning:
- **major**: Breaking changes (1.0.0 → 2.0.0)
- **minor**: New features, refactoring (1.0.0 → 1.1.0)
- **patch**: Bug fixes, docs (1.0.0 → 1.0.1)
## Development Workflow
### 1. Create Structure
Manual approach (if not using script):
```bash
mkdir -p plugins/plugin-name/.claude-plugin
mkdir -p plugins/plugin-name/commands
mkdir -p plugins/plugin-name/skills
```
### 2. 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`:
```json
{
"name": "plugin-name",
"source": "./plugins/plugin-name",
"description": "Plugin description",
"version": "0.1.0",
"keywords": ["keyword1", "keyword2"],
"category": "productivity"
}
```
### 4. Add Components
Create in respective directories:
| Component | Location | Format |
|-----------|----------|--------|
| Commands | `commands/` | Markdown with frontmatter |
| Skills | `skills/<name>/` | Directory with `SKILL.md` |
| Agents | `agents/` | Markdown definitions |
| Hooks | `hooks/hooks.json` | Event handlers |
| MCP Servers | `.mcp.json` | External integrations |
### 5. Local Testing
```bash
# Add marketplace
/plugin marketplace add /path/to/marketplace-root
# Install plugin
/plugin install plugin-name@marketplace-name
# After changes: reinstall
/plugin uninstall plugin-name@marketplace-name
/plugin install plugin-name@marketplace-name
```
## Plugin Patterns
### Framework Plugin
For framework-specific guidance (React, Vue, etc.):
```
plugins/framework-name/
├── .claude-plugin/plugin.json
├── skills/
│ └── framework-name/
│ ├── SKILL.md
│ └── references/
├── 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/
│ └── scripts/
└── README.md
```
## Command Naming
Subdirectory-based namespacing with `:` separator:
- `commands/namespace/command.md` → `/namespace:command`
- `commands/simple.md` → `/simple`
Examples:
- `commands/prime/vue.md` → `/prime:vue`
- `commands/docs/generate.md` → `/docs:generate`
## Version Management
**Important:** Update version in BOTH locations:
1. `plugins/<name>/.claude-plugin/plugin.json`
2. `.claude-plugin/marketplace.json`
Use `bump_version.py` to automate.
## Git Commits
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"
```
## Reference Docs
Detailed documentation included:
| Reference | Content |
|-----------|---------|
| `references/plugin-structure.md` | Directory structure, manifest schema, components |
| `references/marketplace-schema.md` | Marketplace format, plugin entries, distribution |
| `references/workflows.md` | Step-by-step workflows, patterns, publishing |
### Scripts
| Script | Purpose |
|--------|---------|
| `scripts/create_plugin.py` | Scaffold new plugin |
| `scripts/bump_version.py` | Update versions |Related Skills
wordpress-plugin-development
WordPress plugin development workflow covering plugin architecture, hooks, admin interfaces, REST API, and security best practices.
skill-forge
Advanced skill creation system for Claude Code that combines deep intent analysis, evidence-based prompting principles, and systematic skill engineering. Use when creating new skills or refining existing skills to ensure they are well-structured, follow best practices, and incorporate sophisticated prompt engineering techniques. This skill transforms skill creation from template filling into a strategic design process.
agentdb-learning-plugins
Create and train AI learning plugins with AgentDB's 9 reinforcement learning algorithms. Includes Decision Transformer, Q-Learning, SARSA, Actor-Critic, and more. Use when building self-learning agents, implementing RL, or optimizing agent behavior through experience.
claude-plugin
**Use MCP repo-map tools when:** - Searching for symbols by name pattern (faster than Grep) - Getting all symbols in a file (faster than Read + parsing)
building-plugins
Expert at creating and managing Claude Code plugins that bundle agents, skills, commands, and hooks into cohesive packages. Auto-invokes when the user wants to create, structure, validate, or publish a complete plugin, or needs help with plugin architecture and best practices. Also auto-invokes proactively when Claude is about to create plugin directory structures, write plugin.json manifests, or implement tasks that involve bundling components into a plugin package.
building-logseq-plugins
Expert guidance for building Logseq plugins compatible with the new DB architecture. Auto-invokes when users want to create Logseq plugins, work with the Logseq Plugin API, extend Logseq functionality, or need help with plugin development for DB-based graphs. Covers plugin structure, API usage, and DB-specific considerations.
wp-plugin-development
Use when developing WordPress plugins: architecture and hooks, activation/deactivation/uninstall, admin UI and Settings API, data storage, cron/tasks, security (nonces/capabilities/sanitization/escaping), and release packaging.
plugin-settings
This skill should be used when the user asks about "plugin settings", "store plugin configuration", "user-configurable plugin", ".local.md files", "plugin state files", "read YAML frontmatter", "per-project plugin settings", or wants to make plugin behavior configurable. Documents the .claude/plugin-name.local.md pattern for storing plugin-specific configuration with YAML frontmatter and markdown content.
working-on-ancplua-plugins
Primary instruction manual for working within the ancplua-claude-plugins monorepo. Use when creating, modifying, or debugging plugins in this repository.
allaymc-plugin-dev
Build, update, and troubleshoot AllayMC plugins in Java or other JVM languages. Use when creating a new AllayMC plugin, migrating an existing plugin to a new Allay API version, wiring commands/events/tasks/config, or setting up Gradle and plugin metadata (plugin.json or AllayGradle plugin block).
fiftyone-develop-plugin
Develop custom FiftyOne plugins (operators and panels) from scratch. Use when user wants to create a new plugin, extend FiftyOne with custom operators, build interactive panels, or integrate external APIs into FiftyOne. Guides through requirements, design, coding, testing, and iteration.
figjam-plugin
FigJam plugin development workflow. Use when working on plugin code (code.ts, ui.ts), debugging WebSocket communication, or building the plugin.