Marketplaces and Plugins

You have talk-outliner and abstract-writer living in ~/.claude/skills/. They work well, but they’re just loose files. In this module, you’ll create two more conference skills (conf-finder and trip-report), then bundle the three marketplace-ready skills into a plugin and distribute it via a marketplace.

From Skills to Plugins

Right now, your skills live as independent directories in ~/.claude/skills/. They’re related — they all serve the conference-speaking workflow — but Claude Code sees them as unrelated:

  • They have no shared identity

  • You can’t distribute them as a set

  • There’s no versioning

  • Name collisions are possible if someone else installs a skill with the same name

The solution is to bundle them into a plugin and distribute via a marketplace.

Key Terms

Plugin

A collection of related skills (and optionally agents, commands, hooks) packaged as a directory with a .claude-plugin/plugin.json manifest. Plugins provide namespace isolation: skills are invoked as /plugin-name:skill-name.

Marketplace

A git repository containing one or more plugins, with a marketplace.json catalog file at the root. Claude Code can install plugins from any marketplace you add — Anthropic’s official marketplace or your own.

Marketplace Anatomy

Let’s examine the structure of a marketplace using Anthropic’s anthropic-agent-skills marketplace (the anthropics/skills GitHub repo) as a reference.

A marketplace has:

  • marketplace.json at the repository root — lists available plugins

  • Plugin directories under plugins/

  • Each plugin has .claude-plugin/plugin.json for metadata

  • Skills live under plugins/<plugin-name>/skills/<skill-name>/SKILL.md

When you install a plugin from a marketplace, skills are namespaced: plugin-name:skill-name. For example, /conference-toolkit:abstract-writer.

marketplace.json Format

The marketplace.json file catalogs all plugins available in the repository:

{
  "name": "conference-toolkit-marketplace",
  "owner": {
    "name": "Your Name"
  },
  "plugins": [
    {
      "name": "conference-toolkit",
      "source": "./plugins/conference-toolkit",
      "description": "Skills for conference speakers: abstract writing, conference discovery, and trip reports"
    }
  ]
}

plugin.json Format

Each plugin has a manifest at .claude-plugin/plugin.json:

{
  "name": "conference-toolkit",
  "description": "A toolkit for conference speakers",
  "version": "1.0.0"
}

The version field is optional but recommended. When present, Claude Code only updates the plugin when you bump the version.

Directory Structure

Here’s the complete structure for our conference-toolkit marketplace:

conference-toolkit/
├── marketplace.json
├── plugins/
│   └── conference-toolkit/
│       ├── .claude-plugin/
│       │   └── plugin.json
│       └── skills/
│           ├── abstract-writer/
│           │   ├── SKILL.md
│           │   └── templates/
│           ├── conf-finder/
│           │   └── SKILL.md
│           └── trip-report/
│               ├── SKILL.md
│               └── scripts/
│                   └── format-report.py

Building conf-finder

First, let’s quickly create conf-finder — a skill that helps discover conferences relevant to your topic. Since you already know how to use skill-creator from Module 3, use it to generate this one:

> /example-skills:skill-creator Create a skill called "conf-finder" that helps identify
  relevant conferences for a given topic or domain. It should search for conferences by
  topic area, geographic region, and time frame. Output should include conference name,
  dates, location, CFP deadline, and a relevance note.

Inspect and refine the generated skill at ~/.claude/skills/conf-finder/SKILL.md. Make sure the description is specific:

Find technology conferences relevant to a specific topic. Use when the user wants to
discover conferences, find CFP deadlines, or identify speaking opportunities.

Test it quickly:

> /conf-finder Find conferences about AI developer tools in the next 3 months

Once it’s working, move on to the more complex skill.

Building trip-report

Now create trip-report — the most complex skill so far, with an executable Python script. This skill generates structured post-conference trip reports.

Create the Skill Directory

mkdir -p ~/.claude/skills/trip-report/scripts

Write SKILL.md

Create ~/.claude/skills/trip-report/SKILL.md:

---
name: trip-report
description: Generate structured post-conference trip reports with executive summary, session notes, and action items
---

