Tyler-R-Kendrick

Guidance for globalization and localization in .NET. USE FOR: culture-aware formatting, request localization middleware, date/number/currency formatting across cultures, locale-sensitive string comparison. DO NOT USE FOR: simple resource file lookup (use resources-localization), ICU message formatting (use messageformat-net), general i18n architecture (use i18n).

Use when designing how messages are reshaped, enriched, filtered, or normalised as they flow between systems based on Enterprise Integration Patterns (Hohpe & Woolf). USE FOR: message transformation, envelope wrapping, content enrichment, content filtering, claim check, normalisation, canonical data models DO NOT USE FOR: routing messages (use message-routing), message format (use message-construction)

Create new Azure Database for PostgreSQL Flexible Server instances and configure passwordless authentication with Microsoft Entra ID. Set up developer access, managed identities for apps, group-based permissions, and migrate from password-based to Entra ID authentication. Trigger phrases include "passwordless for postgres", "entra id postgres", "azure ad postgres authentication", "postgres managed identity", "migrate postgres to passwordless".

**CRITICAL**: Run azure-validate before deploying Azure resources. Validates Azure deployment readiness. USE FOR: assess if application is ready to deploy to Azure, validate azure.yaml or Bicep configuration files, run Azure preflight checks, review deployment previews and what-if analysis, verify Azure infrastructure configuration, troubleshoot Azure deployment errors. DO NOT USE FOR: creating new applications (use azure-prepare), executing deployments (use azure-deploy).

Use when building message-driven .NET applications with Rebus, a lean and extensible service bus supporting multiple transports. USE FOR: lightweight service bus messaging, pub/sub with RabbitMQ or Azure Service Bus, saga orchestration, message routing, deferred messages, transport-agnostic messaging DO NOT USE FOR: in-process mediator pattern (use mediatr), enterprise service bus with commercial support (use nservicebus), actor concurrency model (use akka-net)

Guidance for Markdig Markdown processor for .NET. USE FOR: converting Markdown to HTML, building custom Markdown pipelines, parsing Markdown AST, supporting CommonMark and extensions (tables, task lists, emoji, math), generating documentation from Markdown sources. DO NOT USE FOR: rich text editing UI (use a WYSIWYG editor), PDF generation from Markdown (convert to HTML first then use a PDF library), plain text formatting.

Guidance for PdfPig PDF reading and content extraction library for .NET. USE FOR: extracting text from PDFs, reading PDF metadata, extracting images from PDF pages, word-level and letter-level text extraction, searching PDF content, analyzing PDF document structure. DO NOT USE FOR: creating or generating PDFs (use PdfSharpCore or QuestPDF), editing existing PDFs, PDF form filling, rendering PDFs to images.

Guidance for Topaz fine-grained, relationship-based authorization. USE FOR: fine-grained permissions, relationship-based access control (ReBAC), Google Zanzibar-style authorization, directory-based identity resolution, policy-as-code with OPA/Rego, hierarchical permission models (owner > editor > viewer). DO NOT USE FOR: simple RBAC (use Casbin/Enforcer), authentication (use ASP.NET Core Identity), input sanitization (use Hygiene), or encryption (use CryptoNet).

USE FOR: Building 2D and 3D games, simulations, and interactive 3D applications using the Wave Engine (Evergine) with C#. Use when you need a component-based game engine with .NET integration, PBR rendering, and cross-platform support. DO NOT USE FOR: Business applications or web UIs (use Blazor or ASP.NET Core), simple 2D-only games where MonoGame is sufficient, or projects requiring the largest community and asset ecosystem (use Unity).

Use when identifying export control and sanctions laws that affect software distribution and encryption. Covers US EAR and ITAR, EU Dual-Use Regulation, Wassenaar Arrangement, OFAC sanctions, and encryption export rules that apply to software products distributed internationally. USE FOR: export controls, EAR, ITAR, OFAC sanctions, Wassenaar Arrangement, encryption export, ECCN, dual-use technology, embargoed countries, deemed exports, open-source encryption exemptions DO NOT USE FOR: implementing encryption (use security/cryptography), trade secret protection (use intellectual-property), general international business law (consult trade counsel)

Guidance for Python project configuration and packaging using pyproject.toml, build backends, and modern PEP standards. USE FOR: creating pyproject.toml, configuring build backends (setuptools, hatchling, flit-core, maturin, poetry-core, pdm-backend), entry points, version management, publishing to PyPI, editable installs, monorepo patterns DO NOT USE FOR: installing packages or managing dependencies at runtime (use package-management), building CLI applications (use cli)

Use when securing APIs against common attack vectors. Covers rate limiting, CORS configuration, Content Security Policy, security headers, API gateway patterns, and API authentication strategies. USE FOR: API security, rate limiting, CORS, CSP, security headers, API gateway, API authentication, API keys, OAuth for APIs, HTTPS enforcement, request validation DO NOT USE FOR: API design patterns (use dev/backend/api-design), API testing tools (use testing/api-testing), authentication protocol details (use authentication)

Use when securing the software supply chain — dependencies, build pipelines, and artifact integrity. Covers SBOMs, dependency scanning, SLSA framework, artifact signing, and reproducible builds. USE FOR: SBOM, software bill of materials, dependency scanning, SLSA framework, artifact signing, reproducible builds, SCA, Dependabot, Snyk, Trivy, Grype, CycloneDX, SPDX DO NOT USE FOR: runtime vulnerability detection (use security-testing), container runtime security (use security-testing), secrets in code detection (use security-testing)

