---
title: "How to Create a Claude Skill and Get It Into Anthropic's Plugin Marketplace"
description: "A step-by-step guide to writing a Claude skill, packaging it as a plugin in a GitHub marketplace, testing it in Claude Code and Cowork, and listing it in Anthropic's plugin directory, built from two real EdgeKits plugins."
canonical: "https://edgekits.dev/en/blog/create-claude-skill-plugin-marketplace/"
published: "2026-11-15"
tags: ["Claude Code", "Claude Cowork", "Claude Skills", "Claude Plugins", "Telegram", "RepoAccess"]
---

A Claude skill is a folder with a `SKILL.md` file that tells Claude when and how to do a specific job. To put one in front of people who use Claude Code and Cowork, you package it as a plugin and submit it to Anthropic's plugin marketplace, which Anthropic's own docs call the plugin directory.

This guide covers the whole path in order: writing a skill that triggers on its own, packaging it as a plugin with a marketplace file, testing it on each surface, filling in the submission form in the developer portal, getting through the security scan and review, and keeping the listing current once it's live. Every step comes from a skill I built and listed, so the files, form fields and checks shown below are the real ones.

> **TL;DR**
>
> 1. Write a `SKILL.md` whose description lists the words people actually type, so Claude loads it without being asked.
> 2. Put the skill in a plugin folder with `.claude-plugin/plugin.json`, and list the plugin in `.claude-plugin/marketplace.json` at the root of a public GitHub repo.
> 3. Run `claude plugin validate`, install the plugin from your own marketplace, and test it in an empty folder in Claude Code and in Cowork.
> 4. Submit it at `claude.ai/directory/manage` in five steps: Source, Listing details, Data handling, Compliance, Review and submit.
> 5. Wait for the security scan, then press Publish, which asks an Anthropic reviewer to make it live: two days for one of my plugins, five weeks for the other.
> 6. Keep it current by pushing to the tracked branch, and raise `version` with every release.

## Skill, plugin and marketplace: what each word means in Claude

