AGIBuild
165 verified skills1,320 total stars
dotnet-ui-chooser
Selecting a .NET UI framework. Decision tree across Blazor, MAUI, Uno, WinUI, WPF, WinForms.
development8
dotnet-file-based-apps
Running C# without a project file (.NET 10 SDK). Directives, CLI commands, migration.
tools8
playwright-blazor
End-to-end testing patterns for Blazor applications using Playwright, including component testing and page navigation. Use when writing E2E tests for Blazor applications, testing Blazor component interactions with Playwright, or setting up Playwright testing infrastructure for Blazor apps.
testing8
dotnet-container-deployment
Deploying .NET containers. Kubernetes probes, Docker Compose for local dev, CI/CD integration.
development8
dotnet-playwright
Automating browser tests in .NET. Playwright E2E, CI browser caching, trace viewer, codegen.
development8
dotnet-openapi
Generating OpenAPI docs. MS.AspNetCore.OpenApi (.NET 9+), Swashbuckle migration, NSwag.
development8
dotnet-semantic-kernel
Building AI/LLM features. Semantic Kernel setup, plugins, prompt templates, memory stores, agents.
tools8
dotnet-tool-management
Installing or managing .NET tools. Global, local, manifests, restore, version pinning.
tools8
dotnet-uno-testing
Testing Uno Platform apps. Playwright for WASM, platform-specific patterns, runtime heads.
testing8
dotnet-wpf-modern
Building WPF on .NET 8+. Host builder, MVVM Toolkit, Fluent theme, performance, modern C# patterns.
tools8
local-tools
Best practices for working with .NET local tools, including manifest management, tool installation, and versioning. Use when setting up dotnet-tools.json for a project, installing or updating local tools, or managing tool versions across team members.
tools8
architecture-design-review
Red-team review of system/design proposals to find fatal flaws and blockers across architecture/tech risk, business reasonableness, and security/compliance. Outputs rejection-style critique (blockers, contradictions, missing invariants), not improvement plans. Use when the user wants a harsh risk审查/否决/质疑/拆穿 review.
testing8
aspire-integration-testing
Write integration tests using .NET Aspire's testing facilities with xUnit. Covers test fixtures, distributed application setup, endpoint discovery, and patterns for testing ASP.NET Core apps with real dependencies. Use when writing integration tests for .NET Aspire applications, testing ASP.NET Core apps with real database connections, or verifying service-to-service communication in distributed applications.
testing8
background-services
Hosted services, background jobs, outbox patterns, and graceful shutdown handling for ASP.NET Core applications. Includes patterns for reliable job processing, distributed systems, and lifecycle management. Use when implementing background processing in ASP.NET Core applications, handling outbox patterns for reliable message delivery, or managing graceful service shutdown.
tools8
modern-csharp-coding-standards
Write modern, high-performance C# code using records, pattern matching, value objects, async/await, Span<T>/Memory<T>, and best-practice API design patterns. Emphasizes functional-style programming with C# 12+ features. Use when writing new C# code or refactoring existing code, designing public APIs for libraries or services, optimizing performance-critical code paths, or building async/await-heavy applications.
development8
csharp-wolverinefx
Build .NET applications with WolverineFX for messaging, HTTP services, and event sourcing. Use when implementing command handlers, message handlers, HTTP endpoints with WolverineFx.HTTP, transactional outbox patterns, event sourcing with Marten, CQRS architectures, cascading messages, batch message processing, or configuring transports like RabbitMQ, Azure Service Bus, or Amazon SQS.
development8
dotnet-add-analyzers
Adding analyzer packages to a project. Nullable, trimming, AOT compat analyzers, severity config.
tools8
dotnet-add-ci
Adding CI/CD to a .NET project. GitHub Actions vs Azure DevOps detection, workflow templates.
development8
dotnet-ado-unique
Using ADO-exclusive features. Environments, approvals, service connections, classic releases.
tools8
dotnet-ado-publish
Publishing .NET artifacts from Azure DevOps. NuGet push, containers to ACR, pipeline artifacts.
development8
dotnet-aot-wasm
AOT-compiling for WebAssembly. Blazor/Uno WASM AOT, size vs speed, lazy loading, Brotli.
development8
dotnet-api-versioning
Versioning HTTP APIs. Asp.Versioning.Http/Mvc, URL segment, header, query string, sunset.
development8
dotnet-api-surface-validation
Detecting API changes in CI. PublicApiAnalyzers, Verify snapshots, breaking change enforcement.
development8
dotnet-aspire-patterns
Using .NET Aspire. AppHost orchestration, service discovery, components, dashboard, health checks.
testing8
dotnet-blazor-components
Building Blazor components. Lifecycle, state management, JS interop, EditForm validation, QuickGrid.
development8
dotnet-cli-architecture
Structuring CLI app layers. Command/handler/service separation, clig.dev principles, exit codes.
tools8
dotnet-cli-distribution
Choosing CLI output format. AOT vs framework-dependent, RID matrix, single-file, dotnet tool.
tools8
dotnet-csharp-nullable-reference-types
Enabling nullable reference types. Annotation strategies, attributes, common agent mistakes.
data-ai8
dotnet-csharp-dependency-injection
Registering or resolving services with MS DI. Keyed services, scopes, decoration, hosted services.
tools8
dotnet-csharp-modern-patterns
Using records, pattern matching, primary constructors, collection expressions. C# 12-15 by TFM.
tools8
dotnet-data-access-strategy
Choosing a data access approach. EF Core vs Dapper vs ADO.NET decision matrix, performance tradeoffs.
testing8
dotnet-csharp-source-generators
Creating source generators. IIncrementalGenerator, GeneratedRegex, LoggerMessage, STJ source-gen.
tools8
dotnet-csproj-reading
Reading or modifying .csproj files. SDK-style structure, PropertyGroup/ItemGroup, CPM, props.
development8
dotnet-editorconfig
Authoring .editorconfig rules. IDE/CA severity, AnalysisLevel, globalconfig, code style enforcement.
development8
dotnet-gc-memory
Tuning GC and memory. GC modes, LOH/POH, Gen0/1/2, Span/Memory deep patterns, ArrayPool, profiling.
tools8
dotnet-mermaid-diagrams
Creating Mermaid diagrams for .NET. Architecture, sequence, class, deployment, ER, flowcharts.
devops8
dotnet-modernize
Analyzing .NET code for modernization. Outdated TFMs, deprecated packages, superseded patterns.
development8
dotnet-native-interop
Calling native libraries via P/Invoke. LibraryImport, marshalling, cross-platform resolution.
development8
dotnet-roslyn-analyzers
Authoring Roslyn analyzers. DiagnosticAnalyzer, CodeFixProvider, CodeRefactoring, multi-version.
development8
dotnet-scaffold-project
Creating a new .NET project. Generates solution with CPM, analyzers, editorconfig, SourceLink.
tools8
dotnet-structured-logging
Designing log pipelines. Aggregation, structured queries, sampling, PII scrubbing, correlation.
devops8
middleware-patterns
Custom middleware patterns for ASP.NET Core applications. Covers request/response pipeline, middleware ordering, conditional middleware, IMiddleware factory pattern, IExceptionHandler (.NET 8+), and reusable middleware components. Use when creating custom middleware in ASP.NET Core applications, understanding middleware pipeline ordering, or implementing cross-cutting concerns like logging, authentication, and caching.
devops8
security-design-review
Reviews designs and business goals for security vulnerabilities, data protection (in transit/at rest), authorization, and compliance alignment. Use when the user asks for a security review, threat modeling, attack surface analysis, data leakage prevention, or compliance/security assessment.
development8
dotnet-cli-packaging
Publishing to package managers. Homebrew, apt/deb, winget, Scoop, Chocolatey manifests.
tools8
aspire-configuration
Configure Aspire AppHost to emit explicit app config via environment variables while keeping app code free of Aspire clients and service discovery. Use when wiring AppHost resources to application configuration, ensuring production configuration is transparent and portable outside of Aspire, or avoiding Aspire client packages inside application code.
tools8
csharp-concurrency-patterns
Choosing the right concurrency abstraction in .NET - from async/await for I/O to Channels for producer/consumer to Akka.NET for stateful entity management. Covers both high-level abstractions and low-level synchronization primitives. Use when deciding how to handle concurrent operations in .NET, evaluating whether to use async/await, Channels, or Akka.NET, or managing state across multiple concurrent entities.
testing8
dotnet-accessibility
Building accessible .NET UI. SemanticProperties, ARIA, AutomationPeer, testing tools per platform.
tools8
dotnet-ado-build-test
Configuring .NET build/test in Azure DevOps. DotNetCoreCLI task, Artifacts, test results.
tools8
dotnet-advisor
Working with .NET, C#, ASP.NET Core, or related frameworks. Routes to specialist skills.
development8
dotnet-ado-patterns
Designing composable Azure DevOps YAML pipelines. Templates, variable groups, multi-stage, triggers.
development8
dotnet-agent-gotchas
Generating or modifying .NET code. Common agent mistakes: async, NuGet, deprecated APIs, DI.
development8
dotnet-api-security
Implementing API auth. Identity, OAuth/OIDC, JWT bearer, passkeys (WebAuthn), CORS, rate limiting.
development8
dotnet-artifacts-output
Using artifacts output layout. UseArtifactsOutput, ArtifactsPath, impact on CI and Docker.
testing8
dotnet-build-analysis
Interpreting MSBuild output, NuGet errors, or analyzer warnings. Error codes, CI drift fixes.
development8
dotnet-ci-benchmarking
Gating CI on perf regressions. Automated threshold alerts, baseline tracking, trend reports.
testing8
dotnet-channels
Using producer/consumer queues. Channel<T>, bounded/unbounded, backpressure, drain patterns
data-ai8
dotnet-cryptography
Choosing crypto algorithms, hashing, encryption, or key derivation. AES-GCM, RSA, ECDSA, PQC.
development8
dotnet-file-io
Doing file I/O. FileStream, RandomAccess, FileSystemWatcher, MemoryMappedFile, paths.
tools8
dotnet-gha-patterns
Designing GitHub Actions workflows. Reusable workflows, composite actions, matrix builds, caching.
development8
dotnet-gha-publish
Publishing .NET artifacts from GitHub Actions. NuGet push, container images, signing, SBOM.
data-ai8
dotnet-http-client
Consuming HTTP APIs. IHttpClientFactory, typed/named clients, resilience, DelegatingHandlers.
tools8
dotnet-linq-optimization
Optimizing LINQ queries. IQueryable vs IEnumerable, compiled queries, deferred exec, allocations.
development8
dotnet-input-validation
Validating HTTP request inputs. .NET 10 AddValidation, FluentValidation, ProblemDetails.
data-ai8
dotnet-maui-aot
Optimizing MAUI for iOS/Catalyst. Native AOT pipeline, size/startup gains, library gaps, trimming.
development8
dotnet-maui-testing
Testing .NET MAUI apps. Appium device/emulator testing, XHarness, platform validation.
development8
dotnet-msbuild-tasks
Writing custom MSBuild tasks. ITask, ToolTask, IIncrementalTask, inline tasks, UsingTask.
tools8
dotnet-msix
Packaging MSIX apps. Creation, signing, Store submission, App Installer sideload, auto-update.
tools8
dotnet-multi-targeting
Targeting multiple TFMs or using newer C# on older TFMs. Polyfill strategy, API compat.
development8
dotnet-native-aot
Publishing Native AOT. PublishAot, ILLink descriptors, P/Invoke, size optimization, containers.
data-ai8
dotnet-observability
Adding observability. OpenTelemetry traces/metrics/logs, health checks, custom metrics.
testing8
dotnet-resilience
Adding fault tolerance. Polly v8 + MS.Extensions.Http.Resilience, retry/circuit breaker/timeout.
tools8
dotnet-secrets-management
Handling secrets or sensitive configuration. User secrets, environment variables, rotation.
tools8
dotnet-service-communication
Choosing inter-service protocols. REST vs gRPC vs SignalR vs SSE decision matrix, tradeoffs.
testing8
dotnet-trimming
Making apps/libraries trim-safe. Annotations, ILLink descriptors, IL2xxx warnings, IsTrimmable.
tools8
dotnet-uno-platform
Building Uno Platform apps. Extensions, MVUX reactive pattern, Toolkit controls, Hot Reload.
tools8
dotnet-version-upgrade
Upgrading .NET to a newer TFM. LTS-to-LTS, staged through STS, preview, upgrade paths.
tools8
dotnet-version-detection
Project has .csproj, global.json, or Directory.Build.props. Detects TFMs and SDK versions.
development8
find-skills
Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
data-ai8
github
Interact with GitHub using the `gh` CLI. Use `gh issue`, `gh pr`, `gh run`, and `gh api` for issues, PRs, CI runs, and advanced queries.
tools8
localization-globalization
Multi-language support, resource files, culture formatting, and globalization patterns for ASP.NET Core Razor Pages applications. Use when implementing multi-language support in ASP.NET Core applications, managing resource files for translations, or formatting dates, numbers, and currencies for different cultures.
development8
.cursor/skills/loop-mode
--- name: loop-mode description: Executes tasks in continuous loop mode with strict test coverage and no legacy compatibility. Use when the user says "进入loop 模式, 目标: XXXX" or asks for nonstop implementation until done. --- # Loop Mode Run in continuous execution mode for a single concrete goal with minimal interruption. ## Trigger Apply this skill when the user provides: - `进入loop 模式, 目标: XXXX` - or equivalent intent such as "keep going without stopping until done" If goal text is missing,
development8
rate-limiting
Rate limiting patterns for ASP.NET Core Razor Pages applications. Covers fixed window, sliding window, token bucket algorithms, and distributed rate limiting with Redis. Use when implementing rate limiting in ASP.NET Core applications, choosing between different rate limiting algorithms, or setting up distributed rate limiting with Redis.
development8
dotnet-github-docs
Creating GitHub-native docs. README badges, CONTRIBUTING, issue/PR templates, repo metadata.
documentation8
dotnet-library-api-compat
Maintaining library compatibility. Binary/source compat rules, type forwarders, SemVer impact.
development8
dotnet-grpc
Building gRPC services. Proto definition, code-gen, ASP.NET Core host, streaming, auth.
development8
dotnet-profiling
Diagnosing .NET performance issues. dotnet-counters, dotnet-trace, dotnet-dump, flame graphs.
tools8
dotnet-localization
Localizing .NET apps. .resx resources, IStringLocalizer, source generators, pluralization, RTL.
tools8
dotnet-realtime-communication
Building real-time features. SignalR hubs, SSE (.NET 10), JSON-RPC 2.0, gRPC streaming, scaling.
development8
dotnet-release-management
Managing .NET release lifecycle. NBGV versioning, SemVer, changelogs, pre-release, branching.
documentation8
dotnet-solid-principles
Designing classes or refactoring. SOLID, DRY, SRP with C# anti-patterns, fixes, compliance.
development8
dotnet-spectre-console
Building rich console output. Spectre.Console: tables, trees, progress, prompts, live displays.
development8
dotnet-test-quality
Measuring test effectiveness. Coverlet code coverage, Stryker.NET mutation testing, flaky detection.
development8
dotnet-testing-strategy
Deciding how to test .NET code. Unit vs integration vs E2E decision tree, test doubles.
development8
dotnet-tunit-test
Guidelines for writing TUnit tests in .NET, including setup, assertions, async testing, and best practices. Use when writing unit tests with TUnit framework, setting up TUnit in a .NET project, or migrating from other test frameworks to TUnit.
development8
dotnet-ui-testing-core
Testing UI across frameworks. Page objects, test selectors, async waits, accessibility.
development8
dotnet-uno-mcp
Using Uno MCP server. Tool detection, search-then-fetch workflow, init rules, fallback, citation.
tools8
dotnet-xml-docs
Writing XML doc comments. Tags, inheritdoc, GenerateDocumentationFile, warning suppression.
documentation8
efcore-patterns
Entity Framework Core best practices including NoTracking by default, query splitting for navigation collections, migration management, dedicated migration services, interceptors, compiled queries, and connection resiliency. Use when setting up EF Core in a new project, optimizing query performance, managing database migrations, integrating EF Core with .NET Aspire, or debugging change tracking issues.
development8
dotnet-xunit
Writing xUnit tests. v3 Fact/Theory, fixtures, parallelism, IAsyncLifetime, v2 compatibility.
tools8
exception-handling
Comprehensive exception handling patterns for ASP.NET Core Razor Pages applications. Covers global exception handling, ProblemDetails API, custom error pages, exception middleware, and graceful degradation strategies. Use when implementing error handling in Razor Pages applications, configuring global exception middleware, or creating user-friendly error pages and API error responses.
development8
feature-flags
Microsoft.FeatureManagement patterns for feature toggles, gradual rollouts, and A/B testing in ASP.NET Core Razor Pages applications. Use when implementing feature toggles in ASP.NET Core applications, setting up gradual feature rollouts, or configuring A/B testing scenarios with feature flags.
testing8
file-handling
File uploads, streaming, storage abstractions, and secure file handling patterns for ASP.NET Core Razor Pages applications. Use when implementing secure file uploads in Razor Pages, streaming large files, or creating storage abstractions for file operations.
data-ai8
fly-io
Deploy, configure, and manage applications on the Fly.io platform using flyctl CLI, fly.toml configuration, Fly Machines, Fly Volumes, private networking, secrets, health checks, autoscaling, and GitHub Actions CI/CD. Use when deploying any application to Fly.io, writing or modifying fly.toml configuration, managing Fly Machines or Volumes, configuring networking (public services, private 6PN, Flycast, custom domains, TLS), setting secrets, configuring health checks, setting up autostop/autostart or metrics-based autoscaling, deploying with GitHub Actions, managing Fly Postgres databases, or preparing an app for production on Fly.io.
tools8
http-client-resilience
IHttpClientFactory patterns with Polly for retries, circuit breakers, timeouts, and resilient HTTP communication. Includes best practices for HTTP client configuration and error handling. Use when configuring resilient HTTP clients in ASP.NET Core, implementing retry policies with Polly, or setting up circuit breakers for external service calls.
tools8
logging-observability
Production-grade logging and observability patterns for ASP.NET Core Razor Pages. Covers structured logging with Serilog, correlation IDs, health checks, request logging, OpenTelemetry integration, and diagnostic best practices. Use when setting up structured logging in ASP.NET Core applications, implementing distributed tracing with OpenTelemetry, or configuring health checks and observability.
testing8
playwright-ci-caching
Optimize CI/CD pipelines by caching Playwright browser binaries and dependencies to speed up test execution. Use when setting up Playwright in CI/CD pipelines, reducing build times by caching browser binaries, or configuring GitHub Actions or Azure DevOps for Playwright tests.
development8
package-management
NuGet package management best practices including versioning strategies, central package management, and dependency resolution. Use when setting up Central Package Management (CPM), managing package versions across multiple projects, or resolving dependency conflicts in .NET solutions.
tools8
mjml-email-templates
Guidelines for creating responsive email templates using MJML framework with .NET Razor syntax integration. Use when building responsive email templates in .NET applications, integrating MJML with Razor views, or creating email layouts that work across email clients.
tools8
microsoft-extensions-dependency-injection
Dependency injection patterns and best practices using Microsoft.Extensions.DependencyInjection for .NET applications. Use when configuring DI containers in .NET, choosing between service lifetimes (Singleton, Scoped, Transient), or implementing decorator patterns and service interception.
tools8
microsoft-extensions-configuration
Configuration patterns using Microsoft.Extensions.Configuration. Covers configuration providers, binding, validation, and best practices for .NET applications. Use when setting up configuration in .NET applications, implementing configuration validation with IValidateOptions, or managing settings across different environments.
tools8
dotnet-wpf-migration
Migrating desktop apps. WPF/WinForms to .NET 8+, WPF to WinUI or Uno, UWP to WinUI, decision matrix.
testing8
dotnet-winui
Building WinUI 3 apps. Windows App SDK setup, XAML patterns, MSIX/unpackaged deploy, UWP migration.
development8
dotnet-winforms-basics
Building WinForms on .NET 8+. High-DPI, dark mode (experimental), DI patterns, modernization tips.
development8
dotnet-uno-targets
Deploying Uno Platform apps. Per-target guidance for WASM, iOS, Android, macOS, Windows, Linux.
devops8
dotnet-terminal-gui
Building full TUI apps. Terminal.Gui v2: views, layout (Pos/Dim), menus, dialogs, bindings, themes.
development8
dotnet-system-commandline
Using System.CommandLine 2.0. Commands, options, SetAction, custom parsing, middleware, testing.
testing8
dotnet-solution-navigation
Orienting in a .NET solution. Entry points, .sln/.slnx files, dependency graphs, config.
tools8
dotnet-security-owasp
Securing .NET code or reviewing for vulnerabilities. OWASP Top 10 mitigations, pattern warnings.
development8
dotnet-project-analysis
Navigating .NET solution structure or build configuration. Analyzes .sln, .csproj, CPM.
development8
dotnet-performance-patterns
Optimizing .NET allocations/throughput. Span, ArrayPool, ref struct, sealed, stackalloc.
tools8
dotnet-nuget-authoring
Creating NuGet packages. SDK-style csproj, source generators, multi-TFM, symbols, signing.
development8
dotnet-msbuild-authoring
Authoring MSBuild targets, props, or conditions. Custom targets, incrementality, Build patterns.
development8
dotnet-minimal-apis
Building Minimal APIs. Route groups, endpoint filters, TypedResults, OpenAPI 3.1, organization.
development8
dotnet-messaging-patterns
Building event-driven systems. Pub/sub, competing consumers, DLQ, sagas, delivery guarantees.
development8
dotnet-maui-development
Building .NET MAUI apps. Project structure, XAML/MVVM, platform services, current caveats.
development8
dotnet-io-pipelines
Building high-perf network I/O. PipeReader/PipeWriter, backpressure, protocol parsers, Kestrel.
development8
dotnet-integration-testing
Testing with real infrastructure. WebApplicationFactory, Testcontainers, Aspire, fixtures.
development8
dotnet-github-releases
Creating GitHub Releases for .NET. Release creation, assets, notes, pre-release management.
tools8
dotnet-gha-deploy
Deploying .NET from GitHub Actions. Azure Web Apps, GitHub Pages, container registries.
development8
dotnet-gha-build-test
Configuring .NET build/test in GitHub Actions. setup-dotnet, NuGet caching, test reporting.
development8
dotnet-efcore-architecture
Designing data layer architecture. Read/write split, aggregate boundaries, N+1 governance.
development8
dotnet-domain-modeling
Modeling business domains. Aggregates, value objects, domain events, rich models, repositories.
data-ai8
dotnet-documentation-strategy
Choosing documentation tooling. Starlight, Docusaurus, DocFX decision tree, migration paths.
tools8
dotnet-csharp-configuration
Using Options pattern, user secrets, or feature flags. IOptions<T> and FeatureManagement.
tools8
dotnet-csharp-code-smells
Reviewing C# for logic issues. Anti-patterns, common pitfalls, async misuse, DI mistakes.
development8
dotnet-csharp-async-patterns
Writing async/await code. Task patterns, ConfigureAwait, cancellation, and common agent pitfalls.
development8
dotnet-containers
Containerizing .NET apps. Multi-stage Dockerfiles, SDK container publish (.NET 8+), rootless.
development8
dotnet-cli-release-pipeline
Releasing CLI tools. GitHub Actions build matrix, artifact staging, Releases, checksums.
tools8
dotnet-build-optimization
Diagnosing slow builds or incremental failures. Binary logs, parallel builds, restore.
development8
dotnet-blazor-testing
Testing Blazor components. bUnit rendering, events, cascading params, JS interop mocking.
testing8
dotnet-blazor-patterns
Building Blazor apps. Hosting models, render modes, routing, streaming rendering, prerender.
development8
dotnet-blazor-auth
Adding auth to Blazor. AuthorizeView, CascadingAuthenticationState, Identity UI, per-model flows.
data-ai8
dotnet-benchmarkdotnet
Writing benchmarks. BenchmarkDotNet setup, memory diagnosers, baselines, result analysis.
research8
dotnet-architecture-patterns
Organizing APIs at scale. Vertical slices, request pipelines, caching, error handling, idempotency.
development8
dotnet-api-docs
Generating API documentation. DocFX setup, OpenAPI-as-docs, doc-code sync, versioned docs.
development8
dotnet-aot-architecture
Designing AOT-first apps. Source gen over reflection, AOT-safe DI, serialization, factories.
content-media8
dotnet-add-testing
Adding test infrastructure to a .NET project. Scaffolds xUnit project, coverlet, layout.
testing8
data-protection
ASP.NET Core Data Protection API patterns for encryption, key management, and secure data handling in web applications. Use when protecting sensitive data at rest or in transit, managing encryption keys in ASP.NET Core applications, or implementing secure token generation and validation.
development8
database-performance
Database access patterns for performance. Separate read/write models, avoid N+1 queries, use AsNoTracking, apply row limits, and never do application-side joins. Works with EF Core and Dapper. Use when designing data access layers, optimizing slow database queries, choosing between EF Core and Dapper, or avoiding common performance pitfalls.
documentation8
type-design-performance
Design .NET types for performance. Covers struct vs class decision matrix, sealed by default, readonly structs, ref struct and Span/Memory selection, FrozenDictionary, ValueTask, and collection return types. Use when designing new types and APIs, reviewing code for performance issues, choosing between class, struct, and record, or working with collections and enumerables.
development8
csharp-scripts
Run single-file C# programs as scripts for quick experimentation, prototyping, and concept testing. Use when the user wants to write and execute a small C# program without creating a full project.
testing8
api-design
Design stable, compatible public APIs using extend-only design principles. Manage API compatibility, wire compatibility, versioning, naming conventions, parameter ordering, and return types for NuGet packages and distributed systems. Use when designing public APIs for NuGet packages or libraries, making changes to existing public APIs, planning wire format changes for distributed systems, or reviewing pull requests for breaking changes.
development8
crap-analysis
Analyze code coverage and CRAP (Change Risk Anti-Patterns) scores to identify high-risk code. Use OpenCover format with ReportGenerator for Risk Hotspots showing cyclomatic complexity and untested code paths. Use when evaluating code quality and test coverage before changes, identifying high-risk code that needs refactoring or testing, setting up coverage collection for a .NET project, or establishing coverage thresholds for CI/CD pipelines.
development8
clawddocs
Clawdbot documentation expert with decision tree navigation, search scripts, doc fetching, version tracking, and config snippets for all Clawdbot features
testing8
caching-strategies
Comprehensive caching patterns for ASP.NET Core Razor Pages applications. Covers output caching, response caching, memory caching, distributed caching with Redis, cache invalidation strategies, and HybridCache (.NET 9+). Use when implementing caching in Razor Pages applications, choosing between memory and distributed caching, or optimizing application performance with caching.
databases8
self-improvement
Captures learnings, errors, and corrections to enable continuous improvement. Use when: (1) A command or operation fails unexpectedly, (2) User corrects Claude ('No, that's wrong...', 'Actually...'), (3) User requests a capability that doesn't exist, (4) An external API or tool fails, (5) Claude realizes its knowledge is outdated or incorrect, (6) A better approach is discovered for a recurring task. Also review learnings before major tasks.
tools8
security-headers
Security headers configuration and best practices for ASP.NET Core Razor Pages applications. Covers CSP, HSTS, X-Frame-Options, and comprehensive security middleware setup. Use when configuring security headers in ASP.NET Core applications, implementing Content Security Policy (CSP), or setting up HSTS and other security-related HTTP headers.
testing8
Razor Pages Patterns
Best practices for building production-grade ASP.NET Core Razor Pages applications. Focuses on structure, lifecycle, binding, validation, security, and maintainability in web apps using Razor Pages as the primary UI framework. Use when building Razor Pages applications, designing PageModels and handlers, implementing model binding and validation, or securing Razor Pages with authentication and authorization.
development8
project-structure
Guidelines for organizing .NET projects, including solution structure, project references, folder conventions, .slnx format, centralized build properties, and central package management. Use when setting up a new .NET solution with modern best practices, configuring centralized build properties across multiple projects, implementing central package version management, or setting up SourceLink for debugging.
development8
business-ux-design-review
Review business goals, PRDs, business flows, user journeys, and UX/interaction designs for completeness, clarity, logical consistency, and alignment with user needs. Use when the user asks to review a business goal/design proposal, PRD, process flow, user journey, or interaction plan.
development8
bootstrap5-ui
Production-grade Bootstrap 5.3 patterns for building modern, responsive web UIs in HTML and ASP.NET Core Razor Pages/Views. Use when creating or styling web pages, layouts, navigation, forms, cards, modals, tables, or any UI component with Bootstrap 5. Covers the grid system, responsive breakpoints, utility classes, color modes (dark/light), accessibility, and integration with ASP.NET Core tag helpers and Razor syntax. Trigger on any task involving Bootstrap CSS classes, responsive HTML layouts, Razor Page UI design, or front-end styling for .NET web applications.
tools8
asp-net-core-identity-patterns
Production-grade patterns for ASP.NET Core Identity in Razor Pages and web apps. Covers setup, customization, security hardening, auth flows, roles/claims, external providers, and integration best practices for .NET 8+ / .NET 9+. Use when implementing authentication and authorization in ASP.NET Core applications, configuring ASP.NET Core Identity, setting up external login providers, or managing roles and claims.
development8
aspire-service-defaults
Create a shared ServiceDefaults project for Aspire applications. Centralizes OpenTelemetry, health checks, resilience, and service discovery configuration across all services. Use when building Aspire-based distributed applications, needing consistent observability across services, or configuring HttpClient resilience and service discovery.
tools8
mailpit-integration
Test email sending locally using Mailpit with .NET Aspire. Captures all outgoing emails without sending them. View rendered HTML, inspect headers, and verify delivery in integration tests. Use when testing email delivery locally without sending real emails, setting up email infrastructure in .NET Aspire, or writing integration tests that verify emails are sent.
development8
agent-browser
Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction.
tools8