# Configuration Sharing

<SlideStart />

## What is a plugin?

A plugin is a packaged collection of Claude Code configuration. It bundles skills, agents, custom slash commands, hooks, and optionally MCP server definitions into a single installable unit.

Structurally, a plugin is a git repository with a `.claude/` directory at its root. That directory follows the same layout Claude Code already uses for project-level configuration, so there is nothing new to learn about the format itself — the novelty is that the whole thing travels together as a unit that anyone can install with one command.

This distinction matters. You have already seen how individual commands or skills improve a specific task. A plugin takes that further: it captures an entire workflow. A data science team might ship one plugin that includes a code-review skill tuned for ML code, an agent that orchestrates test runs, and a `/summarize-notebook` command — all versioned together and installable in seconds.

<DiagramViewer title="What a plugin bundles">
```d2
plugin: Plugin repo {
  commands: commands/
  skills: skills/
  agents: agents/
  settings: settings.json
}
```
</DiagramViewer>

<SlideEnd />

<SlideStart />

## How to create a plugin

A plugin is a git repository with this directory structure:

```
my-plugin/
├── .claude/
│   ├── commands/       # slash commands
│   ├── skills/         # skill files
│   ├── agents/         # agent definitions
│   └── settings.json   # hooks and MCP server configs
└── README.md
```

Nothing about this structure is special to plugins — it is the same `.claude/` layout used in any project. The difference is intent: a plugin repo exists solely to be shared and installed, not to hold application code.

Here is a concrete example. Say your team builds a `ds-workflow` plugin:

```
ds-workflow/
├── .claude/
│   ├── commands/
│   │   └── summarize-notebook.md    # [1]
│   ├── skills/
│   │   └── code-review.md           # [2]
│   ├── agents/
│   │   └── test-runner.md           # [3]
│   └── settings.json
└── README.md
```

- **[1]** `/summarize-notebook` — a command that takes a notebook path and produces a plain-English summary of what it does, suitable for pull request descriptions
- **[2]** `code-review` skill — instructs Claude on ML-specific review criteria: data leakage, pipeline correctness, random seed consistency
- **[3]** `test-runner` agent — an agent definition that locates test files, runs them, and reports failures with suggested fixes

Each file is written the same way you would write a standalone command or skill. The plugin just groups them under a single repo so they can be versioned, reviewed, and installed together.

To publish the plugin, push the repository to GitHub. That is sufficient — no build step, no packaging format, no registry submission required.

<SlideEnd />

<SlideStart />

## How plugins work — marketplace

Claude Code installs plugins from git URLs. When you run an install command, Claude Code clones the plugin repository and merges its `.claude/` contents into your project or global configuration. The plugin's commands show up in `/help`, its skills become available to the model, and its agent definitions are active immediately.

The community shares plugins on GitHub. Common conventions include the `claude-code-plugin` topic tag on repositories and curated lists maintained in the Claude Code documentation. A more formal marketplace at claude.ai/marketplace is also evolving — check the official Claude Code docs for the current state, since this ecosystem is still developing quickly.

Plugins are activated per project or globally, depending on where you install them. A plugin installed globally is available in every session; one installed into a specific project is scoped to that project's `.claude/` directory.

<DiagramViewer title="Plugin installation and activation flow">
```d2
direction: down

git: "GitHub / git URL"
local: "Local .claude/ directory"
cm: commands/
sm: skills/
am: agents/
im: settings.json
active: Active in session

git -> local: plugin install
local -> cm
local -> sm
local -> am
local -> im
cm -> active
sm -> active
am -> active
im -> active
```
</DiagramViewer>

<SlideEnd />

<SlideStart />

## How to install a plugin

Installation takes one command:

```bash
# Install a plugin from a git URL
> claude plugin install https://github.com/example/ds-workflow-plugin   # [1]
```

- **[1]** Claude Code clones the repository, reads its `.claude/` directory, and merges the contents into your configuration. After this completes, the plugin's commands and agents are immediately available.

Once installed, you can confirm the plugin's commands are active:

```bash
> claude
/help    # [2]
```

- **[2]** The `/help` output now lists the plugin's slash commands alongside your own. No restart required.

If you prefer to install manually — or if your organization has a private plugin repo that requires SSH access — you can also add the plugin directly to your Claude Code settings file and point it at the local path after cloning.

<Callout type="tip">
  The most effective team setup is a shared internal plugin in your organization's private git repo. One install command and everyone gets the same workflow — same commands, same skills, same agent behaviors. When a command improves, you update the plugin repo, teammates pull, and the change is live for everyone.
</Callout>

<SlideEnd />