Use when creating entity-relationship diagrams for database design and data modeling. Covers entity types, attributes, relationships, cardinality, Chen and Crow's Foot notation, normalization forms, and Mermaid ERD syntax. USE FOR: database schema design, data modeling, entity-relationship diagrams, cardinality and relationship mapping, normalization analysis, Mermaid ERD syntax, Chen notation, Crow's Foot notation, physical and logical data models DO NOT USE FOR: application architecture (use c4-diagrams or uml), behavioral modeling (use uml or functional-diagrams), general flowcharts (use mermaidjs)

Use when modeling software systems using the Unified Modeling Language (UML) standard. Covers structural and behavioral diagram types, notation, relationships, multiplicity, visibility, and stereotypes. USE FOR: class diagrams, sequence diagrams, activity diagrams, state machine diagrams, use case diagrams, component diagrams, deployment diagrams, package diagrams, object diagrams, UML notation reference, relationship types, multiplicity, visibility modifiers, stereotypes DO NOT USE FOR: text-based diagram rendering (use mermaidjs, plantuml, or d2), enterprise architecture views (use togaf or archimate), data modeling (use erd)

Use when designing or implementing chaos engineering experiments to verify system resilience under failure conditions. Covers chaos engineering principles, steady-state hypothesis, blast radius management, game days, and tools like Chaos Monkey, Gremlin, Litmus, Chaos Mesh, Toxiproxy, and cloud-native fault injection services. USE FOR: chaos engineering, fault injection, resilience testing, game days, steady-state hypothesis, blast radius, Chaos Monkey, Gremlin, Litmus, Chaos Mesh, Toxiproxy, AWS Fault Injection Service, Azure Chaos Studio DO NOT USE FOR: load testing without fault injection (use performance-testing), general system monitoring (use logging-monitoring), disaster recovery planning (use architecture skills)

Use when writing PowerShell scripts or automating tasks with PowerShell 7+ (the cross-platform edition). Covers cmdlet patterns, pipeline, objects vs text, modules, error handling, remoting, and differences from Windows PowerShell 5.1. USE FOR: PowerShell 7, PowerShell Core, pwsh, cmdlets, PowerShell pipeline, PowerShell modules, PowerShell remoting, cross-platform scripting, PowerShell profiles, PSReadLine, PowerShell error handling DO NOT USE FOR: Bash/Zsh scripting (use bash), Windows-only legacy PowerShell 5.1 (still relevant but this skill focuses on 7+), system administration deep dives (use platform-specific skills)

Use when building distributed, stateful applications with Microsoft Orleans. Covers grain design, state persistence, streams, timers, reminders, clustering, and ASP.NET Core co-hosting for virtual actor workloads. USE FOR: distributed virtual actor systems, per-entity stateful services (IoT devices, user sessions, game objects), scalable real-time applications, grain-based event processing, geographically distributed stateful workloads DO NOT USE FOR: stateless HTTP APIs without actor patterns (use ASP.NET Core), simple background tasks (use IHostedService), Dapr actor model (use dapr), ML model training (use mlnet), serverless event processing (use azure-functions)

Guidance for Olive productivity framework for .NET. USE FOR: common string extensions (null-safe operations, validation), collection utilities, date/time helpers, file name sanitization, fluent API helpers, reducing boilerplate in business applications. DO NOT USE FOR: full web frameworks (use ASP.NET Core), ORM functionality (use EF Core), UI frameworks, large-scale enterprise architecture.

USE FOR: Making HTTP API calls using RestSharp's fluent request builder with automatic serialization, authenticators, and response handling. Use when consuming REST APIs that need configurable serialization, file uploads, and built-in authentication support without defining interfaces. DO NOT USE FOR: Type-safe compile-time API clients (use Refit), GraphQL queries (use StrawberryShake), or new projects where HttpClientFactory with source-generated serialization is preferred (use HttpClient with System.Text.Json).

Use when addressing security risks specific to AI and LLM applications. Covers OWASP Top 10 for LLM Applications (2025), prompt injection, model poisoning, excessive agency, insecure output handling, AI red teaming, and responsible AI frameworks. USE FOR: LLM security, prompt injection, model poisoning, excessive agency, AI red teaming, OWASP LLM Top 10, insecure output handling, responsible AI, AI governance, supply chain security for ML models DO NOT USE FOR: general web application security (use owasp), traditional application testing (use security-testing), ML model training and optimization (use AI/ML skills)

Use when planning or conducting adversarial red team engagements that test an organization's detection, response, and resilience capabilities beyond traditional penetration testing. Covers red team vs pen test distinctions, adversary simulation frameworks (MITRE ATT&CK, Cyber Kill Chain), purple teaming, C2 frameworks, and AI/LLM red teaming. USE FOR: red teaming, adversary simulation, MITRE ATT&CK, Cyber Kill Chain, purple teaming, C2 frameworks, assumed breach, attack path mapping, detection testing, AI red teaming, LLM red teaming, tabletop exercises DO NOT USE FOR: automated vulnerability scanning (use security-testing), initial vulnerability discovery (use penetration-testing), threat modeling during design (use threat-modeling)

Use when integrating security into the software development lifecycle. Covers security gates, shift-left security, DevSecOps practices, security champions programs, and security review processes. USE FOR: secure SDLC, DevSecOps, shift-left security, security gates, security review, security champions, SDL, security requirements, security architecture review DO NOT USE FOR: specific security tools (use security-testing), threat modeling methodology (use threat-modeling), compliance frameworks (use data-protection)

