What Functionality Can Be Extended With Plugins in dotnet/skills

The dotnet/skills repository supports a plugin architecture that allows developers to extend AI-driven development capabilities by adding markdown-based skills, workflow agents, LSP/MCP servers, and metadata descriptors to cover any .NET-related development concern.

The dotnet/skills repository provides a flexible plugin system designed to enrich the AI-driven skill ecosystem for .NET developers. By leveraging this architecture, you can introduce new capabilities ranging from MSBuild diagnostics to Docker containerization without modifying core code. Understanding what functionality can be extended with plugins in dotnet/skills enables teams to tailor the AI assistant to specific development workflows and tooling requirements.

Understanding the Plugin Architecture

The architecture revolves around self-contained packages that contribute specific artifacts to the runtime. Each plugin resides in its own directory under the plugins/ folder and is discovered automatically by the skill-validator based on its plugin.json configuration.

The Four Extensible Artifacts

Skills – Markdown Knowledge Units

Skills are markdown-based knowledge units that describe concrete programming tasks and drive the LLM to generate or diagnose code. These files use the .SKILL.md extension and reside in the skills/ subdirectory.

In plugins/dotnet-msbuild/skills/target-authoring/SKILL.md, you can see a fully-fledged skill definition that teaches the model custom MSBuild target patterns. The skill-validator loads these automatically when pointed to by a plugin manifest.

Agents – Workflow Orchestration

Agents are markdown files that prescribe multi-step reasoning or code-generation workflows. They enable the model to act as a planner, executor, and validator for complex tasks that require coordination across multiple skills.

The plugins/dotnet-msbuild/agents/build-perf.agent.md file demonstrates an agent that orchestrates a multi-step performance-diagnosis workflow, breaking down build optimization into discrete, verifiable steps.

LSP and MCP Servers – IDE Integration

Plugins can expose functionality as Language Server Protocol (LSP) endpoints or Microsoft Code-Platform (MCP) services. This enables IDE integration, incremental evaluation, or remote execution of skills.

The plugins/dotnet/plugin.json references lspServers for editor integration, while plugins/dotnet-msbuild/plugin.json defines an MCP server specifically for binlog processing, allowing the skill to interact with build logs as a service.

Plugin Metadata – Configuration and Discovery

The plugin.json file describes the plugin name, version, description, and relative paths to its assets. The skill-validator discovers and registers the plugin at runtime based on this metadata.

Every plugin folder contains this manifest, such as plugins/dotnet-test/plugin.json, which illustrates the pattern for packaging a large group of testing-related skills.

Categories of Functionality You Can Extend

The repository currently demonstrates plugins covering diverse .NET development concerns:

• Build & MSBuild – Performance diagnostics, server activation, custom target authoring, and incremental-build tuning (dotnet-msbuild plugin).

• Testing – MSTest authoring, test-smell detection, test-gap analysis, and test-tagging (dotnet-test plugin).

• ASP.NET – Minimal-API uploads, full WebAPI scaffolding, and OpenTelemetry configuration (dotnet-aspnet plugin).

• Diagnostics – Micro-benchmarking, dump collection, trace collection, and CLR activation debugging (dotnet-diag plugin).

• Data Access – EF Core query optimization (dotnet-data plugin).

• MAUI – Theming, navigation, and safe-area handling (dotnet-maui plugin).

• AI / MCP – Technology selection and C# test creation via MCP platforms (dotnet-ai plugin).

• Upgrade & Migration – Framework version migrations and language-feature upgrades (dotnet-upgrade plugin).

• Package Management – NuGet dependency modernization (dotnet-nuget plugin).

How to Create a Plugin Extension

To add new functionality, create a new plugin directory with a plugin.json manifest and one or more skill definitions. The skill-validator automatically picks up the plugin without code changes.

Here is a minimal plugin skeleton for adding a Dockerfile generation skill:

my-plugin/
├── plugin.json
└── skills/
    └── docker-file/SKILL.md

The plugin.json configuration declares the plugin metadata and asset paths:

{
  "name": "dotnet-docker",
  "version": "0.1.0",
  "description": "Skills for generating Dockerfiles for .NET container images.",
  "skills": ["./skills/"]
}

The skill definition at skills/docker-file/SKILL.md follows the repository's markdown schema:

---
name: docker-file
description: "Generate an optimal Dockerfile for a .NET app (runtime-only, multi-stage, or self-contained)."
license: MIT
---

# Dockerfile Generation

## When to Use

- You need a Dockerfile for a .NET console or web app.
- You want to minimise image size or enable multi-stage builds.

## Workflow

1️⃣ Detect the target framework (net6.0, net8.0, …).  
2️⃣ Choose a base image (`mcr.microsoft.com/dotnet/aspnet:8.0` or `sdk:8.0`).  
3️⃣ Emit a multi-stage Dockerfile that copies the `*.csproj`, runs `dotnet restore`, builds, and then copies the publish output.

```dockerfile
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY *.csproj .
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "MyApp.dll"]

## Summary

- **Skills**, **agents**, **LSP/MCP servers**, and **metadata** constitute the four extensible artifacts in the dotnet/skills plugin architecture.
- You can extend functionality covering any .NET development concern, including build systems, testing frameworks, diagnostics, and containerization.
- Each plugin requires a [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) manifest and markdown-based skill definitions in specific directory structures.
- The skill-validator automatically discovers and registers plugins at runtime, enabling zero-code integration of new capabilities.

## Frequently Asked Questions

### What file format defines a skill in dotnet/skills?

Skills are defined in markdown files with the [`.SKILL.md`](https://github.com/dotnet/skills/blob/main/.SKILL.md) extension, following a structured schema that includes frontmatter metadata and workflow descriptions. These files reside in the `skills/` subdirectory of a plugin folder, as demonstrated in [`plugins/dotnet-msbuild/skills/target-authoring/SKILL.md`](https://github.com/dotnet/skills/blob/main/plugins/dotnet-msbuild/skills/target-authoring/SKILL.md).

### How does the skill-validator discover new plugins?

The skill-validator scans the `plugins/` directory and loads any folder containing a valid [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) file. This JSON manifest specifies the plugin name, version, and relative paths to skills, agents, and server definitions, enabling automatic registration at runtime without code changes.

### Can plugins integrate with VS Code or Visual Studio?

Yes, plugins can expose **LSP (Language Server Protocol)** endpoints or **MCP (Microsoft Code-Platform)** services by declaring server configurations in [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json). For example, [`plugins/dotnet/plugin.json`](https://github.com/dotnet/skills/blob/main/plugins/dotnet/plugin.json) references `lspServers`, while [`plugins/dotnet-msbuild/plugin.json`](https://github.com/dotnet/skills/blob/main/plugins/dotnet-msbuild/plugin.json) defines an MCP server for binlog processing, enabling IDE integration.

### What types of development workflows can I automate with agents?

Agents automate multi-step reasoning workflows such as performance diagnosis, code generation pipelines, and validation sequences. Defined in [`.agent.md`](https://github.com/dotnet/skills/blob/main/.agent.md) files like [`plugins/dotnet-msbuild/agents/build-perf.agent.md`](https://github.com/dotnet/skills/blob/main/plugins/dotnet-msbuild/agents/build-perf.agent.md), they orchestrate complex tasks that require planning, execution, and verification steps.

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