# Stop copy-pasting AI skills between repos: package them as Claude Code plugins

> Source: <https://dev.to/komandakycto/stop-copy-pasting-ai-skills-between-repos-package-them-as-claude-code-plugins-509h>
> Published: 2026-07-20 15:55:30+00:00

As we enter the era of AI and skills, we're faced with new problems — a flood of skills, and sharing knowledge (skills) between repos.

Every day I work with a bunch of repositories, predominantly in Go but sometimes in other languages. A huge layer of knowledge should be shared between them — for example, how to connect to a database, how to deploy a test tag to a staging server, or where to find the logs.

For several months I had been creating skills in each repo and putting the specific knowledge there, but after a while I realized I'd started copy-pasting some skills between repos.

Claude built a plugin system, and it has become mature enough to use. I created a separate repository with the skills and scripts that should be shared, and organized them as plugins. A plugin is just a structured git repository with files — convenient to maintain and update.

The install part is also very flexible: when I install a plugin, I can choose the scope.

Here's what it looks like in practice.

A plugin is just a git repo with a known layout. One marketplace can hold many plugins; one plugin can hold many skills.

```
dev-claude-plugins/                     # the repo you push to git
├── .claude-plugin/
│   └── marketplace.json                # catalog — lists the plugins in this repo
└── plugins/
    └── backend-dev/                    # one installable plugin
        ├── .claude-plugin/
        │   └── plugin.json             # manifest: name, version, author
        └── skills/
            ├── query-db/
            │   └── SKILL.md            # how to connect + run read-only queries
            ├── staging-deploy/
            │   ├── SKILL.md            # deploy a dev tag to staging
            │   └── references/         # extra docs the skill loads on demand
            └── logs/
                ├── SKILL.md            # where/how to read service logs
                └── scripts/            # helper shell scripts the skill calls
```

They're tiny. `marketplace.json`

is the catalog:

```
{
  "name": "myteam",
  "owner": { "name": "your-handle" },
  "plugins": [
    { "name": "backend-dev", "source": "./plugins/backend-dev",
      "description": "Shared cross-repo dev skills: db queries, staging deploy, logs." }
  ]
}
```

`plugin.json`

is the plugin itself:

```
{
  "name": "backend-dev",
  "version": "0.1.0",
  "author": { "name": "your-handle" },
  "description": "Shared cross-repo development skills."
}
```

Two commands. First register the marketplace, then install the plugin — this is where you pick the scope (this project only, or user scope = available in every repo):

```
# 1. Register the marketplace — a local path while iterating…
/plugin marketplace add ~/work/dev-claude-plugins
#    …or a git URL to share across machines and teammates:
/plugin marketplace add https://github.com/your-handle/dev-claude-plugins.git

# 2. Install the plugin (prompts for scope: user vs project)
/plugin install backend-dev@myteam
```

Now every skill is available as `/backend-dev:<skill>`

— e.g. `/backend-dev:query-db`

— and also auto-triggers from its description.

Add a skill once, bump `version`

, push, and every repo picks it up with:

```
/plugin marketplace update myteam
```

One source of truth instead of copy-pasting `.claude/skills/`

into ten repos.