Use when creating architecture diagrams with the D2 declarative diagramming language by Terrastruct. D2 offers advanced layout control, nested containers, scenarios, and multiple rendering engines. USE FOR: architecture diagrams, system design diagrams, declarative diagramming, nested container diagrams, sequence diagrams, grid layouts, SQL table diagrams, scenario-based diagrams, diagrams requiring advanced layout control, D2 syntax, D2 CLI usage DO NOT USE FOR: GitHub-native diagram rendering (use mermaidjs), C4 model diagrams (use c4-diagrams), UML specification compliance (use uml or plantuml)

Guidance for System.IO.Abstractions file system abstraction library. USE FOR: wrapping file and directory operations for testability, mocking file system access in unit tests, replacing static File/Directory/Path calls with injectable interfaces, using MockFileSystem for deterministic test scenarios, testing code that reads/writes files. DO NOT USE FOR: actual file I/O performance optimization, replacing stream-based APIs, or scenarios where you need raw file system performance without abstraction overhead.

USE FOR: Designing domain models where invalid states are unrepresentable by parsing raw input into strongly-typed value objects at system boundaries. Use when enforcing invariants through the type system rather than runtime validation checks. DO NOT USE FOR: Quick prototypes where validation overhead is premature, thin CRUD layers that pass DTOs directly to the database, or scenarios where FluentValidation with error collection is required for user-facing form feedback.

Use when creating data flow diagrams (DFD), functional decomposition trees, IDEF0 diagrams, or BPMN process models. Covers process-oriented and data-oriented diagram types for analyzing system behavior and data transformation. USE FOR: data flow diagrams (DFD), functional decomposition, IDEF0 modeling, BPMN process modeling, process analysis, data transformation visualization, system behavior documentation, input-output analysis DO NOT USE FOR: object-oriented modeling (use uml), system container decomposition (use c4-diagrams), enterprise architecture (use togaf or archimate)

Use when setting up dev containers with sidecar services like databases, caches, or message brokers. Covers Docker Compose integration, service networking, and multi-service devcontainer.json configuration. USE FOR: Docker Compose sidecar services, database/cache/queue containers alongside dev containers, multi-service networking, service health checks DO NOT USE FOR: general devcontainer.json schema (use devcontainer), Docker-in-Docker for building images (use docker-in-docker), production Kubernetes deployment (use iac/kubernetes)

USE FOR: In-memory caching with IMemoryCache, distributed caching with IDistributedCache, output caching in ASP.NET Core, hybrid cache strategies, and cache invalidation patterns. DO NOT USE FOR: Persistent data storage, session state management without a backing store, or scenarios requiring strong consistency guarantees across nodes.

USE FOR: Configuration-driven feature flags, percentage-based rollouts, time-windowed features, user-targeting filters, feature gates in ASP.NET Core controllers and Razor pages, and Azure App Configuration integration. DO NOT USE FOR: Runtime compatibility switches (use AppContext), A/B testing with analytics integration (use a dedicated experimentation platform), or non-.NET clients needing a vendor-neutral SDK (use OpenFeature).

USE FOR: Configuring resilience pipelines using Microsoft.Extensions.Resilience for retries, timeouts, circuit breakers, rate limiting, and hedging in ASP.NET Core and HttpClient workflows. DO NOT USE FOR: Legacy Polly v7 policy syntax, non-.NET resilience (use infrastructure-level tools), or application-level error handling that does not involve transient fault tolerance.

Use when designing how messages are directed, split, aggregated, and orchestrated across enterprise systems based on Enterprise Integration Patterns (Hohpe & Woolf). USE FOR: content-based routing, message filtering, splitter/aggregator, scatter-gather, routing slip, process manager, dynamic routing, recipient lists DO NOT USE FOR: message format (use message-construction), message transformation (use message-transformation)

USE FOR: Building real-time web features using ASP.NET Core SignalR with WebSocket, Server-Sent Events, and long polling transports. Use when implementing live chat, notifications, dashboards, collaborative editing, or any scenario requiring server-to-client push messaging. DO NOT USE FOR: Request-response APIs without real-time requirements (use minimal APIs or controllers), message queuing between backend services (use RabbitMQ, Azure Service Bus, or MassTransit), or streaming large file transfers (use HTTP streaming or gRPC server streaming).

Use when choosing or configuring a TypeScript/JavaScript runtime environment. Covers the runtime landscape including Node.js, Deno, and Bun with feature comparisons, architectural differences, and selection guidance. USE FOR: comparing JavaScript runtimes, choosing between Node.js and Deno and Bun, understanding runtime capabilities, TypeScript execution environments, server-side JavaScript platform selection, runtime migration planning DO NOT USE FOR: specific Node.js APIs or patterns (use node), Deno-specific features or Deno Deploy (use deno), frontend framework selection (use nextjs or relevant framework skill), package manager comparison (use package-management)

Use when working with Figma as the design source for a design system — including Variables, Dev Mode, Code Connect, the REST API, and MCP-based design-to-code workflows. USE FOR: Figma Variables, Figma Dev Mode, Code Connect, Figma REST API, Tokens Studio plugin, Figma MCP server, design-to-code handoff DO NOT USE FOR: token file format details (use design-tokens), token build pipelines (use style-dictionary), component documentation (use storybook)

