dotnet-skills

Plugin dotnet-skills from marketplace blazejewicz-claude-plugins in peterblazejewicz/claude-plugins. Commands read from the repo's manifest — 1 month ago.

Skills (24)

• api-and-interface-design

  Guides stable API and interface design for .NET/C# — HTTP endpoints (Minimal APIs or controllers), library surface area, public records/interfaces, EF Core-backed contracts. Use when designing APIs, module boundaries, `MyApp.Contracts` DTOs, or any public interface where backward compatibility matte

• ci-cd-and-automation

  Automates CI/CD pipelines for .NET/C# projects — GitHub Actions (or Azure DevOps Pipelines) with `setup-dotnet`, quality gates (`dotnet format --verify-no-changes`, `dotnet test`, `dotnet build -warnaserror`, `dotnet list package --vulnerable`), EF Core migrations, preview deploys, feature-flag-driv

• code-review-and-quality

  Conducts multi-axis code review for .NET/C# changes (correctness, readability, architecture, security, performance). Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it en

• code-simplification

  Simplifies .NET/C# code for clarity without changing behavior. Use when refactoring C# code that works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity. Preserves exact behavior; examples cover TypeScript, Python, React

• context-engineering

  Optimizes agent context setup for .NET/C# projects. Use when starting a new session, when agent output quality degrades (wrong patterns, hallucinated APIs, unaware of .NET conventions), when switching between Avalonia/Blazor/ASP.NET Core codebases, or when you need to configure CLAUDE.md, .editorcon

• debugging-and-error-recovery

  Guides systematic root-cause debugging for .NET/C# code. Use when `dotnet test` fails, `dotnet build` breaks, behavior doesn't match expectations, or you encounter any unexpected error (NullReferenceException, TaskCanceledException, missing DI registration, EF Core migration conflict). Use when you

• deprecation-and-migration

  Manages deprecation and migration for .NET/C# systems — removing NuGet packages, retiring controllers/endpoints, sunsetting features, migrating EF Core schemas. Use when removing old code, migrating users from one implementation to another, or deciding whether to maintain or sunset existing code.

• documentation-and-adrs

  Records architectural decisions and writes durable documentation for .NET/C# projects — ADRs, XML doc comments, OpenAPI/Swagger, README with dotnet CLI commands, CLAUDE.md pointers. Use when making architectural decisions, changing public APIs, shipping features, or recording context that future eng

• doubt-driven-development

  Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when correctness matters more than speed, when working in unfamiliar code, when stakes are high (production, security-sensitive logic, irreversible operations like EF Core migrations or deploys), or any t

• frontend-ui-engineering-avalonia

  Builds production-quality Avalonia UIs — MVVM with CommunityToolkit.Mvvm, compiled bindings (`x:DataType`, `x:CompileBindings`), `DataTemplate`s, theming via FluentTheme/SimpleTheme with `ThemeVariant`, keyboard navigation, `AutomationProperties` for accessibility, adaptive layouts across desktop/mo

• git-workflow-and-versioning

  Structures git workflow practices for .NET/C# projects — atomic commits, trunk-based branches, pre-commit hygiene with `dotnet test` + `dotnet format`, worktrees for parallel agent work. Use when making any code change to a .NET solution, when committing, branching, resolving conflicts, or organizin

• idea-refine

  Refines raw ideas into sharp, actionable .NET/C# concepts through structured divergent and convergent thinking. Use "idea-refine" or "ideate" to trigger when deciding what to build next in a .NET solution — new Avalonia app, ASP.NET Core API, EF Core data model, NuGet library, or process improvement

• incremental-implementation

  Delivers .NET/C# changes incrementally — thin vertical slices with dotnet build + dotnet test verification between each. Use when implementing any feature that touches more than one project or assembly. Use when you're about to write a large amount of code at once, or when a task feels too big to la

• integration-testing-dotnet

  Tests .NET/C# systems at their integration boundaries — HTTP APIs with `WebApplicationFactory<T>`, EF Core against real databases via Testcontainers (PostgreSQL, SQL Server, Redis), Blazor/Razor Pages in real browsers via `Microsoft.Playwright`, Avalonia UI via `Avalonia.Headless.XUnit`. Works with

• interview-me

  Extracts what the user actually wants instead of what they think they should want. Achieves this through one-question-at-a-time interview until ~95% confidence about the underlying intent. Use when an ask is underspecified ("build me X" without "for whom" or "why now"), when the user explicitly invo

• observability-and-instrumentation

  Instruments .NET/C# code so production behavior is visible and diagnosable. Use when adding logging, metrics, tracing, or alerting to an ASP.NET Core / Blazor / worker / desktop app. Use when shipping any feature that runs in production and you need evidence it works. Use when production issues are

• performance-optimization-dotnet

  Optimizes .NET/C# application performance — measure first with BenchmarkDotNet / dotnet-counters / dotnet-trace / PerfView, then fix the specific bottleneck (EF Core N+1, sync-over-async, Gen2 GC pressure, thread-pool starvation, allocation hotspots, unbounded queries, missing pagination, Kestrel mi

• planning-and-task-breakdown

  Breaks .NET/C# work into ordered, verifiable tasks. Use when you have a spec or clear requirements and need to decompose work into implementable units with dotnet CLI verification steps. Use when a task feels too large to start, when you need to estimate scope across a multi-project solution, or whe

• security-and-hardening

  Hardens .NET/C# code against vulnerabilities — input validation (FluentValidation), EF Core parameterization, ASP.NET Core Identity / JWT bearer / policy-based authz, Data Protection, antiforgery, user-secrets + Key Vault, `dotnet list package --vulnerable`. Use when handling user input, authenticat