# Trip Report Generator

Generate a comprehensive post-conference trip report.

## Input Requirements

Accept from the user:
- Conference name
- Conference dates
- Location
- Your name (as attendee)
- List of sessions attended (titles and brief notes)
- Overall impressions

## Report Structure

Generate a markdown report with:

1. **Header**
   - Conference name, dates, location
   - Attendee name
   - Report date

2. **Executive Summary**
   - 2-3 paragraphs summarizing the conference value
   - Key themes observed
   - Overall recommendation

3. **Sessions Attended**
   - For each session:
     - Session title
     - Speaker(s)
     - 3-5 key takeaways
     - Relevance to our work

4. **Action Items**
   - Specific follow-up tasks
   - Formatted as checkboxes
   - Include owner if mentioned

5. **Recommendations**
   - Should we attend next year?
   - Who else should attend?
   - Related conferences to consider

## Formatting

After generating the report, pipe it through the formatting script:

```bash
python ~/.claude/skills/trip-report/scripts/format-report.py
```

This adds consistent formatting, timestamps, and checkbox rendering.

## Output

Return the formatted report ready for sharing with stakeholders.

Write the Formatting Script

Create ~/.claude/skills/trip-report/scripts/format-report.py:

#!/usr/bin/env python3
"""
Format conference trip reports with consistent styling.
Reads markdown from stdin, outputs formatted version to stdout.
"""

import sys
from datetime import datetime
import re

def format_report(content):
    """Format a trip report with standard styling."""
    lines = content.strip().split('\n')
    output = []

    # Add timestamp
    now = datetime.now().strftime('%Y-%m-%d')
    output.append(f'<!-- Generated: {now} -->')
    output.append('')

    # Process content
    in_action_items = False
    for line in lines:
        # Detect action items section
        if line.startswith('## Action Items') or line.startswith('### Action Items'):
            in_action_items = True
            output.append(line)
            continue

        # End of action items section
        if in_action_items and line.startswith('#'):
            in_action_items = False

        # Convert action items to checkboxes
        if in_action_items and line.strip().startswith('-'):
            # Convert "- Task" to "- [ ] Task"
            formatted = re.sub(r'^(\s*)-\s+', r'\1- [ ] ', line)
            output.append(formatted)
        else:
            output.append(line)

    return '\n'.join(output)

def main():
    """Read from stdin, format, write to stdout."""
    content = sys.stdin.read()
    formatted = format_report(content)
    print(formatted)

if __name__ == '__main__':
    main()

Make it executable:

chmod +x ~/.claude/skills/trip-report/scripts/format-report.py

Test the Skill

Try it out:

/trip-report I attended DevConf 2025 in Boston from April 15-17. Sessions: "Observability at Scale" by Jane Doe (key takeaway: use OpenTelemetry), "Kubernetes Security" by John Smith (takeaway: Pod Security Standards are critical). Overall: excellent technical depth, recommend for platform engineers.

Claude should generate a structured report and format it via the Python script.

Creating the conference-toolkit Marketplace

Now we’ll package all three skills into a marketplace.

Create Directory Structure

mkdir -p ~/conference-toolkit/plugins/conference-toolkit/.claude-plugin
mkdir -p ~/conference-toolkit/plugins/conference-toolkit/skills

Create marketplace.json

Create ~/conference-toolkit/marketplace.json:

{
  "name": "conference-toolkit-marketplace",
  "owner": {
    "name": "Your Name"
  },
  "plugins": [
    {
      "name": "conference-toolkit",
      "source": "./plugins/conference-toolkit",
      "description": "Skills for conference speakers: abstract writing, conference discovery, and trip reports"
    }
  ]
}

Create plugin.json

Create ~/conference-toolkit/plugins/conference-toolkit/.claude-plugin/plugin.json:

{
  "name": "conference-toolkit",
  "description": "A toolkit for conference speakers: write abstracts, discover conferences, generate trip reports",
  "version": "1.0.0",
  "author": "Your Name",
  "repository": "https://github.com/your-username/conference-toolkit"
}