Use when designing caching strategies — choosing between cache-aside, read-through, write-through, write-behind, and write-around patterns, planning cache invalidation, and implementing multi-tier caching architectures. USE FOR: caching strategy selection, cache invalidation, cache-aside pattern, read-through/write-through/write-behind patterns, CDN caching, HTTP caching, Redis/Memcached architecture, multi-tier caching, cache stampede prevention DO NOT USE FOR: database design (use data-modeling), API endpoint design (use api-design), CDN infrastructure setup (use iac)

Gang of Four (GoF) design patterns — 23 proven object-oriented solutions organized into Creational, Structural, and Behavioral categories, drawn from Gamma, Helm, Johnson, and Vlissides. USE FOR: GoF design patterns, pattern selection, object-oriented design, creational/structural/behavioral patterns, composition over inheritance DO NOT USE FOR: enterprise messaging patterns (use dev/integration-patterns), architecture styles (use dev/architecture), algorithm selection (use dev/algorithms)

Use when configuring dev containers for .NET Aspire projects. Covers the Aspire workload, Docker-in-Docker requirement, dashboard port forwarding, and multi-service orchestration in Codespaces. USE FOR: .NET Aspire dev containers, Aspire workload in Codespaces, Aspire dashboard port forwarding, Aspire + Docker-in-Docker setup DO NOT USE FOR: general .NET dev containers without Aspire (use dotnet), standalone Docker-in-Docker (use docker-in-docker), general devcontainer.json (use devcontainer)

Guidance for NLog logging framework in .NET. USE FOR: NLog target configuration, layout renderers, structured logging with NLog, async logging, conditional routing, custom targets, NLog integration with ASP.NET Core. DO NOT USE FOR: Microsoft.Extensions.Logging abstractions (use extensions-logging), Serilog sinks and enrichers (use serilog), OpenTelemetry log export (use otlp-logging).

USE FOR: Building console applications, background services, and worker processes with standardized DI, configuration, logging, and graceful shutdown. Hosting long-running IHostedService and BackgroundService implementations, and composing application startup pipelines. DO NOT USE FOR: ASP.NET Core web applications (use WebApplication.CreateBuilder), desktop UI applications without background services, or simple scripts that do not need DI or configuration.

Use when applying functional programming patterns and principles in C# including immutability, pure functions, higher-order functions, and monadic patterns. USE FOR: functional programming concepts in C#, immutability patterns, pure functions, LINQ as functional operations, pattern matching, monadic error handling, higher-order functions DO NOT USE FOR: F# language specifics (use fsharp), specific FP library APIs (use language-ext), parser combinators (use pidgin or fparsec)

