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

To package and deploy dotnet/skills plugins, create a directory containing a plugin.json manifest and skill definitions, register the plugin in .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:

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 file defining the skill and associated test files.

The plugin.json Manifest

The plugin.json file declares metadata and entry points. As defined in plugins/dotnet/plugin.json, you must specify at least the following fields:

{
  "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 and add a new entry to the plugins array:

{
  "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 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, 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:

# 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 to resolve plugin locations.

Local Development Setup

For testing unpublished changes without marketplace registration:

# 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:

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

This validates:

• Presence and schema of plugin.json
• Correct formatting of each SKILL.md file
• No orphaned skill directories without documentation

Reference: Detailed command options are documented in eng/skill-validator/src/README.md.

Summary

• Package and deploy dotnet/skills plugins by creating a directory with plugin.json, skill definitions, and registering in .github/plugin/marketplace.json.
• The 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.
• For distribution, the CI workflow in .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 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.

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. 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 exists and is valid, that each skill directory contains a properly formatted SKILL.md, and that no orphaned directories remain unmapped according to the schema defined in the repository.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}