# The plugin name is an immutable slug, and the repository license does not reach the plugins

> claude-plugins-official is a curated directory of Claude Code plugins split into two folders by who wrote them, with a marketplace entry format that pins a commit inside someone else's repository. Two things in it deserve reading before installing anything: the trust warning states plainly that Anthropic does not control the software inside a plugin, and the root license explicitly stops at the repository boundary.

**anthropics/claude-plugins-official** — Official, Anthropic-managed directory of high quality Claude Code Plugins.

- Repository: https://github.com/anthropics/claude-plugins-official
- Website: https://code.claude.com/docs/en/plugins
- Stars: 37,237 · Forks: 4,180
- Language: Python
- License: Apache-2.0
- Published: 2026-08-17 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/anthropics-claude-plugins-official

## The trust warning says Anthropic does not control what a plugin runs

The most important paragraph in this repository is the warning near the top, and it undercuts the idea of a curated list being a safety guarantee. It tells you to trust a plugin before installing, updating, or using it, and states that Anthropic does not control what MCP servers, files, or other software are included in plugins. It goes further and says it cannot verify that they will work as intended or that they will not change. The instruction is to see each plugin's homepage for more information. So what being listed here cannot do is tell you what will execute on your machine, and the warning is explicit that the maintainers of the directory do not control that answer. The consequence is that the directory is a quality and review signal about whether a plugin met the listing bar, not a promise about its behaviour, and it can change after you install it without the directory being able to stop you.

## The root license stops at the repository and points you to each plugin

The repository carries an Apache-2.0 LICENSE file at its root, and the license section of the README does something that is easy to skim past. It does not restate Apache-2.0 as covering the contents. It says to see each linked plugin for the relevant LICENSE file. So what the root license cannot do is tell you the terms for anything you actually install, because a plugin lives in its own source repository, and an internal plugin developed by an Anthropic team member is not the same legal object as the directory entry describing it. The consequence is that anyone treating the directory as a single licensed bundle is reading the wrong file, and a team with a legal review step for new dependencies has to run that review per plugin rather than once for the marketplace.

## A published name cannot change, and renaming breaks installs with plugin-not-found

The `name` field in a marketplace entry is described as an immutable slug. Once a plugin is published, the name must not change, because users have it installed under that slug, and renaming it breaks their install with a `plugin-not-found` error. The sanctioned way to change how something appears is the `displayName` field, which can be set or updated freely. If a rename is genuinely unavoidable, there is one escape hatch, a top-level `renames` map in `.claude-plugin/marketplace.json`:

```json
"renames": {
  "old-name": "new-name"
}
```

The plugin loader reads that map and rewrites the old slug to the new one on the user's next sync. So what this mechanism cannot do is make a rename instant, since it applies at the next sync rather than at the moment you rename, and a user who never syncs keeps a broken install. The consequence for a plugin author is that the name is a one-way door chosen before publication.

## A skill-bundle entry pins one commit inside somebody else's monorepo

Not every plugin ships its own manifest. When a source repository publishes skills as `SKILL.md` files without a `.claude-plugin/plugin.json`, the marketplace entry can declare them directly by setting `strict: false` and listing the skills explicitly. The entry carries a `source` block with a type of `git-subdir`, a repository URL, a subdirectory path, a ref of `main`, and a `sha` placeholder for a commit. So what this entry type cannot do is follow the upstream branch, because the commit is the anchor, and a plugin pulled this way is a slice of a larger repository rather than a package with its own release history. The `skills` array can also reach deeper than one level, with paths relative to `source.path`, so a curated subset can be exposed across several library subdirectories. Each skill is then registered under a namespaced identifier of the form plugin-name followed by a colon and the skill name.

## Only plugin.json is required, and the optional MCP file is the one that adds outside software

The documented layout makes the required surface small:

```
plugin-name/
├── .claude-plugin/
│   └── plugin.json      # Plugin metadata (required)
├── .mcp.json            # MCP server configuration (optional)
├── commands/            # Slash commands (optional)
├── agents/              # Agent definitions (optional)
├── skills/              # Skill definitions (optional)
└── README.md            # Documentation
```

