The license arrives. The whole team starts using Claude. At first, everything is bright: "This thing is amazing!" Everyone improves, everyone shares, everyone discovers new things.

And then, almost without noticing, as a natural evolution, a new problem appears.

Everyone has configured it on their own — on their machine, in their own interface. The one who found the perfect prompt for reviewing PRs keeps it to themselves. The one who built a skill to generate Jira tickets has it on their machine and nowhere else.

You have as many versions of Claude as you have team members.

The first solution, the obvious one, doesn't work for everyone

The first thing every team tries is exporting and importing a file through Cowork. It works. But only between Cowork users.

The developers on Ubuntu running Claude Code don't have that option at first glance. And even if they did, every time someone updates a skill, you're back to sending the file through the team Slack channel. The previous one is now outdated. And nobody knows which version they have installed.

The real solution: a repository as a marketplace

Claude Code and Cowork both support importing skills, commands, and agents packaged as plugins from an external source that follows the plugin marketplace structure.

That means you can build your own:

Git repository, accessible to your whole team, that acts as the single source of truth for your Claude tooling.

What one person updates, everyone receives. And each team member can import it regardless of whether they work on Windows with Cowork, on Mac, or on Ubuntu with Claude Code.

Here's how to do it.

How?

1. Create the repository

It can be on GitHub, GitLab, Bitbucket — whatever you use. It just needs to be accessible from your team's machines.

The repo follows this structure:

claude-plugin-marketplace/         ← git repository
├── .claude-plugin/
│   └── marketplace.json          ← marketplace index
├── README.md
└── greetings/                    ← one directory per plugin
    ├── .claude-plugin/           
    │   └── plugin.json           ← plugin metadata
    ├── commands/
    │   └── welcome.md            ← command
    └── skills/
        └── greet-in-language/    ← skill
            └── SKILL.md

2. The marketplace.json file

This lives inside the .claude-plugin directory at the repo root. It lists the available plugins, each pointing to its directory:

{
  "name": "claude-montells-plugins",
  "owner": {
    "name": "Michel Sánchez Montells"
  },
  "plugins": [
    {
      "name": "greetings",
      "source": "./greetings",
      "description": "A collection of greeting utilities: a /welcome command that introduces the session with date and directory context, and a skill that greets the user in any language they request."
    }
  ]
}

name: is how the marketplace will be listed.
plugins: list of plugins with name and source.

3. The plugin.json file

Each plugin defines its metadata in .claude-plugin/plugin.json inside its own directory:

{
  "name": "greetings",
  "version": "1.0.0",
  "description": "A collection of greeting utilities: a /welcome command that introduces the session with date and directory context, and a skill that greets the user in any language they request.",
  "author": {
    "name": "Michel Sánchez Montells",
    "email": "montells@gmail.com",
    "url": "http://github.com/montells"
  },
  "repository": "https://github.com/montells/claude-plugin-marketplace"
}

name: the name of the plugin. Act as a namespace for the commands and skills.

4. A skill example

Each skill is a folder named after the skill, containing a SKILL.md file. The content is the prompt Claude will invoke autonomously when the context calls for it:

<!-- pluginName/skills/skillName/SKILL.md -->
<!-- greetings/skills/greet-in-language/SKILL.md -->

Greet the user in the language they request.
If no language is specified, greet them in English.
Keep the greeting warm and brief.

5. A command example

Commands live in commands/<name>.md. Unlike skills, they are invoked explicitly with /name and can receive arguments via $ARGUMENTS:

<!-- greetings/commands/commandName.md -->
<!-- greetings/commands/welcome.md -->
---
description: "Introduce the session with date and directory context"
allowed-tools: Bash(date), Bash(pwd)
---

Greet the user and provide session context.

## Context
- Current date and time: !`date`
- Working directory: !`pwd`

## Task
Say hello and let the user know where they are and what time it is.

6. Import from Cowork

The flow in Cowork depends on your plan:

Team or Enterprise plan — the ideal path for teams. An admin connects the GitHub repository from the organization settings. From that point, the plugins appear in every team member's catalog and can be installed (or auto-installed) without anyone having to do anything else.

Individual plan (Pro/Max) — the repository can't be connected directly, but you can export the plugin as a .zip and upload it manually: Customize → Browse plugins → Upload plugin file. It works, though it loses the benefit of automatic sync.

In both cases, once the plugin is installed, its skills appear when you type / in Cowork.

7. Import from Claude Code

From Claude Code, type /plugins to open the plugin manager. Go to the Marketplaces tab and select + Add Marketplace.

You'll be prompted for the marketplace source. It supports several formats:

owner/repo                              ← GitHub shorthand
git@github.com:owner/repo.git          ← SSH
https://example.com/marketplace.json   ← HTTPS
./path/to/marketplace                  ← local path

In our case:

montells/claude-plugin-marketplace

Or with SSH if the repo is private:

git@github.com:montells/claude-plugin-marketplace.git

Once added, go to the Discover tab. You'll see the plugins available in the marketplace. Select one to view its details and choose the installation scope:

• Install for you (user scope) — just for you, across all your projects
• Install for all collaborators on this repository (project scope) — for the whole team on this repo
• Install for you, in this repo only (local scope) — just you, just here

After installing, Claude Code will prompt you to run /reload-plugins to activate the changes.

From that point on, the plugin's commands are invoked with the plugin prefix: /greetings:welcome. Skills activate autonomously when Claude determines the context calls for them.

8. Update flow

From here, updating a skill is exactly like updating code:

1. Edit the skill file in the repo
2. Commit and push
3. The team receives the update next time they sync

No files through Slack. No "which version do you have?". No diverging configurations.

The result

One repository. One single source of truth. And every team member — regardless of their platform — with exactly the same tools, at their latest version.

Onboarding a new team member to Claude goes from "set it up yourself" to "add this marketplace and you're ready."

The example used in this post can be found here