build-perf-diagnostics

Diagnose MSBuild performance bottlenecks by analyzing binlog performance summaries.

Updated Mar 18, 2026
One-click install
npx skills add https://github.com/Mozart-Alkhateeb/ai_sdlc_todo --skill build-perf-diagnostics-mozart-alkhateeb
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: build-perf-diagnostics
Source: https://github.com/Mozart-Alkhateeb/ai_sdlc_todo/tree/main/.agents/skills/build-perf-diagnostics
Command: npx skills add https://github.com/Mozart-Alkhateeb/ai_sdlc_todo --skill build-perf-diagnostics-mozart-alkhateeb

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Diagnosing MSBuild build performance bottlenecks by analyzing binlog performance summaries produced during dotnet build, enabling fast identification of root causes and actionable improvements.

Core Features & Use Cases

  • Generate a binlog from a build (dotnet build /bl) and replay it to produce a performance summary that highlights where time is spent.
  • Review the Performance Summary and Target/Task Performance sections to pinpoint expensive targets, tasks, and serialization bottlenecks.
  • Assess node utilization, analyzer timing, and common bottlenecks (RAR, analyzers, excessive I/O) to guide targeted optimizations.
  • Apply practical fixes and best practices such as improving build parallelism, reducing references, and deferring expensive analyses, with guidance for incremental vs clean builds.

Quick Start

Run a build with binlog enabled, replay the binlog to generate a performance summary, and review the results to identify slow targets, tasks, and potential bottlenecks.

Frequently Asked Questions about build-perf-diagnostics

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

FAQPage Schema
How do I diagnose slow MSBuild performance bottlenecks in my dotnet build?

To diagnose MSBuild performance bottlenecks, generate a binlog using dotnet build /bl, replay it to produce a performance summary, and review the results to pinpoint slow targets, tasks, and potential bottlenecks like low parallelism or excessive I/O.

Why does ResolveAssemblyReferences take so long during my MSBuild build?

ResolveAssemblyReferences can dominate MSBuild build time due to excessive reference resolution. By analyzing a binlog performance summary, you can identify if RAR is a bottleneck and apply targeted optimizations such as reducing references to improve build speed.

What is the best way to identify Roslyn analyzers consuming excessive build time?

The best way to identify slow Roslyn analyzers is to generate a dotnet build binlog, replay it for a performance summary, and assess the analyzer timing sections to guide deferring expensive analyses and optimizing overall build performance.

How do I check node utilization and parallelism issues in MSBuild?

To check MSBuild node utilization and parallelism, generate a binlog from your build, replay it to extract the performance summary, and review the node utilization data to identify serialization bottlenecks and guide improvements for build parallelism.

Can I analyze both incremental and clean builds using a dotnet binlog?

Yes, you can analyze both incremental and clean builds by generating a binlog for each scenario, replaying them to produce performance summaries, and reviewing the target and task performance sections to guide specific optimizations for each build type.