Examples of Existing Plugins in dotnet/skills: A Complete Guide to the Repository Structure

The dotnet/skills repository hosts six production-ready plugin examples—including dotnet, dotnet-msbuild, dotnet-upgrade, dotnet-test, dotnet-maui, and dotnet-ai—that demonstrate how to structure self-contained skills with metadata definitions and optional agents.

The dotnet/skills repository serves as the official reference implementation for .NET-based AI agent capabilities. Each plugin in this collection follows a standardized layout that makes it easy to discover, install, and execute individual skills through compatible agent frameworks.

Repository Structure and Plugin Anatomy

Every plugin in dotnet/skills resides under plugins/<plugin-name>/ and operates as a standalone unit requiring only the .NET SDK. The framework enforces a predictable directory structure that agent tools use to automatically discover capabilities.

Core Files Every Plugin Requires

At minimum, each plugin must contain two critical files:

• plugin.json – The marketplace descriptor located at plugins/<plugin-name>/plugin.json that declares the plugin name, version, description, and capability flags (skill, agent).
• README.md – Human-readable documentation at plugins/<plugin-name>/README.md providing overview and usage instructions.

Skill Definitions (SKILL.md)

The actual operations live inside the skills/ subdirectory. Each skill is defined by a SKILL.md file containing:

• ### Description – Explanation of what the skill accomplishes

• ### Input / ### Output – Typed JSON schemas for parameters and return values

• ### Implementation – References to executable scripts or inline code snippets

When invoked, the agent framework reads the skill’s SKILL.md, resolves referenced scripts, and executes the logic within the host process.

Optional Components

Advanced plugins may include:

• agents/ – Composite agents that orchestrate multiple skills via .agent.md files

• lsp.json – Language Server Protocol configuration for C# tooling support

• references/ – Supporting markdown files, diagrams, or sample code referenced from multiple skills

Six Essential dotnet/skills Plugin Examples to Study

The repository contains distinct plugins demonstrating various complexity levels and use cases.

dotnet – Core .NET Development Demonstrates basic C# language-server registration and common utilities. Key files include plugins/dotnet/plugin.json, plugins/dotnet/README.md, and plugins/dotnet/skills/dotnet-pinvoke/SKILL.md, which shows how to invoke native functions with P/Invoke.

dotnet-msbuild – Build Diagnostics Illustrates complex MSBuild analysis including project-reference resolution and property patterns. Study plugins/dotnet-msbuild/plugin.json and plugins/dotnet-msbuild/skills/target-authoring/SKILL.md to understand build-system integration.

dotnet-upgrade – Migration Helpers Provides sequential migration capabilities such as nullable-reference migration and .NET 9 to 10 upgrades. Examine plugins/dotnet-upgrade/plugin.json and plugins/dotnet-upgrade/skills/migrate-nullable-references/SKILL.md for versioning workflows.

dotnet-test – Testing Utilities Shows how to generate test scaffolding and detect test smells. Reference plugins/dotnet-test/plugin.json and plugins/dotnet-test/skills/writing-mstest-tests/SKILL.md for testing automation patterns.

dotnet-maui – UI Development Exemplifies UI-specific skills including theming and safe-area handling. Review plugins/dotnet-maui/plugin.json and plugins/dotnet-maui/skills/maui-theming/SKILL.md for mobile development patterns.

dotnet-ai – AI/ML Integration Features LLM-driven workflows and technology selection capabilities. Inspect plugins/dotnet-ai/plugin.json and plugins/dotnet-ai/skills/technology-selection/SKILL.md for artificial intelligence integration examples.

Common Architectural Patterns Across Plugins

All dotnet/skills plugins follow a consistent three-layer architecture according to the Agent Skills open standard (agentskills.io):

1. Metadata Layer – The plugin.json file enables marketplace discovery and capability declaration
2. Definition Layer – Each SKILL.md file provides self-documenting specifications with typed schemas
3. Implementation Layer – Scripts or .NET programs referenced within skill definitions execute the actual logic

This standardization allows any compatible tool—including Copilot CLI, Claude Code, Cursor, or the VS Code extension—to automatically discover and expose these plugins as executable commands.

Practical Code Examples for Exploring Plugins

You can interact with these examples directly through the Copilot CLI or compatible agent interfaces.

Listing Available Skills in the dotnet Plugin

# Add the marketplace (once)

/plugin marketplace add dotnet/skills

# Install the core dotnet plugin

/plugin install dotnet@dotnet-agent-skills

# Display all skills provided by the plugin

/skills --plugin dotnet

This returns entries including csharp-scripts, dotnet-pinvoke, and nuget-trusted-publishing.

Executing the dotnet-pinvoke Skill

# Run the native function invocation skill

/skill dotnet-pinvoke \
  --dllPath ./NativeLib.dll \
  --functionName "AddNumbers" \
  --args "[1,2]"

The CLI reads plugins/dotnet/skills/dotnet-pinvoke/SKILL.md to map arguments and executes the helper script referenced in the implementation section.

Using the dotnet-upgrade Agent

# Execute a composite migration agent

/agent dotnet-upgrade/migrate-dotnet9-to-dotnet10 \
  --project ./MyApp.csproj \
  --dryRun true

This agent composes multiple skills defined in plugins/dotnet-upgrade/agents/upgrade-to-dotnet10.agent.md, orchestrating SDK updates and nullable reference checks.

Summary

• The dotnet/skills repository provides six reference plugins: dotnet, dotnet-msbuild, dotnet-upgrade, dotnet-test, dotnet-maui, and dotnet-ai
• Each plugin requires plugin.json for metadata and skills/**/SKILL.md for operation definitions
• The Agent Skills standard enables automatic discovery by compatible AI tools
• Plugins are self-contained and require only the .NET SDK to function
• Study plugins/dotnet-msbuild/skills/target-authoring/SKILL.md for complex build scenarios and plugins/dotnet-ai/skills/technology-selection/SKILL.md for LLM integration patterns

Frequently Asked Questions

Where can I find the simplest example to learn from?

The dotnet plugin located at plugins/dotnet/ serves as the canonical starting point. Its plugin.json shows minimal required metadata, while plugins/dotnet/skills/dotnet-pinvoke/SKILL.md demonstrates a complete skill definition with input/output schemas and script references.

What is the difference between a skill and an agent in these examples?

A skill is a single operation defined by a SKILL.md file in the skills/ directory, such as plugins/dotnet-test/skills/writing-mstest-tests/SKILL.md. An agent is a composite workflow defined in the agents/ directory (e.g., plugins/dotnet-upgrade/agents/upgrade-to-dotnet10.agent.md) that orchestrates multiple skills to accomplish complex multi-step tasks.

How do I run these plugins locally without Copilot?

Because the plugins follow the open Agent Skills standard, any compatible runtime can execute them. The repository includes shell scripts and .NET programs referenced in the Implementation sections of SKILL.md files that can run directly via dotnet run or PowerShell/Bash, using the markdown files as configuration sources.

What information does the SKILL.md file contain?

Each SKILL.md file contains four essential sections: ### Description explaining the capability, ### Input defining the JSON schema for parameters, ### Output specifying return types, and ### Implementation referencing the executable script or inline code. Additional supporting documentation resides in references/ subdirectories for complex scenarios like plugins/dotnet-msbuild/skills/target-authoring/references/.

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