analyzing-dotnet-performance

Scan C#/.NET code for performance anti-patterns and output prioritized fixes.

1|Updated May 21, 2026
One-click install
npx skills add https://github.com/1k-off/umbraco-observability-playground --skill analyzing-dotnet-performance-1k-off
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: analyzing-dotnet-performance
Source: https://github.com/1k-off/umbraco-observability-playground/tree/main/.agents/skills/analyzing-dotnet-performance
Command: npx skills add https://github.com/1k-off/umbraco-observability-playground --skill analyzing-dotnet-performance-1k-off

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you quickly identify common .NET performance anti-patterns that cause excessive allocations, slower execution, and scalability issues, then translates them into prioritized, concrete code fixes.

Core Features & Use Cases

  • Performance anti-pattern scanning: Detects ~50 targeted issues across async patterns, memory/string handling, collections & LINQ, regex usage, serialization, and I/O.
  • Prioritized, severity-based reporting: Classifies findings as 🔴 Critical, 🟡 Moderate, or ℹ️ Info, with escalation rules for hot paths and high repetition.
  • Evidence-driven output: Produces exact hit counts and includes file+line locations plus one-line fixes and any caveats (e.g., version requirements).

Use case examples:

  • Auditing an allocation-heavy API endpoint before a release to reduce latency and GC pressure.
  • Reviewing hot-path code to eliminate culture-sensitive string operations, inefficient LINQ chains, and problematic regex usage.
  • Running a systematic pre-optimization pass to surface risky async/task patterns (e.g., deadlock-prone sync-over-async).

Quick Start

Use the analyzing-dotnet-performance skill to scan your C# repository for performance anti-patterns and return a prioritized list of findings with concrete fixes and exact counts.

Frequently Asked Questions about analyzing-dotnet-performance

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

FAQPage Schema
How do I find .NET performance anti-patterns in my C# codebase?▼

Scanning C# source code targets ~50 performance anti-patterns across async, memory, strings, LINQ, and regex, producing prioritized findings with exact hit counts, file/line evidence, and one-line fixes.

What causes high memory allocations in .NET hot paths and how are they flagged?▼

High memory allocations in .NET hot paths trigger severity escalation rules based on hot-path context and repetition counts, classifying findings as critical, moderate, or info with exact hit counts.

How do I audit async patterns for deadlock-prone sync-over-async issues before a release?▼

Auditing async patterns for deadlock-prone sync-over-async issues involves running a systematic pre-optimization scan of the codebase to surface risky task patterns and return prioritized fixes with file evidence.

Can I use this to detect inefficient LINQ chains and regex usage in C#?▼

Yes, code scanning detects inefficient LINQ chains and problematic regex usage by targeting known anti-patterns, returning evidence-backed findings with severity levels and one-line fix recommendations.

What is the best way to prioritize .NET code fixes for GC pressure and latency?▼

The best way to prioritize .NET code fixes for GC pressure is severity-based reporting that classifies anti-patterns as critical, moderate, or info, applying escalation rules for hot paths and high repetition.

Does the performance analysis require external profiling dependencies or tools?▼

No external profiling dependencies are required; the analysis operates directly by scanning C#/.NET source code recipes to count exact occurrences and apply severity escalation rules using hot-path context.