USE FOR: Writing concise, consistent guard clauses using CommunityToolkit.Diagnostics for argument validation, null checks, range checks, and string validation in constructors, methods, and factory methods. DO NOT USE FOR: Complex business rule validation (use FluentValidation or Peasy), user-facing form validation with error messages (use DataAnnotations), or replacing domain-level parsing/validation (use Parse Don't Validate pattern).

Use when designing observability, testing, debugging, and operational control for messaging systems based on Enterprise Integration Patterns (Hohpe & Woolf). USE FOR: messaging observability, wire tap, control bus, message history, message store, monitoring messaging systems, testing message flows, debugging async systems DO NOT USE FOR: message routing (use message-routing), consumer patterns (use messaging-endpoints)

USE FOR: Reacting to configuration or file changes with IChangeToken, building custom change-notification providers, efficient string segmentation with StringSegment and StringTokenizer, and composing change signals with CompositeChangeToken. DO NOT USE FOR: General-purpose eventing (use System.Reactive or channels), UI data binding, or scenarios where full pub/sub messaging is needed.

USE FOR: Building incremental source generators that emit C# code at compile time, including syntax providers, semantic model queries, attribute-driven generation, and diagnostic reporting. DO NOT USE FOR: IL weaving (use Fody), T4 text templates, runtime code generation with Reflection.Emit, or analyzers that only report diagnostics without generating code.

USE FOR: Loading application settings from JSON files, environment variables, command-line arguments, user secrets, Azure Key Vault, and custom providers. Binding configuration sections to strongly-typed options classes with validation. DO NOT USE FOR: Feature flags (use Microsoft.FeatureManagement), runtime state that changes per request, or secrets that should live exclusively in a vault without local fallback.

USE FOR: Building Blazor applications with a rich component library that abstracts over CSS frameworks like Bootstrap, Bulma, Material, and Ant Design. Use when you need pre-built UI components (DataGrid, Charts, Modals) with consistent theming across providers. DO NOT USE FOR: Non-Blazor projects, applications that need pixel-perfect custom UI unrelated to any CSS framework, or scenarios where you want to avoid third-party component library dependencies.

Use when writing or managing AWS CloudFormation templates. Covers stack resources, parameters, outputs, intrinsic functions, nested stacks, and change sets. USE FOR: AWS stack provisioning, CloudFormation YAML/JSON templates, intrinsic functions, nested stacks, change sets DO NOT USE FOR: Azure infrastructure (use bicep or arm), multi-cloud infrastructure (use terraform or pulumi), Kubernetes resources (use kubernetes)

Use when identifying digital accessibility laws and standards that apply to software products. Covers ADA, Section 508, European Accessibility Act, WCAG standards, and emerging accessibility regulations globally with compliance requirements and litigation risks. USE FOR: ADA compliance, Section 508, European Accessibility Act, WCAG, EN 301 549, digital accessibility law, accessibility lawsuits, accessibility statements, VPAT, ACR DO NOT USE FOR: WCAG implementation techniques (use testing/accessibility-testing), accessibility testing tools (use testing/accessibility-testing), UI component design (use design-system skills)

Use when identifying AI-specific regulations and compliance requirements that apply to AI/ML-powered software products. Covers the EU AI Act, US AI executive orders, China's AI regulations, and emerging global frameworks with risk classification and compliance obligations. USE FOR: EU AI Act, AI regulation, AI risk classification, AI transparency, AI liability, algorithmic accountability, AI ethics compliance, US AI executive orders, China AI rules, AI auditing requirements DO NOT USE FOR: AI security vulnerabilities (use security/ai-security), ML model development (use AI skills), responsible AI ethics without legal dimension (use security/ai-security)

Use when setting up or using GitHub Spec Kit for spec-driven development — where specifications define the "what" before the "how." Covers slash commands for constitution definition, specification generation, clarification, implementation planning, task breakdown, analysis, and implementation execution. USE FOR: spec-driven development, GitHub Spec Kit setup, speckit slash commands, constitution definition, specification generation, implementation planning, task breakdown DO NOT USE FOR: writing specifications manually (use prd, trd, or brd), creating diagrams (use diagramming sub-skills), test automation (use gherkin or gauge)

Use for testing HTTP endpoints directly using cross-platform API testing tools. Covers .http files (VS Code REST Client, JetBrains HTTP Client), Bruno collections, Postman/Newman, k6 for functional API verification, environment management, and CI integration patterns. USE FOR: .http files, Bruno, Postman, Newman, REST Client, k6 API tests, HTTP endpoint testing, API collections, environment variables, API functional verification, HTTP request scripting, API test automation DO NOT USE FOR: browser-based testing (use e2e-testing), contract verification between services (use contract-testing), load/stress testing at scale (use performance-testing)

Use when writing, improving, or debugging end-to-end tests that verify full user flows through the real system. Covers Playwright, Cypress, Selenium, Appium, and Maestro with Page Object Model pattern, critical path testing, codegen, and cross-browser/mobile strategies. USE FOR: Playwright, Cypress, Selenium, Appium, Maestro, browser testing, mobile testing, critical path tests, page object pattern, codegen DO NOT USE FOR: API-only testing (use api-testing or integration-testing), isolated function tests (use unit-testing), service contract verification (use contract-testing)

File a GitHub issue for local integration test failures. TRIGGERS: file test bug, report test failure, create bug for test, integration test failed, test failure issue, junit failure

Use when executing external command-line processes from .NET with CliWrap. Covers fluent command building, output capturing, piping, streaming, cancellation, and environment variable configuration. USE FOR: executing CLI tools from .NET code, capturing stdout/stderr output, piping between processes, streaming large command output, running git/docker/npm from C# applications DO NOT USE FOR: building CLI argument parsers (use commandline-cheatsheet or spectre-console), rendering terminal UI (use spectre-console), running in-process code (use Task.Run), simple Process.Start without advanced piping

USE FOR: High-performance SQL queries mapped to POCOs, read-heavy and latency-critical data access, stored procedure invocation, multi-mapping joins, bulk operations, and scenarios requiring full SQL control. DO NOT USE FOR: Schema migrations (use EF Core or FluentMigrator), complex object-graph change tracking, or applications where a full ORM with lazy loading is needed.

USE FOR: Running Apache Spark jobs from C# or F#, distributed big data processing with DataFrames and RDDs, Spark SQL queries from .NET, ETL pipelines at scale, and integration with Hadoop ecosystem data sources. DO NOT USE FOR: Small-dataset processing that fits in memory (use LINQ), real-time stream processing without Spark Streaming, general-purpose .NET microservices, or scenarios where .NET for Apache Spark (Microsoft.Spark) is preferred on .NET Core.

Guidance for Moq mocking framework for .NET unit testing. USE FOR: creating mock objects for interfaces, stubbing method return values, verifying method invocations, argument matching and capture, testing code in isolation from dependencies, simulating exceptions and async behavior in unit tests. DO NOT USE FOR: integration testing with real dependencies (use Testcontainers), mocking static methods or sealed classes (use shims or wrappers), or end-to-end testing.

USE FOR: Building 2D and 3D games with C# using the MonoGame framework. Use when creating cross-platform games for Windows, macOS, Linux, iOS, Android, and consoles with low-level control over rendering, audio, and input. DO NOT USE FOR: Business applications or form-based UIs (use Blazor, MAUI, or WPF), high-fidelity AAA 3D games requiring a full editor workflow (use Unity or Unreal), or applications that do not need a game loop.

USE FOR: Building GraphQL APIs in .NET using Hot Chocolate. Use when clients need flexible query capabilities, field selection, and efficient data fetching across related entities without over-fetching or under-fetching. DO NOT USE FOR: Simple CRUD APIs with fixed response shapes (use REST with minimal APIs), file upload/download endpoints (use REST), or real-time bidirectional communication (use SignalR, though GraphQL subscriptions can complement it).

Instrument web applications to send telemetry data to Azure Application Insights for observability and monitoring. USE FOR: instrument app with app insights, add appinsights instrumentation, configure application insights, set up telemetry monitoring, enable app insights auto-instrumentation, add observability to azure web app, instrument webapp to send data to app insights, configure telemetry for app service. DO NOT USE FOR: non-Azure monitoring (use CloudWatch for AWS, Datadog for third-party), log analysis (use azure-kusto), cost monitoring (use azure-cost-optimization), security monitoring (use azure-security).

Use when solving optimization problems with overlapping subproblems and optimal substructure. Covers memoization (top-down) vs tabulation (bottom-up), classic DP problems (Knapsack, LCS, LIS, Edit Distance, Coin Change, Matrix Chain, Rod Cutting), and the DP framework. Based on Knuth's TAOCP. USE FOR: optimization problems with overlapping subproblems, memoization strategies, tabulation approaches, recognizing DP problem patterns, state definition and recurrence formulation DO NOT USE FOR: graph shortest paths (use graph-algorithms), sorting (use sorting-searching)

USE FOR: Generating type-safe fluent builder APIs from C# classes using source generation, enforcing required property ordering and compile-time validation of builder step sequences. DO NOT USE FOR: Runtime builder patterns, general-purpose object mapping, or serialization scenarios where AutoMapper or System.Text.Json would be more appropriate.

Use when designing system boundaries, dependency direction, and layered architecture — based on Robert C. Martin's "Clean Architecture." USE FOR: dependency rule enforcement, layer separation, boundary design, use case isolation, screaming architecture, presenter/viewmodel patterns DO NOT USE FOR: code-level clean practices (use clean-code), hexagonal/ports-adapters specifically (use dev/architecture/hexagonal), microservices (use dev/architecture/microservices)

USE FOR: Structuring MSBuild .csproj files, Directory.Build.props, Directory.Packages.props, Central Package Management, and dotnet CLI workflows for modern .NET project scaffolding. DO NOT USE FOR: Hand-editing .csproj XML directly (use dotnet CLI), runtime application configuration (use appsettings.json), or build scripting (use Cake or NUKE).

USE FOR: Building strongly-typed validation rules for domain models and DTOs using FluentValidation's fluent API. Use for form validation, API request validation, and business rule enforcement with composable, testable validators. DO NOT USE FOR: Simple null/range guard clauses on method parameters (use CommunityToolkit.Diagnostics Guard), compile-time type safety enforcement (use Parse Don't Validate pattern), or command pipeline orchestration (use Peasy or MediatR behaviors).

