How to Build the Source Code for dotnet/skills: A Complete Guide

To build the dotnet/skills source code, install the .NET 11 preview SDK specified in global.json, run dotnet restore, then execute dotnet build --no-incremental to compile all plugins, and finally build the skill-validator tool from eng/skill-validator/src/SkillValidator.csproj.

The dotnet/skills repository is a collection of plugins containing reusable skills and agents for .NET-centric coding assistants. Unlike traditional applications that produce a single binary, this repository contains multiple C# class-library projects that must be built individually. This guide walks through the complete build process using the .NET SDK and the repository's specific requirements.

Prerequisites and SDK Setup

The repository pins a specific preview SDK version in global.json to ensure compatibility with the latest C# language features used by the skills.

dotnet --info

The global.json file specifies version 11.0.100-preview.3.26207.106. If you do not have this SDK installed, the .NET CLI will automatically download and use the required preview version when you run commands inside the repository directory.

Full Repository Build

The standard build process compiles all plugin projects under the plugins/ directory. Because many skills require a fresh baseline for reliable operation, you must use the --no-incremental flag.

First, restore NuGet packages for all projects:

dotnet restore

Then perform a clean build:

dotnet clean
dotnet build --no-incremental

This command compiles every .csproj file under plugins/, including class libraries for skills like dotnet-msbuild and dotnet-upgrade. The --no-incremental flag guarantees a clean compilation state, which is required by many skill validation workflows.

Building the Skill-Validator Tool

The skill-validator is the only runnable console application in the repository. Located at eng/skill-validator/src/SkillValidator.csproj, this tool validates that skills behave correctly against test fixtures.

Build the validator in Release configuration:

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

This produces the skill-validator binary (or an AOT-compiled archive) that you can use to execute tests and validate plugin behavior.

Testing Your Build

After compilation, verify the build by running the skill-validator against the test suites defined in tests/. Each skill includes an eval.yaml file (e.g., tests/dotnet-msbuild/msbuild-server/eval.yaml) that defines test scenarios.

Run the validator against all tests:

dotnet run --project eng/skill-validator/src/SkillValidator.csproj \
    evaluate --tests-dir tests \
    --plugins-dir plugins \
    --runs 1

The validator automatically invokes dotnet build on any fixtures required by the test scenarios. For statistical confidence, increase the --runs parameter (e.g., --runs 3 or --runs 5).

Building Individual Plugins

If you only need to modify a specific skill, you can target individual plugin directories rather than building the entire repository.

Build only the dotnet-msbuild plugin:

dotnet build plugins/dotnet-msbuild/ -c Release

Each plugin follows a consistent layout containing plugin.json, skills/, and optional agents/ directories. The build process does not require additional tooling beyond the .NET SDK.

Summary

• Install the .NET 11 preview SDK automatically via global.json.
• Restore packages with dotnet restore before building.
• Compile all plugins using dotnet build --no-incremental for a clean baseline.
• Build the validator tool separately from eng/skill-validator/src/SkillValidator.csproj.
• Run tests using skill-validator evaluate against the tests/ directory to verify functionality.

Frequently Asked Questions

What .NET SDK version do I need to build dotnet/skills?

You need the .NET 11 preview SDK version 11.0.100-preview.3.26207.106, as specified in global.json. If you have a different version installed, the .NET CLI will automatically download the required preview SDK when you run build commands inside the repository.

Why does the build require the --no-incremental flag?

Many skills in the repository require a fresh compilation baseline to ensure deterministic behavior during validation. The --no-incremental flag forces the compiler to ignore previous build artifacts, which is necessary for the skill-validator tool to accurately assess skill behavior against test fixtures.

How do I run tests for specific skills?

Target the specific test directory containing the eval.yaml file:

skill-validator evaluate \
    --tests-dir tests/dotnet-upgrade/migrate-nullable-references \
    --runs 5 \
    plugins/dotnet-upgrade/skills/migrate-nullable-references

This executes only the specified skill's test suite with five runs for statistical confidence.

Can I build individual plugins without compiling the entire repository?

Yes. Navigate to any plugin directory (e.g., plugins/dotnet-msbuild/) and run dotnet build on that specific folder. Each plugin is a standalone C# class library that compiles independently, though you must still have the SDK version specified in the root global.json file.

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