Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
ruvnet avatar

Create Plugin

  • 648 installs
  • 67k repo stars
  • Updated August 4, 2026
  • ruvnet/ruflo

create-plugin is an agent skill that scaffolds Claude Code plugins with plugin.json, skills, commands, and agents for developers extending agent tooling with MCP integrations.

About

create-plugin is a ruvnet/ruflo skill that scaffolds new Claude Code plugins from scratch with the correct directory structure, plugin.json manifest, skills, commands, and agents. The workflow collects a plugin name argument-hint, checks conflicts via mcp__claude-flow__transfer_plugin-search and transfer_store-search MCP tools, then writes files using Bash, Read, Write, and Edit permissions. Developers reach for create-plugin when packaging reusable agent capabilities—custom skills, slash commands, subagents, and MCP hooks—for teams or marketplace distribution instead of one-off project prompts. The skill also calls transfer_plugin-info for metadata alignment. Agents follow numbered steps to validate naming, lay out plugin folders, and wire Claude-flow transfer endpoints so new plugins integrate cleanly with existing Claude Code extension conventions. Numbered steps prompt for plugin name and description, then lay out skills, slash commands, and subagent folders expected by Claude Code marketplace conventions. transfer_plugin-info aligns manifest metadata while Bash and Edit permissions write plugin.json and starter command files to disk in one guided pass.

  • create-plugin

Create Plugin by the numbers

  • 648 all-time installs (skills.sh)
  • +10 installs in the week ending Jul 26, 2026 (Skillselion tracking)
  • Ranked #562 of 4,347 Backend & APIs skills by installs in the Skillselion catalog
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/ruvnet/ruflo --skill create-plugin

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs648
repo stars67k
Last updatedAugust 4, 2026
Repositoryruvnet/ruflo

How do you scaffold a Claude Code plugin?

Use create-plugin for development tasks

Who is it for?

Developers packaging reusable Claude Code extensions with skills, commands, agents, and Claude-flow MCP integration.

Skip if: Developers building standalone npm CLI tools without Claude Code plugin.json structure or agent extension conventions.

When should I use this skill?

User asks to create a Claude Code plugin, scaffold plugin.json, or add skills and commands to a new extension.

What you get

Plugin directory tree, plugin.json manifest, starter skills, commands, agents, and MCP wiring stubs.

  • plugin.json manifest
  • Plugin directory scaffold
  • Starter skills and commands

By the numbers

  • Scaffolds plugin.json plus skills, commands, and agents in one workflow
  • Uses 3 Claude-flow transfer MCP tools for info and conflict search

Files

SKILL.mdMarkdownGitHub ↗

Create Plugin

Scaffold a new Claude Code plugin from scratch.

When to use

When you want to create a new plugin that extends Claude Code with skills, commands, and agents. This generates the correct directory structure and wires up MCP tools.

Steps

1. Get plugin name and description from the user 2. Check for conflicts — call mcp__claude-flow__transfer_plugin-search to ensure the name isn't taken 3. Create directory structure (follows the canonical plugin contract from sibling plugins' ADR-0001s):

   plugins/<name>/
   ├── .claude-plugin/
   │   └── plugin.json
   ├── skills/
   │   └── <skill-name>/
   │       └── SKILL.md
   ├── commands/
   │   └── <command-name>.md
   ├── agents/
   │   └── <agent-name>.md
   ├── docs/
   │   └── adrs/
   │       └── 0001-<name>-contract.md     # Plugin-level ADR (Proposed)
   ├── scripts/
   │   └── smoke.sh                         # Structural contract (≥8 checks)
   └── README.md                            # Compatibility + Namespace coordination + Verification + ADR sections

4. Generate plugin.json with name, description, version, author (do NOT include skills, commands, or agents arrays — Claude Code auto-discovers these from directory structure) 5. Generate SKILL.md files with proper frontmatter:

   ---
   name: skill-name
   description: What this skill does
   allowed-tools: mcp__claude-flow__tool1 mcp__claude-flow__tool2 Bash
   ---