Everything except the manifest is marked optional, so a valid plugin can be a single JSON file and a README. What this cannot tell you is what a given plugin will do, because a directory that contains only the manifest and one that contains an MCP server configuration look identical in a file listing. That optional `.mcp.json` is the file that declares an external server, which is exactly the category the trust warning names when it says Anthropic does not control what MCP servers are included. The consequence is that reviewing a plugin means opening its files, and the structure tells you where to look rather than what you will find.

## Two directories, two different approval paths

The structure section divides the whole directory in two. The `plugins` folder holds internal plugins developed and maintained by Anthropic, and the `external_plugins` folder holds third-party plugins from partners and the community. The contribution rules differ accordingly. Internal plugins are written by Anthropic team members, and there is a reference implementation to copy from at `plugins/example-plugin`. External plugins arrive through a submission form, and they must meet quality and security standards for approval before they appear. So what the folder name cannot do is tell you who is behind a plugin, since a partner and a community author both land in `external_plugins`. The consequence for a reader is that the path is a weak provenance signal, useful for knowing whether Anthropic wrote the code, and useless for knowing whether you want to run it.

## Installation is a slash command with the marketplace name appended

Plugins are installed through Claude Code's plugin system rather than by fetching a repository. The command form is:

```
/plugin install {plugin-name}@claude-plugins-official
```

The alternative is to browse for the plugin under `/plugin > Discover`. Two details follow from that syntax. The marketplace suffix is part of the identifier, so the same plugin name in a different marketplace is a different install target rather than a conflict, and the name being an immutable slug is what makes that addressing stable. The existence of a Discover path means a plugin can also arrive without anyone typing its exact name, which puts the decision about what to install one layer further from the command line. The repository is not archived and its last push is dated 2026-09-29, so the listing changes frequently, but it publishes no releases at all, so there is no version to pin a directory entry to.

## Conclusion

This directory suits someone who wants a shortlist with a documented structure and a reference implementation to copy, and who will read each plugin's own repository before trusting it. It is not a security boundary and not a licensing grant, since the project says so itself about both. Before installing, open the plugin's homepage and check what it bundles, especially whether it ships an MCP server, and treat the directory listing as a quality signal about the listing rather than about the code. If you are publishing a plugin yourself, read the naming rule first, because a slug you publish cannot be changed later without breaking every install.

## FAQ

### what is claude plugins official

It is an official, Anthropic-managed curated directory of high-quality plugins for Claude Code, split into a `plugins` folder for internal plugins developed and maintained by Anthropic and an `external_plugins` folder for third-party plugins from partners and the community. It publishes no GitHub releases.

### how to install claude-plugins-official

Plugins install through Claude Code's plugin system rather than by cloning. Run `/plugin install {plugin-name}@claude-plugins-official`, or browse for the plugin under `/plugin > Discover`.

### What are the official Claude Code plugins?

The `plugins` directory holds the internal plugins developed and maintained by Anthropic, and `external_plugins` holds third-party plugins from partners and the community. The repository points to `plugins/example-plugin` as a reference implementation for what an internal one looks like.

### What exactly is a Claude plugin?

A plugin is a directory whose `.claude-plugin/plugin.json` manifest is the only required file. Everything else is optional: `.mcp.json` for MCP server configuration, and `commands/`, `agents/`, and `skills/` directories for slash commands, agent definitions, and skill definitions, alongside a README.

### how to add claude plugins official marketplace

External plugins are submitted by third-party partners through the plugin directory submission form and must meet quality and security standards for approval. Internal plugins are developed by Anthropic team members rather than submitted, and the repository provides a reference implementation for them.

## Sources

- [Official documentation](https://code.claude.com/docs/en/plugins)
- [Official README](https://github.com/anthropics/claude-plugins-official#readme)
- [Project repository](https://github.com/anthropics/claude-plugins-official)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/anthropics-claude-plugins-official