# What Is the plugins Directory in dotnet/skills?

> Discover the purpose of the plugins directory in dotnet/skills. Learn how it centralizes AI-driven skills, metadata, and execution logic for the .NET Agent Skills ecosystem.

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

---

**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`](https://github.com/dotnet/skills/blob/main/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)](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`](https://github.com/dotnet/skills/blob/main/.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`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/README.md):

```bash

# 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`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/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:

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

```

### Installing a Specific Skill

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

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

```csharp
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`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/.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`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/plugin.json) manifest at that location to discover the plugin's skills and validation rules, as documented in [`eng/skill-validator/src/README.md`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/README.md).

### Can I install a single skill without the entire plugin?

Yes. While the [`plugin.json`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/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.