A **skill** is a folder with a `SKILL.md` file: YAML frontmatter on top, instructions below. Claude keeps the descriptions of installed skills in context and loads a skill's full body only when a request matches, as [Claude Code's skills documentation](https://code.claude.com/docs/en/skills) explains. A skill costs almost nothing until it fires.

A **plugin** is the package people install: a folder with `.claude-plugin/plugin.json` and any mix of skills, commands, agents, hooks and MCP servers. A skill can't be listed by itself. [Anthropic's directory docs](https://claude.com/docs/directory/publish) are direct about it: skills aren't a submission type, so you put them in a plugin bundle.

A **marketplace** is a catalog: a `.claude-plugin/marketplace.json` file in a repo that lists plugins and where to fetch each one. Anyone can host one on GitHub. Anthropic runs the big one, the plugin directory, which Claude Code shows as "Anthropic Directory" in its Discover tab, and the Claude Marketplace website sends plugin authors there too, with no separate submission of its own.

## Two Claude skill examples from one marketplace

Both plugins live in one public repo, [EdgeKits/skills](https://github.com/EdgeKits/skills), which is also the `edgekits` marketplace. Each plugin installs on its own and has its own directory listing and icon. Together they make two different Claude skill examples: one only reads code, the other runs commands on the user's machine.

  **Update (November 2026):** the marketplace now carries five plugins. One of them,
  `edgekits-i18n`, is a different kind of skill from the two below: the installation interface of an npm package,
  `@edgekits/astro-i18n`, that asks six questions, writes the config and project files, and
  refuses the steps a tutorial would leave to the reader. What that looks like, and which bugs
  the agents installing it found, is in
  [Edge-Native i18n, Part 4](/en/blog/astro-i18n-npm-package-agent-skill-part-4/).

**Telegram Bot Security Audit** is the main example: a code review skill for Telegram bots, packaged as a Claude security plugin. A general review reads a bot as a webhook handler with no SQL and finds little, so this one looks for the holes specific to the platform: whether an update really came from Telegram, which chat a reply lands in, who can pay an invoice, what a log line leaks. It's one skill of 195 lines plus two reference files, runs no code of its own, and works on a bot written in any language.

**RepoAccess** is the second plugin, and it taught me most of what's in the next section. It's a hand-off skill: when someone says they want to sell access to a private GitHub repo, it explains [RepoAccess core](/en/tools/repoaccess/), asks which payment provider they use, clones the repo and passes them to its setup wizard. A skill that runs commands on someone's machine has more ways to go wrong than one that only reads code, and I hit most of them.

## How to create a Claude skill that triggers on its own

A skill nobody has to name is worth more than one people must remember to call. Everything below serves two goals: getting Claude to load the skill at the right moment, and keeping it on rails once it has.

### Write the description as the trigger

The `description` field is the only part of a skill Claude sees before it decides. I write it in three parts: what the skill achieves, why it beats the generic approach, and a "Use when" list in the user's own words, including the narrow questions people ask instead of "please audit my bot". Here is the frontmatter of the Telegram skill:

```yaml
---
name: telegram-bot-security-audit
description: Security-audit a Telegram bot's source code, in any language and on any hosting - webhook authenticity and the Mini App-to-server boundary, admin gating, chat identity, guest mode and other non-private entry points, payments and Stars (invoices, refunds, subscriptions), the support relay, message-entity forgery, secrets in logs, and data retention. Use this skill whenever the user asks to review, audit, harden or "check the security of" a Telegram bot, a Bot API webhook handler, or any code that handles Telegram updates, callback queries, invoices, Stars payments or refunds - and also when they ask a narrower question that touches that surface, such as "is my admin check safe", "is my webhook safe", "can a buyer fake this message", "what happens if someone adds my bot to a group", or "am I leaking my bot token". Generic OWASP or dependency scanners miss almost everything here, so reach for this skill even when a general security review has already been run.
---
```

Those quoted phrases aren't decoration. In the test bot's folder I typed "Is my webhook safe?", with no mention of a skill or an audit, and Claude Code loaded `telegram-bot-security-audit` by itself; "What happens if someone adds my bot to a group?" did the same. The docs truncate the combined description at 1,536 characters in the skill listing, so put the main use case first.

### Make every question a hard stop

When a skill needs an answer from the user, an open question invites the model to guess and keep going. In RepoAccess, an open "which provider do you use?" produced "Paddle, Lemon Squeezy, Gumroad, etc." in one run and a full list in another. The fix was a closed menu of exactly seven numbered options, followed by one blunt line: "Stop and wait for the answer. Do not go on to step 3 in the same message."

Two details made it hold. The skill tells Claude to use a multiple-choice tool if it has one, which Claude Code renders as a clickable menu. And because that tool caps the number of options, the skill says what a typed answer outside the menu counts as, so no reply falls through.

### Spell out what the skill must not do

A model that wants to help will fill any gap you leave. RepoAccess ends with a "Do not" list: don't run the setup wizard from this session, don't create or edit the files that hold secrets, don't write payment or GitHub-access code, and don't rebuild the setup from the repo's source. Each line closes a shortcut I could picture the model taking.

### Keep secrets out of the agent's reach

The safest skill never sees a key. RepoAccess sends the user to a new terminal session inside the cloned repo and explains why: that repo ships its own agent permissions, which let the wizard's one command (`npm run wizard:drive`) run without prompts and deny the agent read access to `.dev.vars` and `.dev.vars.production`, the files where the user pastes secrets. Those permissions apply only to a session started in that folder.

So the skill is a pointer, and the guarded work happens somewhere built for it. If your skill touches credentials, design the hand-off before you write the first step.

### Plan for the environment the skill can't see

My first RepoAccess run cloned the repo two folders above where the user was working, and the question about the path was buried at the end of a long message. The skill now picks the location by rule (inside an empty folder, otherwise next to the current project, never inside it) and asks for the exact full path as a short question of its own.

The second surprise came from Cowork. Its shell runs in a Linux sandbox, so `npm install` there would put Linux builds of native tools into a Windows user's folder. The model noticed this by itself and handed the command to the user, and I turned its judgment into a rule: if your shell isn't on the user's operating system, run only `git clone` and give them the rest.

### Move the heavy material into references

The Telegram skill keeps its method in `SKILL.md` and its depth in two files under `references/`: a platform reference for the Bot API and a catalogue of 16 finding patterns. `SKILL.md` says when to open each one, so the details load only during an audit. Anthropic's guidance is to keep `SKILL.md` under 500 lines and move detailed material out.

## Claude skill structure inside a plugin

Here is the whole repo: one marketplace file at the root, one folder per plugin, and inside each plugin a manifest, an icon, a README and the skill.

```
.claude-plugin/marketplace.json
.gitattributes
LICENSE
README.md
plugins/
  repoaccess/
    .claude-plugin/plugin.json
    .claude-plugin/icon.png
    README.md
    skills/sell-repo-access/SKILL.md
  telegram-bot-security-audit/
    .claude-plugin/plugin.json
    .claude-plugin/icon.png
    README.md
    skills/telegram-bot-security-audit/
      SKILL.md
      references/telegram-platform.md
      references/findings-catalogue.md
```

### The Claude marketplace.json and plugin.json files

The marketplace file needs a `name`, an `owner` and a `plugins` array. Each entry needs a `name` and a `source`, written as a path from the repo root, as [the marketplace docs](https://code.claude.com/docs/en/plugin-marketplaces) show:

```json
{
  "name": "edgekits",
  "description": "Agent skills and Claude plugins from EdgeKits.",
  "owner": { "name": "EdgeKits", "url": "https://edgekits.dev" },
  "plugins": [
    {
      "name": "repoaccess",
      "source": "./plugins/repoaccess",
      "description": "Sell access to a private GitHub repo with Stripe: gets you to the setup wizard of RepoAccess core, a free, self-hosted Cloudflare Worker."
    },
    {
      "name": "telegram-bot-security-audit",
      "source": "./plugins/telegram-bot-security-audit",
      "description": "Security audit for Telegram bot code: webhook and Mini App authenticity, admin gates, chat identity in groups and guest mode, Stars payments and refunds, token leaks. The platform-specific holes generic scanners miss."
    }
  ]
}
```

Keep each entry's `name` identical to the `name` in that plugin's own `plugin.json`. The install id is `entry-name@marketplace`, and when the two names differ, installs fail with "not found in marketplace".

The plugin manifest requires only `name`. Everything else is what the directory shows on your listing:

```json
{
  "name": "telegram-bot-security-audit",
  "version": "1.0.0",
  "displayName": "Telegram Bot Security Audit",
  "description": "Security audit for Telegram bot code: webhook and Mini App authenticity, admin gates, chat identity in groups and guest mode, Stars payments and refunds, token leaks. The platform-specific holes generic scanners miss.",
  "author": { "name": "EdgeKits", "url": "https://edgekits.dev" },
  "homepage": "https://github.com/EdgeKits/skills/tree/main/plugins/telegram-bot-security-audit",
  "repository": "https://github.com/EdgeKits/skills",
  "privacyPolicyUrl": "https://github.com/EdgeKits/skills/tree/main/plugins/telegram-bot-security-audit#privacy",
  "license": "MIT",
  "keywords": ["telegram", "telegram-bot", "bot-api", "security", "audit", "code-review", "telegram-stars", "mini-apps"]
}
```

`displayName` and `description` become the listing's title and short description, and `keywords` become its discovery keywords. `privacyPolicyUrl` is read only by the directory: Claude Code ignores it, and the portal flags it as an unrecognized field with "No action needed". I keep it, because that warning is the price of a Privacy policy link on the listing.

### Version or no version?

Without a `version`, Claude Code uses the commit SHA, so every push is a new version. With one, you must raise it in every release: otherwise `claude plugin update` reports the plugin is already at the latest version and users keep the old copy, as [the publishing docs](https://code.claude.com/docs/en/plugins/publish) warn.

I shipped RepoAccess without a version at first, then moved both plugins to `1.0.0` when they joined one repo. The directory now shows v1.0.0 on the plugin page instead of a commit hash, and a release becomes a deliberate act: the change and the version bump go in the same commit.

### README, license, privacy policy and icon

The directory's checks look for a README that explains what the plugin does and any data it sends, a LICENSE file or a `license` field, and an icon. Each of my plugin READMEs ends with a Privacy section, and that's where `privacyPolicyUrl` points. Write it precisely: my first draft said EdgeKits "receives nothing", which was wrong, because the skill's links to the site carry UTM tags.

The icon is a square PNG or JPEG, 512 to 2048 px and under 2 MB, at `.claude-plugin/icon.png`; SVG and WebP are rejected. Don't build it from someone else's logo: my first Telegram icon used Telegram's, which its API terms forbid, so it became a robot in a shield. Commit the icon before you first save the submission, because the portal imports it from the repo only once.

### Validate before you push

From the repo root:

```bash
claude plugin validate .
claude plugin validate ./plugins/telegram-bot-security-audit
```

Both should end with "Validation passed". The command checks JSON syntax, required fields, names and source paths; it doesn't check icons, which the portal does later. Unknown fields come back as warnings, and warnings don't fail validation unless you add `--strict`.

### The same repo works in other agents

Cursor, OpenCode and other agents that read `SKILL.md` install from the same repo with the [skills CLI](https://github.com/vercel-labs/skills), which finds skills through the `.claude-plugin` manifests:

```bash
npx skills add EdgeKits/skills --list
npx skills add EdgeKits/skills --skill telegram-bot-security-audit
```

`--list` shows what's in the repo without installing anything, and `--skill` picks one skill from a repo that holds several.

## Test it on every surface before you submit

The directory scans your code; it doesn't check that your skill fires or does its job. That part is yours, and it's cheaper to fix before a listing exists.

### How to install a Claude skill the way your users will

A Claude skill is installed through its plugin: add the marketplace, then install the plugin from it, inside a Claude Code session:

```
/plugin marketplace add EdgeKits/skills
/plugin install telegram-bot-security-audit@edgekits
```

Adding a marketplace installs nothing. My first RepoAccess "trigger test" ran with only the marketplace added: the skill didn't fire, Claude answered from general knowledge, and the test proved nothing. Install the plugin, then confirm it with `claude plugin list` or the Installed tab in `/plugin` before you trust a result.

Two more pitfalls. Marketplace names are unique per user, and mine collided with a local marketplace I had already registered as `edgekits`; the error read `Cannot add marketplace "edgekits": its source doesn't match its extraKnownMarketplaces entry`, so run `claude plugin marketplace list` before you pick a name. And for a plugin folder you haven't pushed yet, `claude --plugin-dir ./path` loads it for one session with no marketplace at all.

### Test against a target with a known answer

A trigger test shows that the skill loads, not that it's any good. For the audit I wrote a small Telegram shop bot, planted 17 defects in it, and kept the answer key outside the folder the audit ran in. Then I opened Claude Code in that folder and typed "Check my Telegram bot for security issues and save the report to SECURITY-AUDIT.md".

The skill loaded on that phrase, read all 331 lines of the bot, checked the current Bot API version against its own reference, and ran the bot's code against forged updates with Telegram stubbed out. The report caught all 17 planted defects plus five real ones I hadn't planted, grouped into 18 findings from one Critical to three Info. Two severity grades differed from my key, with reasons I accepted.

Then walk every branch the skill has, each in a fresh empty folder. For RepoAccess that meant a provider only the paid tier supports, an unsupported provider, and Stripe all the way to the wizard; three rounds of fixes came out of those runs.

### Cowork: an empty folder and a different shell

In the Claude desktop app, Cowork adds plugins from Customize, then Plugins: through Discover, Add marketplace, or Upload plugin with a zip of the folder, per [the platform support table](https://claude.com/docs/plugins/platform-support). Create a project with an empty folder and start a task with a natural phrase. Skip the plugin's Try In Cowork button for this test, because it names the plugin for you.

This is where RepoAccess met the Linux sandbox described above, and where I saw the skill answer in Russian when I wrote to it in Russian. Test every surface you plan to list on, because chat, Cowork and Claude Code each load a different subset of what a plugin can contain.

## How to submit a plugin to Anthropic's plugin marketplace

### Who can submit, and how often

Anyone on a Pro, Max, Team or Enterprise plan can submit; free accounts can't. On Pro and Max you submit from your own account, and on Team and Enterprise an Owner submits or grants the Directory permission, per [the eligibility rules](https://claude.com/docs/directory/publish#confirm-you-can-submit-to-the-directory). I submitted both plugins from a Max account.

Each plugin folder is its own submission, so a repo with two plugins needs two. An organization can create up to 10 submissions in 24 hours, drafts and withdrawn ones included, according to [the submission guide](https://claude.com/docs/plugins/submit). The portal also checks that the GitHub account connected to your Claude organization can push to the repo; my first attempt stopped with "GitHub isn't connected for this Claude organization" until I connected it.

### Start a plugin bundle submission

Open the developer portal at `claude.ai/directory/manage`, select Submit new, and choose Plugin bundle. The other option, MCP connector, is for a remote server listed by itself.

The form has five steps: Source, Listing details, Data handling, Compliance, Review and submit. Save and exit keeps a draft at any point.

### Step 1: Source and Validate

Enter the repository, the plugin path if the plugin isn't at the root, and a branch or tag if you don't want the default branch. I entered `https://github.com/EdgeKits/skills` and `plugins/telegram-bot-security-audit`, and left the branch empty, so the directory follows `main`.

Validate ran seven checks on commit `56ea61c` and passed with two warnings. One was the expected `privacyPolicyUrl` notice. The other said the skill body "contains a download-and-run command", although the `SKILL.md` downloads nothing: the scanner matched a line of prose that mentions shells and `eval` while describing what a safe handler avoids.

The portal's own help says a pattern that appears only in documentation needs no change, and a warning doesn't block a submission. A validation result belongs to one commit, so if you push after validating, validate again.

### Step 2: Listing details

This step is read-only: name, description, author, keywords and README come from `plugin.json` and the repo. To change anything, edit the repo, push and validate again. Empty links show up here with the field to add, such as `supportUrl` or `documentationUrl` in `plugin.json`.

The same screen holds Listed on, with Claude Code, Cowork and Claude apps (web, desktop, mobile) all ticked by default. That choice deserves a minute, and I come back to it below.

### Steps 3 and 4: Data handling and Compliance

Data handling asks four questions: does the plugin read or store personal data, does any skill send data to a service other than the declared connectors, how long is data retained, and is it intended for users under 18. For a plugin that is only instructions, my answers were No, No, Not retained and No.

Compliance asks for a contact email, never shown publicly, and four acknowledgements, including one that the privacy policy accurately describes the data the plugin handles. That's why the Privacy section should exist before you reach this step.

### Step 5: Review and submit

The last step sums up your choices and adds two settings. Auto-publish passing versions lets later versions go live without you pressing Publish; the first version always goes through a person. How new versions reach the directory offers a GitHub push webhook, which needs admin access to the repo, or a scheduled check about every six hours, which the directory runs either way.

I chose the scheduled check and pressed Submit for review.

## What happens after you press Submit for review?

The directory scans the newest commit on the tracked branch: validation again, then a security scan. A scan ends one of three ways: the version passes, it's held for a reviewer, or it fails with the broken rules listed. The Telegram plugin passed about four minutes after I submitted.

A passing version still isn't live. You press Publish, and by default that records a request for an Anthropic reviewer, who makes the version live. RepoAccess went from submission to live in two days. The Telegram plugin passed its scan in four minutes, then waited five weeks for a reviewer with nothing changed in its folder: submitted on October 8, live on November 13.

The docs say review time isn't fixed, and that range is the reason to submit early and not time a launch post to the listing. Read the banner above the tracker while you wait, because it says who acts next. Once a plugin is published, the portal notes that a new listing can take up to an hour to show up in the apps.

The directory kept scanning while it waited. Every commit on the tracked branch becomes a new version of every plugin in the repo, even a commit that never touches the plugin's folder, so the version that went live was a later commit than the one I submitted, with the same 1.0.0 in `plugin.json`.

## Which surfaces should the plugin be listed on?

List a plugin only where it can do its job. RepoAccess needs a shell, git and a folder, so it's listed on Claude Code and Cowork, and I ticked Cowork only after testing there. When I submitted it, chat in the Claude apps had no shell, so that box stayed empty.

The Telegram audit only reads code, so I kept all three surfaces and tested in the Claude desktop app once the listing was live. I added the plugin from the directory and pressed Try in chat first: it opens a chat with the skill's slash command already typed, which proves the install, not the trigger.

The trigger test was a new project with the demo bot's folder and the plain request "Run a security audit for this project." The skill loaded on its own, read the code, ran the bot against a stubbed Telegram API on my machine and saved a report with 19 findings, from one Critical down to three Info. All three surfaces stay.

You can change this at any time under Settings, then Listed on; a saved change reads "Not listed yet" until the directory applies it.

## Where people find and install your plugin

In Claude Code, `/plugin` opens a Discover tab that searches the Anthropic Directory together with every marketplace you've added, and `/plugin directory` browses the directory on Claude Code v2.1.287 and later. On the day I searched, the source counts read Anthropic Directory 3,226 and claude-plugins-official 312 against my own marketplace's 2, so a directory listing puts a plugin in by far the biggest pool.

In the Claude desktop app and on claude.ai, the directory sits under Settings, then Customize, then Plugins, on paid plans. A search for "Telegram" there returned 139 results, with the audit second, right after Anthropic's own Telegram plugin. In the list, a directory plugin carries a Community badge and its GitHub source.

Open it, and its own page reads "from Anthropic Directory", with its version, its skill count and, for a plugin like this one, a note that it only adds instructions for Claude.

A plugin added to an account on claude.ai also reaches Claude Code as a synced plugin at the next session start, while one installed from the command line stays on that machine.

Two places I wouldn't count on. The public page at claude.ai/directory showed me connectors and a desktop extension in a logged-out session, but no plugins. And the GitHub catalog [anthropics/claude-plugins-community](https://github.com/anthropics/claude-plugins-community) lagged behind the in-app directory, with 2,283 entries against 2,473 on the same day.

## Keeping the listing current

Push to the tracked branch, and the directory picks up the commit, scans it and publishes it according to your publish setting. Without the webhook, either wait for the scheduled check or press Check for new commits on the plugin's page. Until a new version is published, the old one keeps serving.

Two things surprised me here. A submission's repo and plugin folder can't be changed, yet renaming the GitHub repo from `repoaccess-skill` to `skills` broke nothing: GitHub redirects the old URL, and the directory scanned the next commit from the renamed repo. The Listing tab, meanwhile, keeps the details read at submission, while the display name and short description follow the live version.

The icon has its own review queue. RepoAccess's icon expired unreviewed four days after submission, and new commits didn't bring it back, because the portal imports the repo icon only once. The fix was Listing, then Icon, then Replace with the same file. The Telegram plugin went live with its icon still waiting, so the apps show it with a generic placeholder instead of its shield.

## Other places to list a Claude skill

The directory isn't the only catalog. I submitted RepoAccess to MCP Market, which lists one skill per entry and takes the skill folder's URL, and opened a pull request to the ComposioHQ awesome-claude-skills list.

The hesreallyhim awesome-claude-code list takes submissions only through its issue form, filed by a person, for repos at least 14 days old. And skills.sh needs no submission at all, since it ranks skills by `npx skills add` usage. Each of these reaches people who never open Claude's Discover tab, and the same repo serves all of them.

## What the directory doesn't give you

It doesn't give you reliable traffic numbers. In its first week, RepoAccess showed Installs climbing from 125 to 160 while Active accounts and Uses stayed at one or two, which was me testing. The Telegram plugin repeated the pattern: 44 installs in its first days in the directory, against two active accounts and two uses. Installs count technical events, and GitHub clone counts were inflated the same way: 75 clones from 33 cloners against 2 unique visitors.

It doesn't tell you whether people succeed with the skill, either. The Usage tab shows runs and error rates, not outcomes. Tag the links your skill shows with UTM parameters, because a tagged visit to your site is the one number that means a person clicked.

And it doesn't market the plugin for you. A listing makes the skill findable by people already searching; the README, the repo description and write-ups like this one are what get it searched for.

Both plugins in this guide are free in [EdgeKits/skills](https://github.com/EdgeKits/skills). If the hand-off skill is the part that caught your eye, [RepoAccess](/en/tools/repoaccess/) is the product it hands off to: a self-hosted Cloudflare Worker that invites a buyer to your private GitHub repo when they pay and removes them on a refund. If you're choosing how to sell code at all, [the comparison of every way to sell private repo access](/en/blog/sell-access-private-github-repo-every-option-compared/) lays out the options, and the bot-based route is in [the guide to selling repo access for Telegram Stars](/en/blog/telegram-stars-github-repo-access/).

## Frequently Asked Questions

**Q: How do I create a Claude skill?**

**A:** Create a folder named after the skill and put a SKILL.md file in it. The file starts with YAML frontmatter holding a name and a description, followed by the instructions Claude follows when the skill runs. The description matters most, because Claude reads only the descriptions of installed skills before deciding which one to load. Write what the skill achieves, why it beats the generic approach, and a 'Use when' list in the words people actually type, including narrow questions. Keep SKILL.md under 500 lines and move long reference material into separate files that the skill tells Claude when to open. To share it, place the folder under skills/ inside a plugin, then test it by typing a natural request in an unrelated empty folder and checking that Claude loads the skill without being asked.

---

**Q: What is the difference between a Claude skill and a Claude plugin?**

**A:** A skill is one capability: a folder with a SKILL.md file that tells Claude when and how to do a specific job. A plugin is the package people install. It is a folder with a .claude-plugin/plugin.json manifest that can hold any mix of skills, commands, agents, hooks and MCP servers. Anthropic's directory lists plugins, not loose skills: skills are not a submission type of their own, so you put them in a plugin bundle. Inside Claude Code a plugin's skill is namespaced by the plugin, so the telegram-bot-security-audit skill appears as telegram-bot-security-audit:telegram-bot-security-audit. A plugin with one skill and no code is perfectly valid, and the directory shows it as adding only instructions for Claude.

---

**Q: Who can submit a plugin to Anthropic's plugin marketplace?**

**A:** Anyone on a paid Claude plan: Pro, Max, Team or Enterprise. Free accounts cannot submit. On Pro and Max you submit from your own account with no role to check. On Team and Enterprise an Owner can submit, and on Enterprise an Owner can grant the Directory permission to other members through a custom role. You submit at claude.ai/directory/manage, and the listing belongs to the organization you submit from, so choose the one that should own it long term. The portal also checks that the GitHub account connected to that Claude organization can push to the repository. There is no partner program to apply to first, and there is no separate Claude Marketplace submission: the directory is the one place to submit.

---

**Q: How does Anthropic review a plugin before it goes live?**

**A:** Every version gets automated validation and a security scan, and a person reviews a new listing before it goes live. After you submit, the directory scans the newest commit on the tracked branch. The scan ends with the version passing, held for a reviewer, or failing with the broken rules listed. A passing version is still not live: you press Publish, which by default records a request for an Anthropic reviewer. In my case RepoAccess went from submission to live in two days, while the Telegram plugin passed its scan about four minutes after I submitted and then waited five weeks for a reviewer. Review time is not fixed, so read the banner on the plugin's page, which says who acts next.

---

**Q: Do I need a version field in plugin.json?**

**A:** No, only name is required, but the choice changes how updates work. Without a version, Claude Code uses the commit SHA, so every push to the tracked branch is a new version for users and for the directory. With a version, you must raise it in every release, because a push that keeps the old number leaves users on the old copy: claude plugin update reports that the plugin is already at the latest version. I started RepoAccess without a version and accepted the validator's warning, then moved both plugins to 1.0.0 when they joined one repository. The directory now shows v1.0.0 instead of a commit hash, and every release puts the change and the version bump in the same commit.

---

**Q: How do people install a Claude skill from a plugin marketplace?**

**A:** A skill is installed through the plugin that contains it. In Claude Code, add the marketplace once with /plugin marketplace add owner/repo, then install with /plugin install plugin-name@marketplace; adding a marketplace alone installs nothing, so check claude plugin list afterwards. A plugin listed in Anthropic's directory skips the marketplace step: it shows up in the Discover tab of /plugin, and /plugin directory browses the directory on Claude Code v2.1.287 and later. In Cowork and on claude.ai, plugins are under Customize, then Plugins, where Discover, Add marketplace and Upload plugin with a zip of the folder are all available, and a plugin added there reaches Claude Code as a synced plugin at the next session start. Agents such as Cursor and OpenCode install the same skill with npx skills add owner/repo --skill skill-name.

---

**Q: How do I update a plugin that is already listed?**

**A:** Push to the tracked branch, the way you already release. The directory picks up each commit, scans it and publishes it according to the plugin's publish setting. Without the GitHub push webhook it finds new commits on a scheduled check about every six hours, and Check for new commits on the plugin's page runs the check at once. The listing keeps serving the last published version until a new one is published, including when a new version fails or is held for a reviewer. If plugin.json sets a version, raise it with every release. You cannot change a submission's repository or plugin folder, but renaming the GitHub repository did not break mine, because GitHub redirects the old URL.

---

**Q: Is my own plugin marketplace enough, or do I need Anthropic's directory?**

**A:** Your own marketplace is enough for anyone who already knows about you. A public GitHub repo with a .claude-plugin/marketplace.json is published the moment you push it: people add it with /plugin marketplace add owner/repo and install by name, and the same repo works in other agents through npx skills add. What it lacks is discovery. The directory puts your plugin into the Discover tab of Claude Code and Cowork, next to more than three thousand others, for people who have never heard of you. It also scans each version and gives you a usage dashboard. I run both: the EdgeKits/skills repo is the marketplace, and each plugin in it has its own directory listing.

```json
{"@context":"https://schema.org","@graph":[{"@type":"BlogPosting","headline":"How to Create a Claude Skill and Get It Into Anthropic's Plugin Marketplace","description":"A step-by-step guide to writing a Claude skill, packaging it as a plugin in a GitHub marketplace, testing it in Claude Code and Cowork, and listing it in Anthropic's plugin directory, built from two real EdgeKits plugins.","image":"https://cdn.edgekits.dev/public/blog/2026/create-claude-skill-plugin-marketplace/create-claude-skill-plugin-marketplace-hero.jpg","author":{"@type":"Person","name":"Gary Stupak","url":"https://x.com/GaryEdgeKits"},"datePublished":"2026-11-15T08:08:00.000Z","dateModified":"2026-11-15T08:08:00.000Z","keywords":["Claude Code","Claude Cowork","Claude Skills","Claude Plugins","Telegram","RepoAccess"],"mainEntityOfPage":{"@type":"WebPage","@id":"https://edgekits.dev/en/blog/create-claude-skill-plugin-marketplace/"},"publisher":{"@id":"https://edgekits.dev/#organization"}},{"@type":"Organization","@id":"https://edgekits.dev/#organization","name":"EdgeKits","url":"https://edgekits.dev","logo":"https://cdn.edgekits.dev/public/branding/edgekits-logo.png","sameAs":["https://x.com/GaryEdgeKits","https://github.com/EdgeKits","https://www.linkedin.com/in/gary-stupak/"]}]}
```