Plugin Marketplaces

Author Claude Code plugins in Moxn — git-versioned, published to GitHub, with a fast local dev loop

Moxn is a source of truth for AI coding-agent plugins. You author your skills, commands, and agents in Moxn — with the same branches, versioning, and collaboration you get for documents — then publish them to GitHub as an installable plugin marketplace. A local dev loop lets you iterate against your Moxn content in seconds, without publishing.

One published repo installs in all three harnesses: Claude Code (skills, commands, and agents — verified end-to-end), Codex (skills — see Installing in Codex), and Cursor (skills and agents — see Installing in Cursor). The authoring and dev-loop flows below are written for Claude Code.

The mental model

Three concepts, nested:

• Marketplace — a git-versioned Moxn workspace that holds one or more plugins. It maps to a single GitHub repository when you publish.
• Plugin — a bundle of components that a user installs as one unit (e.g. a localization plugin).
• Component — a single skill, command, or agent inside a plugin. Each is a Moxn document with a small frontmatter contract.

Component	What it is	Frontmatter
skill	A SKILL.md — instructions an agent loads on demand	name, description (both required), allowed-tools?
command	A slash command (/plugin:name)	description?, argument-hint?, allowed-tools? — the name is the filename
agent	A subagent definition	name, description (both required), tools?, model?

Two planes: publish vs. develop

The thing to internalize is that Moxn drives two separate paths, and they never touch each other:

• The publish plane (solid) is how content reaches users. You publish a marketplace, which projects its committed HEAD into the GitHub repo, one-way. Consumers /plugin install from that repo. This is a deliberate release step.
• The dev plane (dotted) is how you iterate. context marketplaces dev pulls a marketplace’s live branch content straight from Moxn into a local directory — no GitHub, no publish involved — and wires it into Claude Code, Codex or Cursor. This is the fast loop, covered in The dev loop.

Publish serves committed HEAD; the dev loop serves live working state (even uncommitted edits on the branch). That difference is intentional — publishing is a release, developing is a preview.

Where everything lives

Thing	Lives in	Notes
Your authored components	Moxn	Git-versioned; edit on main or a feature branch
The published plugin	GitHub	One repo per marketplace; only what you explicitly publish
Your local dev copy	Your machine (./.moxn/dev/<marketplace-slug>)	Materialized by marketplaces dev; never published
The installed plugin	~/.claude/plugins	What consumers run; pinned to a published commit

The lifecycle at a glance

1. Author

   Create a marketplace, add a plugin, and write your skills / commands / agents in Moxn. See Create & author.

2. Develop

   Iterate with the local dev loop — edit in Moxn, re-run marketplaces dev, /reload-plugins, test in your agent. See The dev loop.

3. Publish

   Connect a GitHub repo and publish your committed content to it. See Publish & install.

4. Install

   You (and your users) /plugin marketplace add the repo and /plugin install the plugin. See Publish & install.

Prerequisites

• The context CLI installed and authenticated — see CLI Quick Start.
• A Moxn account with a marketplace (or the ability to create one).
• Claude Code for installing and running plugins.