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

> Learn to build the dotnet/skills source code with our guide. Follow simple steps to restore, build plugins, and compile the skill-validator tool for your projects.

- Repository: [.NET Platform/skills](https://github.com/dotnet/skills)
- Tags: how-to-guide
- Published: 2026-07-08

---

**To build the dotnet/skills source code, install the .NET 11 preview SDK specified in [`global.json`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/global.json) to ensure compatibility with the latest C# language features used by the skills.

```bash
dotnet --info

```

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

```bash
dotnet restore

```

Then perform a clean build:

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

```bash
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`](https://github.com/dotnet/skills/blob/main/eval.yaml) file (e.g., [`tests/dotnet-msbuild/msbuild-server/eval.yaml`](https://github.com/dotnet/skills/blob/main/tests/dotnet-msbuild/msbuild-server/eval.yaml)) that defines test scenarios.

Run the validator against all tests:

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

```bash
dotnet build plugins/dotnet-msbuild/ -c Release

```

Each plugin follows a consistent layout containing [`plugin.json`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/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`](https://github.com/dotnet/skills/blob/main/eval.yaml) file:

```bash
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`](https://github.com/dotnet/skills/blob/main/global.json) file.