Dependencies for Developing Plugins in dotnet/skills: Complete Setup Guide

To develop plugins for dotnet/skills, you need the .NET SDK (version 6.0 or later), the dotnet CLI available on your system PATH, Git, and two global .NET tools: Microsoft.DotNet.SkillValidator and Microsoft.DotNet.SkillInstaller. Optional runtime services like MCP servers and LSP support are declared in individual plugin.json files and require no additional manual installation beyond the core SDK.

The dotnet/skills repository hosts a lightweight plugin architecture designed for AI-assisted development workflows. Before authoring custom skills or contributing to existing plugins, you must configure your local environment with specific SDK versions and validation tools. This guide covers the exact dependencies for developing plugins in dotnet/skills, from mandatory build tooling to optional language servers.

Core Prerequisites

.NET SDK and CLI

The foundation of plugin development is a .NET SDK version 6.0 or later (7.x is commonly used). The dotnet CLI must be available on your PATH to compile C# skill logic and execute repository-specific commands. The repository uses a global.json file to pin the exact SDK version, ensuring consistent builds across different development machines. Verify your installation by running:

dotnet --version

Git Source Control

Git is required for cloning the repository, managing plugin versions, and publishing updates via standard git push and git tag workflows.

Required Development Tools

Skill-Validator Tool

The Microsoft.DotNet.SkillValidator global tool performs static analysis and evaluation of plugin packages. It validates plugin.json schemas, checks skill definitions, and runs evaluation suites. Install it globally from the NuGet feed:

dotnet tool install Microsoft.DotNet.SkillValidator --global

Source code and detailed documentation reside in eng/skill-validator/src/README.md. Typical usage includes skill-validator check --plugin . to validate a plugin directory before submission.

Skill-Installer CLI

The Microsoft.DotNet.SkillInstaller tool simplifies local plugin installation and management. It handles the skill-installer install <url> workflow for testing plugins in your development environment. Install using:

dotnet tool install Microsoft.DotNet.SkillInstaller --global

Both tools are invoked via the dotnet CLI and are considered essential dependencies for the development workflow.

Optional Runtime Services

MCP Servers

Some plugins, such as dotnet-msbuild, ship with optional MCP (Model Context Protocol) servers. For example, the dotnet-msbuild plugin declares a binlog MCP server (AITools.BinlogMcp) in plugins/dotnet-msbuild/plugin.json. These servers run as helper executables pulled from DevOps NuGet feeds and start automatically when the plugin activates. No additional client-side installation is required if you have the .NET runtime.

Language Server Protocol (LSP) Support

The core dotnet plugin declares an LSP server in plugins/dotnet/plugin.json, enabling advanced editor features. The server launches via the dotnet lsp command and leverages built-in .NET LSP support. As with MCP servers, this requires only the standard .NET SDK and no separate downloads.

Installation and Verification Workflow

After installing the core SDK and global tools, verify your environment and build a plugin using the following sequence:

# Verify core dependencies

dotnet --version
git --version

# Install required global tools (run once per machine)

dotnet tool install Microsoft.DotNet.SkillValidator --global
dotnet tool install Microsoft.DotNet.SkillInstaller --global

# Build and validate a plugin (example: dotnet-msbuild)

cd plugins/dotnet-msbuild
dotnet build
skill-validator check --plugin .

# Start the LSP server for the core dotnet plugin (optional)

cd plugins/dotnet
dotnet lsp

Key Configuration Files

Understanding where dependencies are declared helps troubleshoot environment issues:

• global.json: Pins the .NET SDK version used by the repository, ensuring consistent compilation across different setups.
• plugins/dotnet/plugin.json: Declares the core plugin metadata, including the optional LSP server configuration and skills folder structure.
• plugins/dotnet-msbuild/plugin.json: Contains the MCP server definition for binlog analysis, including command-line arguments and feed URLs.
• eng/skill-validator/src/README.md: Documents the validator CLI, its parameters, and installation options.

Summary

• Minimal requirements: .NET SDK 6+, dotnet CLI on PATH, Git, and the two global tools (SkillValidator and SkillInstaller).
• Validation workflow: Use skill-validator check to catch static analysis errors before committing changes.
• Optional services: MCP servers and LSP support are declared in individual plugin.json files and require no manual installation beyond the core SDK.
• Version consistency: The repository's global.json file ensures all contributors use the same .NET SDK version.

Frequently Asked Questions

Do I need Visual Studio to develop dotnet/skills plugins?

No. While Visual Studio or VS Code with the Copilot Chat extension can enhance the development experience, you only need the .NET SDK and Git to build and validate plugins. Any text editor combined with the dotnet CLI and skill-validator tool is sufficient for local development.

What is the minimum .NET SDK version required for plugin development?

The repository supports .NET SDK version 6.0 or later, though version 7.x is commonly used in the current codebase. The global.json file at the repository root enforces a specific SDK version to ensure build consistency across contributor environments.

Are MCP servers mandatory for all plugins?

No. MCP servers are optional runtime services used by specific plugins like dotnet-msbuild for specialized tasks such as binary log analysis. They are declared in the plugin's plugin.json and launch automatically when needed, requiring no additional installation if you have the .NET runtime installed.

Where do I configure plugin-specific dependencies?

Plugin metadata and optional service declarations are configured in each plugin's plugin.json file. For example, plugins/dotnet/plugin.json configures the LSP server, while plugins/dotnet-msbuild/plugin.json defines the binlog MCP server. Core repository dependencies are managed via global.json and NuGet package references.

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