# How to Set Up a Local Development Environment for dotnet/skills: Step-by-Step Guide

> Set up a local dev environment for dotnet/skills with this step-by-step guide. Clone, install SDK, restore, build validator, and run tests to get started quickly.

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

---

**To set up a local development environment for dotnet/skills, clone the repository, install the .NET 6 SDK version pinned in [`global.json`](https://github.com/dotnet/skills/blob/main/global.json), run `dotnet restore`, build the validator project at `eng/skill-validator/src/skill-validator.csproj`, and execute the test suite to verify your installation.**

The **dotnet/skills** repository hosts a collection of "skill" plugins and a **skill-validator** engine that evaluates those plugins against real-world code scenarios. To contribute new skills or modify existing ones, you need a local environment that can compile the validator, parse plugin manifests, and run the extensive fixture-based tests. This guide covers the minimal, dependency-free setup using only the .NET SDK and repository scripts.

## Prerequisites and Repository Architecture

Before executing build commands, understand the three-layer architecture that determines how components interact during local development.

### The Three-Layer Architecture

The repository splits into three logical layers:

1. **Plugin Packages** – Each folder under `plugins/` contains a self-contained skill (e.g., `dotnet11`, `dotnet-msbuild`). These plugins expose a [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) manifest and a [`SKILL.md`](https://github.com/dotnet/skills/blob/main/SKILL.md) description that the validator consumes. For example, the `dotnet11` skill defines its capabilities in [`plugins/dotnet11/skills/system-text-json-net11/SKILL.md`](https://github.com/dotnet/skills/blob/main/plugins/dotnet11/skills/system-text-json-net11/SKILL.md).

2. **Skill-Validator Engine** – The core command-line tool lives in `eng/skill-validator/`. The entry point at [`eng/skill-validator/src/Program.cs`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/Program.cs) parses manifests, discovers external dependencies, and runs evaluation pipelines defined in the workflow files. The core orchestration logic resides in [`eng/skill-validator/src/Evaluate/EvaluateCommand.cs`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/Evaluate/EvaluateCommand.cs).

3. **Test Fixtures** – Integration tests and mock code bases live under `tests/`. These fixtures model scenarios like mock-usage-analysis and SIMD vectorization, allowing the validator to run realistic evaluations locally. An example fixture is located at [`tests/dotnet-experimental/exp-mock-usage-analysis/well-placed-mocks/AppointmentSchedulerTests.cs`](https://github.com/dotnet/skills/blob/main/tests/dotnet-experimental/exp-mock-usage-analysis/well-placed-mocks/AppointmentSchedulerTests.cs).

### SDK Version Requirements

The build system requires the .NET 6 SDK, with the specific version pinned in [`global.json`](https://github.com/dotnet/skills/blob/main/global.json) at the repository root. Using the exact version ensures compatibility with the CI pipelines defined in [`.github/workflows/skill-validator.yml`](https://github.com/dotnet/skills/blob/main/.github/workflows/skill-validator.yml) and the validator project itself.

## Step-by-Step Local Development Setup

Follow these six steps to configure your environment. These steps rely only on the .NET SDK and repository scripts, avoiding external services or secrets.

### Step 1: Clone the Repository

Download the source, workflows, and test data:

```bash
git clone https://github.com/dotnet/skills.git
cd skills

```

### Step 2: Install the .NET 6 SDK

Install the SDK version specified in [`global.json`](https://github.com/dotnet/skills/blob/main/global.json). For example, using the official install script:

```bash
curl -sSL https://dot.net/v1/dotnet-install.sh | bash -s -- --version 6.0.400

```

Alternatively, use your system's package manager, ensuring the version matches the [`global.json`](https://github.com/dotnet/skills/blob/main/global.json) specification.

### Step 3: Restore NuGet Packages

From the repository root, restore dependencies for both the plugins and the validator engine:

```bash
dotnet restore

```

### Step 4: Build the Skill-Validator Engine

Compile the command-line tool that drives evaluations:

```bash
dotnet build eng/skill-validator/src/skill-validator.csproj

```

This produces the validator executable that parses [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) manifests and executes evaluation pipelines.

### Step 5: Run the Test Suite

Execute the extensive fixture-based tests to confirm your local environment mirrors CI behavior:

```bash
dotnet test tests/

```

This command runs the integration tests located in directories like `tests/dotnet-experimental/`, validating that the validator correctly processes the test fixtures.

### Step 6: Validate a Single Skill Locally

Demonstrate the end-to-end flow by running the validator against a specific skill. This executes discovery, evaluation, and JSON result emission for a single plugin:

```bash
dotnet run --project eng/skill-validator/src/skill-validator.csproj -- evaluate --skill plugins/dotnet11

```

The validator reads the [`plugins/dotnet11/plugin.json`](https://github.com/dotnet/skills/blob/main/plugins/dotnet11/plugin.json) manifest, locates the skill description, and outputs evaluation results to standard output.

## Key Source Files for Troubleshooting

Understanding these files helps debug setup issues:

- **[`global.json`](https://github.com/dotnet/skills/blob/main/global.json)** – Pins the SDK version (e.g., 6.0.400) to ensure build consistency across environments.
- **[`eng/skill-validator/src/Program.cs`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/Program.cs)** – The CLI entry point that initializes the validator.
- **[`eng/skill-validator/src/Evaluate/EvaluateCommand.cs`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/Evaluate/EvaluateCommand.cs)** – Contains the core evaluation orchestration logic.
- **[`plugins/dotnet11/plugin.json`](https://github.com/dotnet/skills/blob/main/plugins/dotnet11/plugin.json)** – Example manifest showing how skills declare dependencies and entry points.
- **[`.github/workflows/skill-validator.yml`](https://github.com/dotnet/skills/blob/main/.github/workflows/skill-validator.yml)** – Reference for the CI pipeline that builds and runs the validator on every pull request.

## Summary

- **Clone** the dotnet/skills repository to access the plugin source, validator engine, and test fixtures.
- **Install** the .NET 6 SDK version specified in [`global.json`](https://github.com/dotnet/skills/blob/main/global.json) to match the build requirements.
- **Restore** all dependencies with `dotnet restore` before compiling any projects.
- **Build** the skill-validator using `dotnet build eng/skill-validator/src/skill-validator.csproj` to compile the evaluation engine.
- **Test** your setup by running `dotnet test tests/` to execute the fixture-based integration tests.
- **Validate** individual skills using the CLI to verify the end-to-end evaluation pipeline works locally.

## Frequently Asked Questions

### What version of the .NET SDK is required to build dotnet/skills locally?

The repository requires the .NET 6 SDK, with the specific version pinned in [`global.json`](https://github.com/dotnet/skills/blob/main/global.json) (typically 6.0.x). Using the exact version specified in this file ensures compatibility with the build scripts and the skill-validator project located in `eng/skill-validator/src/`.

### Can I run a single skill evaluation without executing the full test suite?

Yes. After building the validator, you can target a specific plugin by running `dotnet run --project eng/skill-validator/src/skill-validator.csproj -- evaluate --skill <path>`. This command executes the discovery and evaluation pipeline defined in [`eng/skill-validator/src/Evaluate/EvaluateCommand.cs`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/Evaluate/EvaluateCommand.cs) for that single skill without processing all test fixtures under `tests/`.

### Where does the skill-validator store evaluation results when running locally?

By default, the validator emits JSON results to standard output. The evaluation logic in [`eng/skill-validator/src/Evaluate/EvaluateCommand.cs`](https://github.com/dotnet/skills/blob/main/eng/skill-validator/src/Evaluate/EvaluateCommand.cs) processes the [`plugin.json`](https://github.com/dotnet/skills/blob/main/plugin.json) manifests and generates structured output that you can redirect to a file or pipe to downstream dashboards.

### Do I need external services or secrets to set up the local development environment?

No. The setup relies only on the .NET SDK and repository scripts. All dependencies are restored via NuGet, and the test fixtures under `tests/` (such as [`tests/dotnet-experimental/exp-mock-usage-analysis/well-placed-mocks/AppointmentSchedulerTests.cs`](https://github.com/dotnet/skills/blob/main/tests/dotnet-experimental/exp-mock-usage-analysis/well-placed-mocks/AppointmentSchedulerTests.cs)) provide mock data for evaluations, eliminating the need for external services or configuration secrets.