6. Generate command files with name and description frontmatter 7. Generate agent files with name, description, and model: sonnet 8. Generate README.md with install instructions, features, commands, skills, AND the canonical plugin-contract sections:

  • Compatibility — pin to @claude-flow/cli v3.6 major+minor
  • Namespace coordination — claim a kebab-case <plugin-stem>-<intent> namespace; defer to ruflo-agentdb ADR-0001 §"Namespace convention"
  • Verificationbash plugins/<name>/scripts/smoke.sh
  • Architecture Decisions — link to ADR-0001

9. Generate ADR-0001 (Proposed) at docs/adrs/0001-<name>-contract.md documenting: pinning, namespace coordination, MCP-tool surface count if applicable, smoke contract scope. Status: Proposed. 10. Generate scripts/smoke.sh — at minimum 8 structural checks: version + keywords; skills/agents/commands present with valid frontmatter; v3.6 pin in README; namespace coordination block in README; ADR exists with status Proposed; no wildcard tools in skills. 11. Update marketplace.json if adding to the ruflo marketplace.

MCP-tool drift to avoid (per sibling-ADR lessons learned)

Several plugins shipped with subtle MCP bugs the loop has been finding. Don't replicate them:

  • `embeddings_embed` does not exist. Real tool is embeddings_generate. Don't reference embeddings_embed in any allowed-tools line.
  • *`agentdb_hierarchical- does NOT route by namespace.** It routes by tier (working|episodic|semantic). Pass tier, not namespace. For namespaced reads/writes, use memory_*` instead.
  • *`agentdb_pattern- does NOT route by namespace.** It routes through ReasoningBank. Don't pass a namespace arg — fallback writes to the reserved pattern namespace via memory-store-fallback`.
  • `pattern` (singular) and `patterns` (plural) are different namespaces. ReasoningBank fallback writes to pattern; hooks_pretrain writes to patterns. Don't conflate them.

Plugin.json schema

Required fields:

  • name — plugin identifier (kebab-case)
  • description — what the plugin does
  • version — semver

Recommended fields:

  • author{ "name": "...", "url": "..." }
  • homepage, license, keywords

Optional fields:

  • graph_adapter — ADR-130 graph intelligence contract (commented out by default in generated output):
  // "graph_adapter": {
  //   "edgeRelations": ["my-relation-type"],
  //   "nodeTypes": ["entity"],
  //   "autoRegister": true
  // }

When autoRegister: true, the plugin's edges are automatically included in graph_edges writes by the core graph layer. Declare edgeRelations — the relation types this plugin produces.

Do NOT include skills, commands, or agents arrays in plugin.json — these are auto-discovered from the directory structure by Claude Code and will cause validation errors if present.

Available MCP tools to wire

Browse available tools: mcp__claude-flow__transfer_plugin-info

Common tool categories:

  • memory_* — storage, search, retrieval
  • agentdb_* — 15 controller-bridge tools (do NOT pass namespace arg — they route by tier or ReasoningBank); call agentdb_controllers at runtime for the canonical list
  • neural_* — neural training and prediction
  • hooks_* — lifecycle hooks and intelligence
  • browser_* — browser automation
  • workflow_* — workflow management
  • aidefence_* — safety scanning
  • embeddings_* — 10 vector-embedding tools (use embeddings_generate, NOT embeddings_embed which does not exist)

Related skills

How it compares

Pick create-plugin for opinionated Claude Code plugin scaffolding instead of manual folder creation without transfer MCP conflict checks.

FAQ

What does create-plugin generate?

create-plugin generates a Claude Code plugin directory with plugin.json, skills, commands, and agents. The skill scaffolds MCP wiring and follows Claude-flow transfer tooling for metadata and conflict checks.

How does create-plugin avoid naming conflicts?

create-plugin calls mcp__claude-flow__transfer_plugin-search and transfer_store-search before writing files. Agents verify the plugin name is unused across plugin and store registries.

Which tools can create-plugin use?

create-plugin allows mcp__claude-flow__transfer_plugin-info, transfer_plugin-search, transfer_store-search, plus Bash, Read, Write, and Edit for scaffolding files on disk.

Backend & APIsbackendintegrations

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.