• shipping-and-launch

  Prepares production launches for .NET/C# systems — pre-launch checklist with `dotnet test` + `dotnet list package --vulnerable`, feature flags via `IOptions<T>`, staged rollout with Application Insights / OpenTelemetry monitoring, EF Core migration rollback, `dotnet ef database update` to previous m

• source-driven-development

  Grounds every .NET/C# implementation decision in official documentation (Microsoft Learn, EF Core docs, ASP.NET Core docs, Avalonia docs, NuGet README). Use when you want authoritative, source-cited code free from outdated patterns. Use when building with any .NET framework or library where correctn

• spec-driven-development

  Creates specs before coding a .NET/C# project. Use when starting a new .NET 8+ solution, feature, or significant change and no specification exists yet. Use when requirements are unclear, ambiguous, or only exist as a vague idea. Frames examples for Avalonia, ASP.NET Core, Blazor, .NET MAUI, EF Core

• test-driven-development

  Drives .NET/C# development with tests — RED/GREEN/REFACTOR with xUnit (v2 or v3) or MSTest, the Prove-It Pattern for bug fixes, the test pyramid with `WebApplicationFactory` for integration and `Playwright`/`Avalonia.Headless` for E2E. Supports both VSTest and Microsoft.Testing.Platform (MTP) runner

• using-agent-skills

  Meta-skill — discovers and invokes the right .NET/C# agent skill from this marketplace for the task at hand. Use when starting a session, when a task doesn't obviously map to a single skill, or when you need a phase-by-phase map of what's available across Define / Plan / Build / Verify / Review / Sh

Slash commands (9)

• /dotnet-skills:build

  Implement tasks incrementally in .NET — RED/GREEN/REFACTOR, `dotnet build`, `dotnet test`, commit. Add "auto" to run the whole plan in one approved pass.

• /dotnet-skills:code-simplify

  Simplify C# code for clarity and maintainability — reduce complexity without changing behavior

• /dotnet-skills:dotnet-skills

  List the .NET skills, subagents, and lifecycle commands shipped by this plugin (adapted from addyosmani/agent-skills — spec-driven development, TDD, code review, security audit, test engineering, and more with .NET 8+, C# 12+, xUnit/MSTest, EF Core, Avalonia framing)

• /dotnet-skills:plan

  Break .NET work into small verifiable tasks with acceptance criteria, `dotnet` CLI verification steps, and dependency ordering

• /dotnet-skills:review

  Conduct a five-axis code review for .NET/C# changes — correctness, readability, architecture, security, performance

• /dotnet-skills:ship

  Run the .NET pre-launch checklist via parallel fan-out to specialist personas, then synthesize a go/no-go decision with rollback in place

• /dotnet-skills:spec

  Start spec-driven development for a .NET project — write a structured specification before writing C# code

• /dotnet-skills:test

  Run .NET TDD workflow — write failing xUnit/MSTest tests, implement, verify. For bugs, use the Prove-It pattern.

• /dotnet-skills:webperf

  Run a web performance audit on a Blazor / ASP.NET Core front end via the web-performance-auditor persona

Subagents (8)

• code-reviewer

  Senior .NET/C# code reviewer that evaluates changes across five dimensions — correctness, readability, architecture, security, and performance — with .NET 8+ (Avalonia, ASP.NET Core, Blazor, MAUI, EF Core, xUnit/MSTest) framing. Use for thorough code review before merge.

• code-reviewer

  Senior .NET/C# code reviewer that evaluates changes across five dimensions — correctness, readability, architecture, security, and performance — with .NET 8+ (Avalonia, ASP.NET Core, Blazor, MAUI, EF Core, xUnit/MSTest) framing. Use for thorough code review before merge.

• security-auditor

  .NET/C# security engineer focused on vulnerability detection, threat modeling, and secure coding practices for ASP.NET Core / Blazor / MAUI applications. Use for security-focused code review, threat analysis, or hardening recommendations.

• security-auditor

  .NET/C# security engineer focused on vulnerability detection, threat modeling, and secure coding practices for ASP.NET Core / Blazor / MAUI applications. Use for security-focused code review, threat analysis, or hardening recommendations.

• test-engineer

  .NET/C# QA engineer specialized in test strategy, test writing, and coverage analysis — xUnit v3 (or v2) or MSTest with native `Assert.X`, WebApplicationFactory, Testcontainers, Microsoft.Playwright, and Avalonia.Headless. Use for designing test suites, writing tests for existing code, or evaluating

• test-engineer

  .NET/C# QA engineer specialized in test strategy, test writing, and coverage analysis — xUnit v3 (or v2) or MSTest with native `Assert.X`, WebApplicationFactory, Testcontainers, Microsoft.Playwright, and Avalonia.Headless. Use for designing test suites, writing tests for existing code, or evaluating

• web-performance-auditor

  .NET web performance engineer focused on Core Web Vitals, loading, rendering, and network optimization for Blazor (Server / WebAssembly / Auto) and ASP.NET Core MVC / Razor Pages front ends. Use for performance-focused audits, CWV analysis, and identifying structural performance anti-patterns in .NE

• web-performance-auditor

  .NET web performance engineer focused on Core Web Vitals, loading, rendering, and network optimization for Blazor (Server / WebAssembly / Auto) and ASP.NET Core MVC / Razor Pages front ends. Use for performance-focused audits, CWV analysis, and identifying structural performance anti-patterns in .NE

Similar plugins