What Is the plugins Directory in dotnet/skills?

The plugins directory serves as the central distribution point for the .NET Agent Skills ecosystem, where each sub-directory represents a self-contained plugin package containing related AI-driven skills, metadata manifests, and execution logic.

The dotnet/skills repository hosts the official .NET Agent Skills library, and the plugins directory forms its organizational backbone. This folder encapsulates modular, domain-specific capabilities that power AI agents across the .NET toolchain.

Core Architecture of the plugins Directory

The plugins folder is the foundation of the .NET Agent Skills architecture. Every sub-directory within plugins/ constitutes a plugin—a standalone package grouping related skills (discrete, reusable AI actions) and optional agent configurations that operate on those skills.

Domain-Based Modular Organization

The repository organizes capabilities by functional domain to enforce clean separation of concerns. Sub-directories like dotnet, dotnet-test, and dotnet-upgrade each isolate specific workflows, allowing users to install or update precise capabilities without importing unrelated code. This structure enables both human discovery via the repository README and automated tooling traversal.

The plugin.json Metadata Standard

Every plugin ships a mandatory plugin.json manifest file declaring the package’s metadata. Located at plugins/<plugin-name>/plugin.json, this file specifies the plugin’s name, version, description, and skill definition paths. For example, the core plugin manifest resides at [plugins/dotnet/plugin.json](https://github.com/dotnet/skills/blob/main/plugins/dotnet/plugin.json).

Tooling such as the skill-validator, skill-installer, and Copilot/Claude agents consume this manifest to locate and load appropriate skills. The validator specifically references these manifests when executing validation commands against the repository.

Tooling Integration and Skill Execution

The plugins directory functions as the discovery root for automation tooling and IDE marketplaces. Client applications resolve skill paths relative to this directory structure.

Skill Validation Workflow

The continuous integration pipeline defined in .github/workflows/skill-validator.yml executes the validator against every plugin in the repository. Developers can run localized validation using the CLI documented in eng/skill-validator/src/README.md:

# Validate a specific plugin's structure and metadata

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

# Execute skill tests against a specific plugin's skills

skill-validator evaluate \
    --tests-dir ./tests/dotnet-test/run-tests \
    ./plugins/dotnet-test/skills/run-tests

These commands parse the plugin.json manifest and verify that all referenced skills in the skills/ subdirectories conform to the expected schema.

Marketplace Distribution

The repository publishes as both a Cursor and GitHub Copilot marketplace. When developers execute installation commands like /plugin install dotnet@dotnet-agent-skills, the client fetches the corresponding sub-directory under plugins/ and registers its skills for IDE integration. This distribution model treats each plugins/<name> path as an atomic, versioned package.

Directory Structure and Key Files

Understanding the file hierarchy within plugins/ clarifies how the system resolves dependencies and executes skills.

Plugin Manifests

Each plugin root contains a plugin.json file that acts as the machine-readable contract. As implemented in the dotnet/skills source, this manifest enables the skill-installer to resolve dependencies without scanning the entire repository.

Skill Definitions

Individual skills reside at plugins/<plugin>/skills/<skill-name>/SKILL.md. For instance, the NuGet trusted publishing skill is defined at plugins/dotnet/skills/nuget-trusted-publishing/SKILL.md. These markdown files contain the prompt logic and execution parameters that AI agents interpret.

Practical Usage Examples

The following patterns demonstrate how to interact with the plugins directory structure programmatically and via CLI.

Validating Plugin Integrity

To verify a plugin's configuration against the repository standards:

skill-validator check --plugin ./plugins/dotnet-upgrade

Installing a Specific Skill

Target a single skill without downloading the entire repository using the skill-installer:

skill-installer install \
    https://github.com/dotnet/skills/tree/main/plugins/dotnet/skills/nuget-trusted-publishing

This command resolves the skill from its path within the plugins directory and installs it to the local agent environment.

Programmatic Manifest Loading

Load and inspect a plugin manifest using C#:

using System.Text.Json;
using System.IO;

var manifestPath = Path.Combine(
    Environment.CurrentDirectory, "plugins", "dotnet", "plugin.json");
var json = File.ReadAllText(manifestPath);
var plugin = JsonSerializer.Deserialize<PluginManifest>(json);

Console.WriteLine($"Loaded plugin: {plugin.Name} ({plugin.Version})");

// PluginManifest structure mirrors plugin.json fields:
// public string Name { get; set; }
// public string Version { get; set; }
// public string Description { get; set; }
// public string[] Skills { get; set; }

Summary

• The plugins directory is the distribution point for the entire .NET Agent Skills library, with each sub-directory representing an installable plugin package.
• Modular organization by domain (e.g., dotnet-test, dotnet-upgrade) enables precise capability management without code bloat.
• Every plugin requires a plugin.json manifest at its root to declare metadata and skill locations for machine consumption.
• Tooling such as skill-validator and the Copilot CLI use the plugins path structure to validate, install, and execute skills.
• The repository’s CI pipeline (.github/workflows/skill-validator.yml) automatically validates all plugins against the schema defined in the manifest files.

Frequently Asked Questions

What is the difference between a plugin and a skill in dotnet/skills?

A plugin is a container directory under plugins/ that groups related capabilities, while a skill is a discrete AI action defined within that plugin. The plugin provides the organizational structure and plugin.json manifest, whereas individual skills reside in skills/<name>/SKILL.md files and contain the specific execution logic for agents.

How does the skill-validator locate plugins to check?

The validator accepts an explicit path via the --plugin flag (e.g., skill-validator check --plugin ./plugins/dotnet). It reads the plugin.json manifest at that location to discover the plugin's skills and validation rules, as documented in eng/skill-validator/src/README.md.

Can I install a single skill without the entire plugin?

Yes. While the plugin.json manifest defines the complete skill set, the skill-installer CLI supports targeting individual skill URLs within the plugins directory structure. This allows granular installation of specific capabilities without importing the full plugin contents.

What information does the plugin.json file contain?

The plugin.json file contains the plugin's name, version, description, and references to its skill definitions. This metadata serves as the machine-readable contract consumed by the skill-validator, marketplace clients, and agent runtime environments to properly load and execute skills.

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