Copy Skills

cp -r ~/.claude/skills/abstract-writer ~/conference-toolkit/plugins/conference-toolkit/skills/
cp -r ~/.claude/skills/conf-finder ~/conference-toolkit/plugins/conference-toolkit/skills/
cp -r ~/.claude/skills/trip-report ~/conference-toolkit/plugins/conference-toolkit/skills/

Initialize Git Repository

cd ~/conference-toolkit
git init
git add -A
git commit -m "Initial conference-toolkit marketplace"

Push to GitHub

If you have the gh CLI:

gh repo create conference-toolkit --public --source=. --remote=origin --push

Or manually:

  1. Create a new repository on GitHub named conference-toolkit

  2. Add the remote and push:

git remote add origin https://github.com/your-username/conference-toolkit.git
git branch -M main
git push -u origin main

Your marketplace is now live at https://github.com/your-username/conference-toolkit.

Installing and Verifying

Let’s install the plugin from your marketplace and verify namespaced access.

Remove Local Skills

First, remove the loose skills from ~/.claude/skills/:

rm -rf ~/.claude/skills/abstract-writer
rm -rf ~/.claude/skills/conf-finder
rm -rf ~/.claude/skills/trip-report

Add the Marketplace

For testing with the local path:

claude plugin marketplace add ~/conference-toolkit

Or from GitHub (recommended):

claude plugin marketplace add your-username/conference-toolkit

Install the Plugin

claude plugin install conference-toolkit@conference-toolkit-marketplace

This installs the conference-toolkit plugin from the conference-toolkit-marketplace.

Verify Namespaced Access

Skills are now namespaced. Try:

/conference-toolkit:abstract-writer Write an abstract about observability for KubeCon
/conference-toolkit:conf-finder Find upcoming Kubernetes conferences
/conference-toolkit:trip-report Generate a report for KubeCon EU 2025

The conference-toolkit: prefix disambiguates these skills from any others with similar names.

Distribution and Scope

Installation Scopes

Claude Code supports three installation scopes:

--scope user (default)

Installs to ~/.claude/ — available in all Claude Code sessions for your user account.

--scope project

Writes marketplace and plugin configuration to .claude/settings.json in the current repository. When teammates clone the repo and run Claude Code, they automatically get the plugin.

--scope local

Installs only for the current working directory, not persisted.

To install project-scoped:

claude plugin marketplace add your-username/conference-toolkit --scope project
claude plugin install conference-toolkit@conference-toolkit-marketplace --scope project

Now .claude/settings.json contains:

{
  "marketplaces": [
    "your-username/conference-toolkit"
  ],
  "plugins": [
    "conference-toolkit@conference-toolkit-marketplace"
  ]
}

Teammates who pull this repository and run Claude Code will automatically have access to /conference-toolkit:* skills.

Versioning

The version field in plugin.json controls updates. Claude Code only updates installed plugins when you bump the version and users run:

claude plugin update conference-toolkit

This allows you to push non-breaking changes without forcing updates.

Skill Evolution and Evaluation

An open question: how do you evaluate whether your skills are working as intended? As skills evolve, how do you prevent regressions?

Some approaches:

  • Manual testing: Invoke skills with known prompts and review outputs

  • Example-driven: Maintain a examples/ directory with test prompts and expected outputs

  • Automated testing: Write scripts that invoke skills via claude CLI and check outputs

There’s no definitive answer yet — skill evaluation is an emerging practice. The key is to establish feedback loops: use your skills regularly, observe where they fall short, and iterate.

Summary

You’ve built a complete marketplace with three skills bundled into a plugin:

  • conf-finder discovers relevant conferences (generated with skill-creator)

  • trip-report generates structured post-conference reports (with executable scripts)

  • abstract-writer from Module 3

  • All three packaged as conference-toolkit plugin

  • Distributed via GitHub as a marketplace

  • Installed with namespace isolation: /conference-toolkit:skill-name

Next, we’ll use your marketplace alongside two other skill layers — superpowers and beads — in a real-world workflow.