Build Process for Plugins in dotnet/skills: A Complete Guide

Plugins in the dotnet/skills repository require no compilation; they are markdown-based skill definitions validated by a single .NET tool during CI.

The build process for plugins in dotnet/skills differs fundamentally from traditional compiled extensions. Instead of producing binaries, this repository treats plugins as pure data assets—collections of markdown files and JSON descriptors that agent tools consume at runtime. The entire workflow centers on validation rather than compilation, ensuring every skill definition conforms to the Agents Skills schema before deployment.

How the Plugin Build Process Works

Unlike conventional .NET projects that require dotnet build for every component, the dotnet/skills repository only compiles its validation tooling. The build workflow consists of three distinct phases executed during continuous integration.

Step 1 – Compile the Skill Validator

The only compiled artifact in the repository is the skill-validator, located at eng/skill-validator/src/SkillValidator.csproj. This standard .NET project builds with the conventional SDK command:

dotnet build ./eng/skill-validator/src/SkillValidator.csproj

The validator serves as a schema checker and quality gate. It does not generate plugin code; instead, it inspects the markdown files that constitute each plugin's functionality.

Step 2 – Validate Plugin Definitions

After building the validator, CI executes it against every plugin directory to verify structural integrity. The tool parses each SKILL.md file to ensure:

• Valid front-matter containing required metadata fields
• Required fields such as name, description, inputs, and outputs
• Existing references to any helper scripts or commands mentioned in the skill definition

Run validation locally using:

dotnet run --project ./eng/skill-validator/src/SkillValidator.csproj \
    validate --plugins ./plugins

Step 3 – Publish Plugin Assets

Upon successful validation, the build pipeline copies the markdown files and descriptors to the distribution folder. No packaging binaries are generated. The "build" artifacts consist of the raw SKILL.md files, plugin.json descriptors, and any supporting scripts organized under their respective plugins/ subdirectories.

Understanding the Plugin Structure

Because plugins are interpreted at runtime by tools like Copilot CLI, Claude Code, or Cursor, they follow a documentation-first architecture rather than a code-first approach.

SKILL.md Files (The Core Definition)

Each skill resides in a SKILL.md file containing YAML front-matter that defines the contract between the agent and the user. For example, plugins/dotnet-msbuild/skills/build/SKILL.md declares inputs and execution logic:

---
name: dotnet-build
description: Runs `dotnet build` on the target project
inputs:
  - name: project
    type: string
    required: true
---

The markdown body following the front-matter contains the actual implementation instructions that the LLM agent interprets.

Plugin Descriptors (plugin.json)

The plugin.json file (or README.md in some cases) acts as a manifest that tells agent tools which skills a plugin provides and how to expose them. For instance, plugins/dotnet-upgrade/plugin.json registers the plugin with the agent's skill registry without requiring any compilation step.

Local Development Workflow

Since plugins are pure data files, you can iterate without waiting for compilation. Modify a SKILL.md, add helper scripts if needed, and re-run the validator to check for schema compliance.

Install a plugin from the marketplace using the Copilot CLI:

/plugin marketplace add dotnet/skills
/plugin install dotnet-msbuild@dotnet-agent-skills

Key files you will interact with include:

• README.md – Repository overview listing available plugins and installation instructions
• eng/skill-validator/src/SkillValidator.csproj – The validation tool source
• plugins/dotnet-msbuild/README.md – Example plugin documentation showing the markdown-only structure

Summary

• No binary compilation is required for individual plugins in dotnet/skills.
• The skill-validator (eng/skill-validator/src/SkillValidator.csproj) is the only compiled component, built with standard dotnet build commands.
• Plugins consist of markdown-based skill definitions (SKILL.md) and JSON descriptors consumed at runtime by agent tools.
• The CI pipeline validates schema compliance and publishes raw markdown assets rather than packaged binaries.

Frequently Asked Questions

Do plugins in dotnet/skills require dotnet build?

No. Individual plugins do not require compilation. You only need to run dotnet build for the skill-validator tool itself. The plugins are markdown files that agent tools read and interpret at runtime without binary generation.

What validates the plugin definitions?

The eng/skill-validator/src/SkillValidator.csproj project contains the validation logic. Built as a standard .NET application, it checks every SKILL.md file for correct front-matter, required fields, and valid script references during the CI process.

Can I install a plugin without compiling it?

Yes. Plugins install directly from the repository into tools like Copilot CLI, Claude Code, or Cursor. Since they consist of markdown and JSON files, installation involves copying these data files rather than compiling or linking binaries.

What files are required to create a new plugin?

At minimum, you need a SKILL.md file containing the skill definition with proper YAML front-matter, and a descriptor file (plugin.json or README.md) that registers the plugin with agent tools. Optional helper scripts can accompany these files if the skill requires external command execution.

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