Guidance for building .NET worker services and background tasks using BackgroundService and IHostedService. USE FOR: long-running background processing, message queue consumers, scheduled jobs, health monitoring services, data synchronization tasks, Windows services, Linux systemd daemons. DO NOT USE FOR: HTTP request handling (use ASP.NET Core), one-shot CLI tools (use console apps), UI applications, short-lived Azure Functions.

Guidance for MessageFormat.NET (Jeffijoe.MessageFormat) ICU message formatting library. USE FOR: ICU MessageFormat pluralization, gender/select patterns, complex parameterized localization messages, locale-aware plural rules. DO NOT USE FOR: basic resource file localization (use resources-localization), culture formatting of dates/numbers (use globalization-localization), general i18n architecture (use i18n).

Use when building microservices with Dapr (Distributed Application Runtime) in .NET. Covers service invocation, state management, pub/sub messaging, bindings, actors, secrets, and sidecar configuration. USE FOR: service-to-service invocation with automatic mTLS, distributed state management with pluggable stores, pub/sub messaging with topic subscriptions, output bindings to external systems, virtual actor model for per-entity stateful logic DO NOT USE FOR: .NET Aspire orchestration without Dapr (use aspire), serverless functions (use azure-functions), simple in-process background tasks (use IHostedService), Orleans virtual actors without Dapr (use orleans)

USE FOR: Distributed caching, session storage, real-time pub/sub messaging, leaderboards and sorted sets, rate limiting, distributed locks, and high-throughput key-value operations using StackExchange.Redis. DO NOT USE FOR: Primary relational data storage, complex queries with joins, large blob storage (values over 512 MB), or scenarios where data durability is more critical than performance.

USE FOR: Building enterprise .NET applications using Telerik UI components for Blazor, WPF, WinForms, or ASP.NET Core. Use when you need professional-grade data grids, editors, charts, and document processing with commercial support from Progress. DO NOT USE FOR: Open-source-only projects (Telerik requires a commercial license), simple prototypes where a lightweight component library suffices, or game development.

USE FOR: Building API gateways in .NET using Ocelot for microservices architectures. Use when you need request routing, load balancing, rate limiting, request aggregation, authentication forwarding, and service discovery across multiple downstream services behind a unified entry point. DO NOT USE FOR: Simple single-service reverse proxying (use YARP), high-throughput proxying requiring custom transforms and session affinity (use YARP), or service mesh features like mTLS and distributed tracing injection (use Istio, Linkerd, or Dapr).

USE FOR: Integrating Stripe payment processing into .NET applications using the Stripe.NET SDK. Use when implementing checkout flows, subscriptions, payment intents, customer management, webhook handling, and Connect platform payments. DO NOT USE FOR: PayPal, Square, or Braintree payments (use their respective SDKs), cryptocurrency payments (use Coinbase Commerce or similar), or payment processing without Stripe as the provider.

Use when identifying attribution requirements that apply to software products — open-source license notices, third-party asset credits, API usage attribution, font licensing, media licensing, and data source attribution. Covers what must be attributed, how, and where across different asset types and jurisdictions. USE FOR: attribution requirements, license notices, open-source attribution, Creative Commons, font licensing, image licensing, API attribution, data attribution, NOTICE files, third-party credits, attribution in UI, attribution in documentation DO NOT USE FOR: choosing open-source licenses (use open-source-licensing), IP ownership disputes (use intellectual-property), content moderation obligations (use content-moderation)

