What Programming Languages Are Used in the dotnet/skills Repository?

The dotnet/skills repository is a polyglot codebase that uses C# for core skill logic, PowerShell and Python for automation scripts, TypeScript and JavaScript for testing and visualization, and Shell scripts for CI workflows.

The dotnet/skills repository demonstrates a pragmatic approach to programming language selection, leveraging the .NET ecosystem's strengths while incorporating specialized languages for specific operational needs. This multi-language architecture allows the project to handle everything from LSP server implementations to cross-platform automation and web-based dashboards. Understanding the distribution of programming languages in dotnet/skills reveals how modern .NET projects integrate with broader development ecosystems.

Primary Programming Language: C# in dotnet/skills

C# serves as the backbone of the repository, driving the core implementation of every plugin and skill through compiled .NET assemblies.

Each plugin directory under plugins/ contains .cs files and accompanying .csproj projects that compile into .NET assemblies. These assemblies expose the skill contracts that agents consume. For example, Find-UntestedSources.cs in the dotnet-test plugin discovers untested source files across the codebase, demonstrating how C# handles file system enumeration and logging within the skill framework.

// Located in plugins/dotnet-test/skills/find-untested-sources/scripts/Find-UntestedSources.cs
var allCs = Directory.EnumerateFiles(root, "*.cs", SearchOption.AllDirectories).ToList();
Log($"Discovered {allCs.Count} .cs files");

The C# implementations handle LSP servers, build helpers, diagnostics, and the primary skill logic that agents interact with, making it the dominant programming language for core functionality.

Scripting Languages for dotnet/skills Automation

Beyond the core .NET implementation, the repository employs several scripting languages to handle automation, migration tasks, and evaluation workflows without requiring compiled assemblies.

PowerShell for Migration Tasks

PowerShell scripts handle complex automation scenarios, particularly for upgrade and migration workflows. The Get-NullableReadiness.ps1 script in the dotnet-upgrade plugin scans projects for nullable reference type annotations, providing detailed readiness reports.

# Located in plugins/dotnet-upgrade/skills/migrate-nullable-references/scripts/Get-NullableReadiness.ps1

$projPath = Resolve-Path $Path
Write-Host "Scanning $projPath for nullable annotations..."

These scripts run outside the CLR, allowing them to be invoked from CI pipelines without pulling in heavy runtime dependencies.

Python for Source Analysis

Python utilities perform source-code analysis and test discovery tasks that benefit from Python's extensive standard library. The find_untested_sources.py script filters and identifies Python test files while scanning for source candidates.

# Located in plugins/dotnet-test/skills/find-untested-sources/scripts/find_untested_sources.py

if name.endswith("test.py") or name == "conftest.py":
    continue
candidates.add(PurePosixPath(base + ".py"))

Shell Scripts for CI Integration

Bash wrappers support the Vally evaluation adapter in continuous integration environments. The run-vally-evals.sh script provides a lightweight entry point for running evaluations across the plugin ecosystem.

#!/usr/bin/env bash

# Located in eng/vally-adapter/run-vally-evals.sh

./run-vally-evals.sh -p ./plugins/dotnet-test -s ./skills

Web and Testing Languages in dotnet/skills

The repository includes web technologies for visualization and cross-language testing scenarios, ensuring skills work across diverse codebases.

TypeScript for Test Fixtures

TypeScript files serve as test fixtures to verify that skills correctly handle non-C# code. The tax.ts file in the dotnet-test fixtures demonstrates tax calculation logic used for validation scenarios.

// Located in tests/dotnet-test/code-testing-agent/fixtures/typescript-vitest-cart/src/tax.ts
export function taxRate(amount: number): number {
    return amount * 0.07;
}

JavaScript for Dashboard Visualization

JavaScript powers the dashboard that visualizes skill-validation results in a web interface. The dashboard.js file fetches component data and renders evaluation metrics for the public website.

// Located in eng/dashboard/dashboard.js
const response = await fetch('data/components.json');
const plugins = await response.json();

Configuration and Declarative Formats

JSON, YAML, and Markdown files define plugin metadata, CI workflow configurations, and documentation. These declarative formats are parsed at runtime to register skills and configure pipelines.

Key configuration files include:

• plugin.json – Defines plugin metadata and entry points
• eval.yaml – Configures evaluation parameters for testing scenarios

Summary

• C# dominates the core implementation, handling skill logic, LSP servers, and build helpers in files like Find-UntestedSources.cs
• PowerShell manages migration and automation tasks through scripts such as Get-NullableReadiness.ps1
• Python handles source analysis utilities like find_untested_sources.py
• TypeScript and JavaScript support cross-language testing fixtures and dashboard visualization (tax.ts, dashboard.js)
• Shell scripts provide CI workflow wrappers like run-vally-evals.sh
• JSON/YAML configure plugins and evaluation pipelines without requiring compiled code

Frequently Asked Questions

Is dotnet/skills a pure C# codebase?

No, while C# serves as the primary implementation language for skill logic and plugins, the repository uses PowerShell, Python, TypeScript, JavaScript, and Shell scripts for automation, testing, and visualization tasks. This polyglot approach allows each component to use the most suitable programming language for its specific function.

Why does the repository use Python alongside .NET?

Python scripts handle source-analysis and file-discovery tasks that benefit from Python's extensive standard library and text-processing capabilities. Because these scripts run outside the CLR, they can be invoked from CI pipelines or from .NET skills directly without introducing heavy runtime dependencies.

How are TypeScript files used in a .NET skills repository?

TypeScript files function as test fixtures in the dotnet-test skill to verify that the skills correctly analyze and handle non-C# codebases. Files like tax.ts provide realistic test scenarios that ensure the testing agent works across multiple programming languages.

Where are the CI automation scripts located?

Automation scripts reside in multiple directories throughout the repository. PowerShell scripts live in plugin-specific scripts/ folders, Python utilities appear in skills directories, and Shell wrappers are located in eng/vally-adapter/ for evaluation workflows.

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