# How to Package and Deploy dotnet/skills Plugins: A Complete Guide

> Learn to package and deploy dotnet/skills plugins. Follow our guide to create a plugin manifest, register it, and distribute it via the Agent-Skills marketplace or as a NuGet package.

- Repository: [.NET Platform/skills](https://github.com/dotnet/skills)
- Tags: how-to-guide
- Published: 2026-05-22

---

**To package and deploy dotnet/skills plugins, create a directory containing a [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) manifest and skill definitions, register the plugin in [`.github/plugin/marketplace.json`](https://github.com/dotnet/skills/blob/main/.github/plugin/marketplace.json), and distribute it via the Agent-Skills marketplace or as a RID-specific NuGet package.**

The **dotnet/skills** repository hosts agent-skills plugins under the `plugins/` folder that extend AI coding assistants with specialized capabilities. Understanding how to package and deploy dotnet/skills plugins allows you to create self-contained units that clients like Copilot CLI, Claude Code, and Cursor can discover and execute. This guide covers the mandatory directory structure, marketplace registration, and build workflows required for distribution.

## Plugin Structure and Configuration

Every plugin must follow a standardized directory layout and include a mandatory configuration file to be recognized by the Agent-Skills ecosystem.

### Directory Layout

Create a dedicated folder under `plugins/` with the following structure:

```text
plugins/
└── my-plugin/
    ├── plugin.json          # mandatory manifest

    ├── skills/              # one folder per skill (SKILL.md + tests)

    └── agents/              # optional custom agents

```

Each skill directory inside `skills/` must contain a [`SKILL.md`](https://github.com/dotnet/skills/blob/main/SKILL.md) file defining the skill and associated test files.

### The plugin.json Manifest

The [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) file declares metadata and entry points. As defined in [`plugins/dotnet/plugin.json`](https://github.com/dotnet/skills/blob/main/plugins/dotnet/plugin.json), you must specify at least the following fields:

```json
{
  "name": "my-plugin",
  "version": "0.1.0",
  "description": "A short description of what the plugin does.",
  "skills": ["./skills/"],
  "lspServers": "./lsp.json"
}

```

Required fields include **name**, **version**, **description**, and **skills** (relative path to skill directories). The `lspServers` field is optional but recommended for Language Server Protocol integration.

## Marketplace Registration

To make your plugin discoverable by clients, you must register it in the repository's marketplace manifest.

### Updating the Central Manifest

Edit [`.github/plugin/marketplace.json`](https://github.com/dotnet/skills/blob/main/.github/plugin/marketplace.json) and add a new entry to the `plugins` array:

```json
{
  "name": "my-plugin",
  "source": "./plugins/my-plugin",
  "description": "A short description of what the plugin does."
}

```

For Cursor-specific distribution, use [`.cursor-plugin/marketplace.json`](https://github.com/dotnet/skills/blob/main/.cursor-plugin/marketplace.json) instead. Commit and push to `main`; the CI pipeline validates the manifest schema, and upon successful validation, the plugin becomes resolvable as `dotnet/<plugin>` in compatible clients.

## Build and Distribution Formats

While most consumers install plugins directly from GitHub via the marketplace mechanism, you can distribute compiled artifacts for offline or CI-specific use cases.

### RID-Specific NuGet Packages

The repository builds platform-specific NuGet packages for the `skill-validator` tool. As implemented in [`.github/workflows/skill-validator.yml`](https://github.com/dotnet/skills/blob/main/.github/workflows/skill-validator.yml), the workflow performs:

1. **`dotnet pack`** to create a RID-specific NuGet package (e.g., `Microsoft.DotNet.SkillValidator.linux-x64.nupkg`)
2. **`tar -czf`** to generate `skill-validator-<rid>.tar.gz` archives
3. Upload to GitHub Releases under the `skill-validator-nightly` tag

Follow this pattern to package your own plugin as a NuGet by adding a `.csproj` that includes the plugin directory contents and executing `dotnet pack` with runtime identifiers.

### Direct GitHub Checkout

For local development or private plugins, clients can consume plugins directly from a GitHub checkout without marketplace registration by symlinking the plugin directory.

## Installation Methods

Once packaged and registered, users can install your plugin through multiple channels depending on their client environment.

### Copilot CLI and Claude Code

Add the marketplace and install the plugin:

```bash

# Add the dotnet/skills marketplace (once per machine)

/plugin marketplace add dotnet/skills

# Install the specific plugin

plugin install my-plugin@dotnet-agent-skills

# Restart the CLI to load the plugin

```

### Cursor IDE

1. Open **Marketplace** → **Search**
2. Type the plugin name (e.g., `.NET` or `my-plugin`)
3. Click **Install**

Cursor reads from [`.cursor-plugin/marketplace.json`](https://github.com/dotnet/skills/blob/main/.cursor-plugin/marketplace.json) to resolve plugin locations.

### Local Development Setup

For testing unpublished changes without marketplace registration:

```bash

# Clone the repository

git clone https://github.com/dotnet/skills.git
cd skills

# Symlink the plugin into the client's local plugins folder

ln -s $(pwd)/plugins/my-plugin ~/.cursor/plugins/local/dotnet-agent-skills/my-plugin

```

Restart the client to load the symlinked plugin.

## Validation with skill-validator

Before deploying, validate your plugin against the Agent-Skills schema using the `skill-validator` tool.

### Static Analysis Check

Run the following command from the repository root:

```bash
skill-validator check --plugin ./plugins/my-plugin

```

This validates:
- Presence and schema of [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json)
- Correct formatting of each [`SKILL.md`](https://github.com/dotnet/skills/blob/main/SKILL.md) file
- No orphaned skill directories without documentation

*Reference*: Detailed command options are documented in [`eng/skill-validator/src/README.md`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/README.md).

## Summary

- **Package and deploy dotnet/skills plugins** by creating a directory with [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json), skill definitions, and registering in [`.github/plugin/marketplace.json`](https://github.com/dotnet/skills/blob/main/.github/plugin/marketplace.json).
- The [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) manifest must declare the plugin **name**, **version**, **description**, and **skills** array pointing to relative paths.
- Marketplace registration enables discovery across Copilot CLI, Claude Code, and Cursor, with Cursor specifically reading [`.cursor-plugin/marketplace.json`](https://github.com/dotnet/skills/blob/main/.cursor-plugin/marketplace.json).
- For distribution, the CI workflow in [`.github/workflows/skill-validator.yml`](https://github.com/dotnet/skills/blob/main/.github/workflows/skill-validator.yml) builds RID-specific NuGet packages like `Microsoft.DotNet.SkillValidator.linux-x64.nupkg` and tar.gz archives.
- Validate plugins before deployment using `skill-validator check --plugin ./plugins/<name>` to ensure schema compliance.

## Frequently Asked Questions

### What fields are required in plugin.json?

The [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) manifest requires four mandatory fields: **name** (unique identifier), **version** (semver), **description** (human-readable summary), and **skills** (array of relative paths to skill directories). You may optionally include **lspServers** to configure Language Server Protocol integration.

### How do I install a plugin from the dotnet/skills repository?

Add the marketplace once with `/plugin marketplace add dotnet/skills`, then install specific plugins using `plugin install <name>@dotnet-agent-skills`. For Cursor IDE, search the Marketplace UI after the repository has indexed the plugin manifest from [`.cursor-plugin/marketplace.json`](https://github.com/dotnet/skills/blob/main/.cursor-plugin/marketplace.json).

### Can I distribute dotnet/skills plugins as NuGet packages?

Yes. While the standard distribution uses GitHub-based marketplace resolution, you can package plugins as RID-specific NuGet packages following the pattern in [`.github/workflows/skill-validator.yml`](https://github.com/dotnet/skills/blob/main/.github/workflows/skill-validator.yml). This approach uses `dotnet pack` with runtime identifiers and publishes artifacts to GitHub Releases under tags like `skill-validator-nightly`.

### How do I validate my plugin before submitting to the marketplace?

Run `skill-validator check --plugin ./plugins/<your-plugin>` to perform static analysis. This command verifies that [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) exists and is valid, that each skill directory contains a properly formatted [`SKILL.md`](https://github.com/dotnet/skills/blob/main/SKILL.md), and that no orphaned directories remain unmapped according to the schema defined in the repository.