dotnet-tooling

Configure .NET projects, MSBuild targets, and Native AOT-ready CLI tooling.

Updated Dec 20, 2023
One-click install
npx skills add https://github.com/Thiago-Cruz-eng/Hibrygame --skill dotnet-tooling-thiago-cruz-eng
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dotnet-tooling
Source: https://github.com/Thiago-Cruz-eng/Hibrygame/tree/main/.claude/skills/dotnet-tooling
Command: npx skills add https://github.com/Thiago-Cruz-eng/Hibrygame --skill dotnet-tooling-thiago-cruz-eng

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps you set up, harden, and troubleshoot .NET project build tooling so your solution builds reliably, optimizes performance, and supports Native AOT-ready command line applications.

Core Features & Use Cases

  • Project structure & scaffolding: Establish consistent solution patterns (Directory.Build.*, central packages/analysis, CPM) and scaffold new projects with the right baseline.
  • MSBuild authoring & build performance: Create correct custom targets, enable incremental builds with Inputs/Outputs, and diagnose “always rebuilding” issues using binary logs.
  • AOT, trimming, GC/memory, and profiling: Make your code and dependencies AOT- and trim-compatible, tune memory/GC behavior, and pick the right profiling tooling.
  • CLI architecture & distribution: Design System.CommandLine-based CLIs with clean command/handler/service layering, and plan packaging/release pipelines across RIDs.
  • Docs and diagram support: Generate consistent documentation strategy choices (Starlight/Docusaurus/DocFX) and produce Mermaid diagrams from a shared reference.

Use it when you need to modernize a .NET repo (analyzers, nullable, central config), speed up builds, or prepare a production-grade CLI that publishes cleanly with Native AOT and trimming.

Quick Start

Use the dotnet-tooling skill to plan your .NET solution structure and AOT/trimming-safe CLI approach for your existing repo.

Frequently Asked Questions about dotnet-tooling

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I make my .NET project Native AOT and trim compatible?

To make a .NET project Native AOT and trim compatible, you analyze dependencies and code paths to ensure trim-safe execution. This Skill guides AOT compatibility planning, trimming, and GC/memory tuning for reliable deployment.

Why does MSBuild always rebuild my targets instead of using incremental builds?

MSBuild always rebuilds targets when custom authoring lacks correct Inputs/Outputs mappings. This Skill helps diagnose incremental build failures and "always rebuilding" issues using binary logs to restore efficient build performance.

What is the best way to structure a System.CommandLine CLI for multiple platforms?

The best way to structure a System.CommandLine CLI is using clean command, handler, and service layering. This Skill helps design CLI architecture and plan packaging/release pipelines across RIDs for reliable distribution.

Can I use central package management to modernize my .NET repo?

Yes, you can use central package management (CPM) alongside Directory.Build.* files and nullable analyzers to modernize a .NET repo. This Skill establishes consistent solution patterns and scaffolds projects with the correct baseline.

How do I diagnose .NET build performance issues using binary logs?

You diagnose .NET build performance by analyzing MSBuild binary logs to find target execution bottlenecks. This Skill streamlines MSBuild authoring, incremental build diagnostics, and target optimization to speed up builds.

When should I not use Native AOT for my .NET application?

You should avoid Native AOT when your application relies heavily on dynamic code generation or reflection-heavy dependencies that cannot be made trim-compatible. This Skill helps evaluate AOT limitations and plan alternative CLI architectures.