Use when creating software architecture diagrams, system visualizations, or technical drawings. Covers text-based and visual diagramming approaches for architecture communication. USE FOR: choosing diagram types, comparing diagramming tools, architecture visualization strategy, diagrams-as-code workflows, embedding diagrams in documentation DO NOT USE FOR: specific diagram syntax (use c4-diagrams, mermaidjs, uml, d2, plantuml, etc.), requirements documents (use documentation sub-skills)

Structural design patterns from the Gang of Four — Adapter, Bridge, Composite, Decorator, Facade, Flyweight, and Proxy. Patterns that compose classes and objects into larger structures while keeping those structures flexible and efficient. USE FOR: adapting interfaces, composing objects into trees, adding behavior dynamically, simplifying complex subsystems, sharing objects efficiently, controlling access via proxies DO NOT USE FOR: object creation (use creational), communication patterns (use behavioral)

Use when building state machine workflows integrated with MassTransit for distributed sagas and long-running processes. USE FOR: state machine definitions, MassTransit saga orchestration, order/workflow lifecycle management, distributed state transitions, compensation logic DO NOT USE FOR: simple in-process mediator patterns (use mediatr), standalone actor concurrency (use akka-net), basic event pub/sub without state tracking (use event-driven)

Analyzes markdown files for token efficiency. TRIGGERS: optimize markdown, reduce tokens, token count, token bloat, too many tokens, make concise, shrink file, file too large, optimize for AI, token efficiency, verbose markdown, reduce file size

Use when working with graph problems including traversal, shortest paths, minimum spanning trees, topological sorting, and connectivity analysis. Covers BFS, DFS, Dijkstra, Bellman-Ford, Floyd-Warshall, Prim, Kruskal, Tarjan, Kosaraju, A*, and Union-Find. Based on Knuth's TAOCP. USE FOR: graph traversal, shortest path computation, minimum spanning tree construction, topological sorting, strongly connected components, pathfinding, union-find operations DO NOT USE FOR: basic data structure operations (use data-structures), optimization problems (use dynamic-programming)

Use when designing, deploying, or evaluating cloud-native applications — based on the Twelve-Factor App methodology from Heroku. USE FOR: cloud-native app design, environment configuration, stateless process design, backing service integration, build/release/run pipelines, dev/prod parity DO NOT USE FOR: cloud infrastructure provisioning (use iac), container configuration (use iac/docker or iac/kubernetes), microservice decomposition (use dev/architecture/microservices)

USE FOR: Toggling runtime compatibility switches, enabling or disabling breaking-change mitigations between framework versions, gating legacy code paths at startup, and reading platform-level feature switches. DO NOT USE FOR: User-facing feature flags (use Microsoft.FeatureManagement or OpenFeature), per-request dynamic toggles, or configuration that changes at runtime without restart.

USE FOR: Writing cross-platform build automation scripts in C# using Cake (C# Make) for compiling, testing, packaging, and deploying .NET solutions with a task-based dependency graph. DO NOT USE FOR: Simple single-command builds (use dotnet CLI directly), CI/CD pipeline definitions (use YAML-native features), or Make/MSBuild targets that do not need C# scripting.

USE FOR: Vendor-neutral feature flag evaluation, switching between flag providers (LaunchDarkly, Flagsmith, Split, CloudBees, in-memory) without code changes, standardized targeting and context-based evaluation, and multi-provider setups. DO NOT USE FOR: Simple compile-time feature toggles, runtime compatibility switches (use AppContext), or Microsoft-only ecosystems where Microsoft.FeatureManagement is already established.

Guidance for .NET Community Toolkit libraries including MVVM Toolkit, Diagnostics, and HighPerformance. USE FOR: MVVM source-generated view models, observable properties, relay commands, messenger pattern, guard clauses, high-performance array pooling, string pooling. DO NOT USE FOR: UI framework specifics (use WPF/MAUI/WinUI skills), full reactive programming (use Rx), dependency injection container logic.

Use when identifying contractual considerations for software companies — SLAs, DPAs, MSAs, licensing agreements, and liability allocation. Covers key contract types, essential clauses, jurisdiction-specific requirements, and negotiation considerations for software products and services. USE FOR: SLA, DPA, MSA, software licensing, liability limitation, indemnification, warranty, contract negotiation, jurisdiction clauses, force majeure, escrow agreements, SaaS agreements DO NOT USE FOR: drafting actual contracts (consult legal counsel), open-source license selection (use open-source-licensing), consumer terms of service (use consumer-protection)

Progressive Web App architecture — service workers, web app manifest, caching strategies, offline support, push notifications, background sync, and Workbox. Covers the full lifecycle of building installable, offline-capable web applications. USE FOR: progressive web apps, service workers, offline support, caching strategies, web app manifest, Workbox configuration, push notifications, installability DO NOT USE FOR: SPA routing/state management (use spa), server-side rendering (use ssr), native mobile apps (use e2e-testing for Appium)

Single Page Application architecture — client-side routing, state management, data fetching, bundle optimization, and the SPA vs MPA tradeoff. Covers React, Vue, Angular, Svelte, and Solid ecosystems. USE FOR: SPA architecture, client-side routing, state management patterns, data fetching strategies, bundle optimization, code splitting, lazy loading DO NOT USE FOR: server-side rendering (use ssr), progressive web apps (use pwa), micro-frontend composition (use micro-frontends)

Server-Side Rendering, Static Site Generation, Incremental Static Regeneration, Islands Architecture, Streaming SSR, and React Server Components. Covers Next.js, Nuxt, Remix, SvelteKit, and Astro in depth. USE FOR: server-side rendering, SSG, ISR, Islands Architecture, streaming SSR, React Server Components, Next.js, Nuxt, Remix, SvelteKit, Astro, choosing between SSR vs SSG vs ISR DO NOT USE FOR: client-only SPAs (use spa), progressive web apps (use pwa), micro-frontend composition (use micro-frontends)

USE FOR: Building interactive web UIs with C# and Razor components using Blazor Server, Blazor WebAssembly, or Blazor United (SSR + interactivity). Use when building SPAs, dashboards, or full-stack .NET web applications. DO NOT USE FOR: Static marketing sites with minimal interactivity (use Razor Pages or static site generators), native desktop apps (use MAUI or Avalonia), or real-time game rendering (use Unity or MonoGame).

USE FOR: Defining type-safe HTTP API clients using interfaces and attributes with Refit's source generator. Use when consuming REST APIs where compile-time safety, automatic serialization, and integration with HttpClientFactory and DI are needed. DO NOT USE FOR: Low-level HTTP operations requiring manual stream control (use HttpClient directly), GraphQL clients (use StrawberryShake or GraphQL.Client), or file download/upload with custom progress reporting (use HttpClient with stream copying).

Use when identifying healthcare regulations that apply to software handling health data or functioning as a medical device. Covers HIPAA, HITECH, FDA SaMD regulation, EU MDR, HITRUST, and health data privacy across jurisdictions. USE FOR: HIPAA, HITECH, PHI, FDA SaMD, EU MDR, HITRUST, health data privacy, medical device software, BAA, ePHI, clinical decision support, telehealth regulation, health app compliance DO NOT USE FOR: general data privacy (use privacy-data-protection), security controls implementation (use security skills), clinical validation methodology (consult regulatory affairs specialists)

Use when applying software craftsmanship principles — code quality, professional practices, and continuous improvement drawn from canonical works. USE FOR: code quality principles, Boy Scout Rule, DRY/KISS/YAGNI, craftsmanship practices, choosing quality improvement approaches DO NOT USE FOR: specific principle details (use clean-code, solid, refactoring sub-skills), architecture decisions (use dev/architecture), testing strategy (use testing)

Guidance for modern .NET code patterns and libraries. Use when working with dotnet cheatsheet.

USE FOR: Deriving semantic version numbers from Git history, branch names, tags, and commit messages to automate versioning in CI/CD pipelines and NuGet package publishing. DO NOT USE FOR: Manual version bumping in .csproj files, runtime version display logic, or changelog generation (use tools like versionize or conventional-changelog for that).

USE FOR: Creating, packaging, and distributing custom dotnet new project and item templates using the template engine, template.json configuration, and NuGet template packs for team standardization. DO NOT USE FOR: Visual Studio VSIX extensions, runtime code scaffolding, or T4 text templates that generate code during build rather than during project creation.

Cloud well-architected frameworks from AWS, Azure, and GCP -- covering pillars, design principles, review processes, and cross-cloud comparison for building reliable, secure, cost-effective cloud workloads. USE FOR: well-architected reviews, cloud architecture evaluation, reliability/security/cost/performance pillar analysis, cross-cloud architecture comparison DO NOT USE FOR: cloud infrastructure provisioning (use iac/terraform, iac/bicep, etc.), specific cloud services, microservice patterns (use microservices)

Use when building command-line applications in .NET with System.CommandLine. Covers command/option/argument definitions, middleware, tab completion, parsing, and hosting integration for CLI tools. USE FOR: building CLI applications with typed argument parsing, creating dotnet tools with subcommands, System.CommandLine setup and configuration, adding tab completion to CLI apps, parsing and validating command-line arguments DO NOT USE FOR: executing external CLI processes (use cliwrap), rendering rich terminal UI with tables and progress bars (use spectre-console), building web APIs (use ASP.NET Core), simple Console.ReadLine input

USE FOR: CRUD data access with LINQ, database migrations, change tracking, complex domain models with relationships, database-first and code-first workflows, and multi-provider support (SQL Server, PostgreSQL, SQLite, Cosmos DB). DO NOT USE FOR: Bulk operations on millions of rows without batching extensions, latency-critical read-only queries where Dapper is faster, or non-relational data that does not fit an entity model.

Guidance for protobuf-net Protocol Buffers serializer for .NET. USE FOR: high-performance binary serialization, gRPC service contracts, cross-language data interchange, compact wire format for microservices, schema evolution with backward compatibility, replacing JSON in performance-critical inter-service communication. DO NOT USE FOR: human-readable serialization (use System.Text.Json), polymorphic type hierarchies without planning, dynamic/schema-less data, or browser-facing REST APIs expecting JSON.

Use when building MCP Apps that serve interactive UI from MCP servers. Covers the ui:// URI scheme, HTML rendering in sandboxed iframes, and bidirectional communication between UI and host. USE FOR: rich UI in agent conversations, interactive dashboards from MCP servers, sandboxed iframe rendering DO NOT USE FOR: basic tool responses without UI (use mcp), agent communication (use a2a), full web applications