Tyler R Kendrick Skills

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 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)

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)

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 designing APIs — REST endpoints, GraphQL schemas, gRPC services, or WebSocket protocols — including resource naming, versioning, pagination, error handling, and API gateway patterns. USE FOR: REST API design, GraphQL schema design, gRPC service definition, WebSocket protocol design, API versioning, pagination strategies, API gateway patterns, idempotency, OpenAPI specifications DO NOT USE FOR: data storage design (use data-modeling), authentication mechanisms (use authentication), API testing (use testing/api-testing)

Guidance for Serilog structured logging library in .NET. USE FOR: Serilog sink configuration, structured event logging, log enrichment, ASP.NET Core request logging, Serilog expressions and filtering, Seq/Elasticsearch/Application Insights integration. DO NOT USE FOR: Microsoft.Extensions.Logging abstractions (use extensions-logging), NLog targets and routing (use nlog), OpenTelemetry log export (use otlp-logging).

USE FOR: Building Blazor applications with Radzen Blazor components, including DataGrid, Form, Scheduler, and Chart. Use when you need a free, open-source component library with an optional Radzen IDE for rapid application development. DO NOT USE FOR: Non-Blazor projects, native mobile or desktop apps (use MAUI or Avalonia), or projects that require deep integration with a specific CSS framework other than Radzen's built-in theme system.

USE FOR: Building cross-platform applications with WinUI/XAML and C# that target Web (WebAssembly), iOS, Android, macOS, Linux, and Windows from a single codebase using the Uno Platform. Use when you want WinUI API compatibility across all platforms. DO NOT USE FOR: Games (use Unity or MonoGame), server-side web APIs (use ASP.NET Core), or projects that only target Windows and do not need cross-platform reach (use WinUI 3 directly).

USE FOR: Building web APIs, web applications, and microservices with ASP.NET Core. Use for minimal APIs, controller-based APIs, Razor Pages, MVC, gRPC, and real-time applications with the full ASP.NET Core middleware pipeline, dependency injection, and configuration system. DO NOT USE FOR: Desktop or mobile UI (use MAUI, WPF, or Avalonia), game development (use Unity or MonoGame), or standalone console tools that do not serve HTTP traffic.

Use when identifying tax, billing, and revenue recognition obligations for software products sold globally. Covers service type classification and billing codes, VAT/GST/sales tax, invoicing requirements, revenue recognition (ASC 606/IFRS 15), cloud credits and stored-value models, and money transmission risks for prepaid systems. USE FOR: sales tax, VAT, GST, billing codes, service classification, invoicing requirements, revenue recognition, ASC 606, IFRS 15, cloud credits, stored value, prepaid credits, tax nexus, digital services tax, e-invoicing, withholding tax, transfer pricing DO NOT USE FOR: payment processing compliance (use financial-regulation), consumer refund policies (use consumer-protection), contract pricing terms (use contracts), tax return preparation (consult a tax advisor)

Use when identifying employment and labor law considerations for software companies, especially those with distributed or global teams. Covers contractor vs employee classification, IP assignment, non-competes, remote work across borders, equity compensation, and whistleblower protections. USE FOR: contractor vs employee, IP assignment, work-for-hire, non-compete agreements, remote work compliance, cross-border employment, employer of record, equity compensation, whistleblower protection, employee monitoring DO NOT USE FOR: IP ownership law (use intellectual-property), data privacy of employees (use privacy-data-protection), HR policy drafting (consult employment counsel)

Use for visual regression testing to catch unintended UI changes. Covers Chromatic (Storybook integration), Percy (BrowserStack), BackstopJS (headless CSS regression), Playwright screenshot assertions, and Applitools Eyes (AI-powered). Includes baseline management, approval workflows, and flaky screenshot handling. USE FOR: Chromatic, Percy, BackstopJS, Playwright screenshots, visual regression testing, UI snapshot comparison, CSS regression detection, Applitools, design system visual verification, cross-browser visual diffs DO NOT USE FOR: functional testing (use e2e-testing), accessibility checks (use accessibility-testing), performance testing (use performance-testing)

Use when installing, managing, or automating system-level software with OS package managers. Covers Chocolatey, winget, Homebrew, apt, dnf, pacman, snap, Flatpak, and Scoop — the non-language-specific package managers for installing developer tools and system dependencies. USE FOR: Chocolatey, choco, winget, Homebrew, brew, apt, apt-get, dnf, yum, pacman, snap, Flatpak, Scoop, system package management, developer environment setup, automated provisioning DO NOT USE FOR: language-specific package managers (npm, pip, cargo, NuGet, Maven — use language-specific skills), container image management (use docker), application deployment

Use when documenting, developing, or testing UI components with Storybook. Covers CSF3, CSF Factories, play functions, Args, interaction testing, and addon configuration. USE FOR: Storybook stories (CSF3 and CSF Factories), play functions, Args and ArgTypes, interaction testing, Storybook addons, visual regression testing, component documentation DO NOT USE FOR: design token authoring (use design-tokens), token transformation (use style-dictionary), Figma design handoff (use figma), cross-framework component compilation (use mitosis)

Use when applying or evaluating SOLID object-oriented design principles — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. USE FOR: class design, interface design, dependency management, evaluating OO design quality, reducing coupling, improving testability DO NOT USE FOR: architecture layer decisions (use clean-architecture), design pattern selection (use dev/design-patterns), refactoring mechanics (use refactoring)

Use when implementing in-process mediator, CQRS, and pipeline behavior patterns with MediatR in .NET applications. USE FOR: in-process command/query dispatch, CQRS with pipeline behaviors, notification fan-out, cross-cutting concern pipelines (validation, logging, caching), decoupling controllers from handlers DO NOT USE FOR: distributed messaging across services (use masstransit or nservicebus), actor-based concurrency (use akka-net), external message broker integration (use rebus)

Guidance for NCrontab cron expression parser and scheduler for .NET. USE FOR: parsing cron expressions, calculating next/previous occurrences, validating cron syntax, scheduling background tasks with cron patterns, generating occurrence lists for display. DO NOT USE FOR: full job scheduling frameworks (use Quartz.NET or Hangfire), distributed task scheduling, Windows Task Scheduler integration, real-time event processing.

Guidance for Topshelf Windows service hosting framework for .NET. USE FOR: creating Windows services with fluent API, service install/uninstall from command line, service recovery configuration, running services as console apps during development, .NET Framework Windows services. DO NOT USE FOR: modern .NET 6+ worker services (use BackgroundService with AddWindowsService), Linux daemons (use systemd hosting), cross-platform services, ASP.NET Core web hosting.

USE FOR: Implementing resilience patterns (retry, circuit breaker, timeout, fallback, hedging, rate limiter) using Polly v8's ResiliencePipeline API for transient fault handling in .NET. DO NOT USE FOR: Application-level validation errors, permanent failures that should not be retried, or infrastructure-level resilience (use load balancers, service mesh).

Guidance for input sanitization, output encoding, and security hygiene in .NET. USE FOR: preventing XSS attacks, SQL injection prevention, HTML/URL/JavaScript encoding, input validation, Content Security Policy headers, CSRF protection, secure HTTP headers. DO NOT USE FOR: authentication flows (use ASP.NET Core Identity), encryption at rest (use CryptoNet), authorization policies (use Casbin/Enforcer), or certificate management.

Guidance for Reqnroll BDD testing framework (SpecFlow successor) in .NET. USE FOR: behavior-driven development with Gherkin syntax, writing executable specifications, step definition bindings, scenario outlines with data tables, integrating BDD with xUnit/NUnit/MSTest, acceptance testing with natural language scenarios. DO NOT USE FOR: unit testing without BDD requirements (use xUnit directly), performance testing, API contract testing (use Pact), or browser automation (combine with Playwright).

Use when designing or implementing authentication and authorization systems. Covers OAuth 2.0, OpenID Connect, RBAC, ABAC, Zero Trust architecture, session management, and multi-factor authentication across all platforms. USE FOR: OAuth 2.0, OpenID Connect, OIDC, RBAC, ABAC, Zero Trust, session management, MFA, JWT, token management, SSO, identity federation DO NOT USE FOR: cryptographic primitives (use cryptography), API rate limiting and headers (use api-security), specific identity provider setup (use platform-specific skills)

Use when writing Business Requirements Documents that justify why a project should be undertaken. Covers executive summaries, business objectives, stakeholder analysis, current state analysis, proposed solutions, business rules, cost-benefit analysis, success criteria, timelines, and risk assessment. USE FOR: business case documentation, cost-benefit analysis, stakeholder alignment, business objectives, ROI justification, project proposals, business rules documentation, executive-level project summaries DO NOT USE FOR: technical design (use trd), product feature details (use prd), architecture decisions (use adr), test specifications (use gherkin or gauge)

Use when writing RFC (Request for Comments) design documents to propose significant technical changes for team review and feedback. Covers RFC structure, motivation, detailed design, alternatives analysis, risk assessment, the RFC workflow, and when to use RFC vs ADR. USE FOR: design proposals, technical change proposals, architecture proposals seeking feedback, RFC workflow management, lightweight and heavyweight RFC formats, cross-team design alignment, pre-decision design documents DO NOT USE FOR: recording final decisions (use adr), product requirements (use prd), business justification (use brd), executable specs (use gherkin)

Use when writing Technical Requirements Documents that define how to build a system. Covers system architecture, API specifications, data models, security requirements, performance requirements, dependencies, technical constraints, and deployment plans. USE FOR: technical design specifications, API contracts, data model documentation, system architecture descriptions, performance and security requirements, deployment plans, infrastructure requirements, technical constraints documentation DO NOT USE FOR: product-level requirements (use prd), business justification (use brd), recording individual decisions (use adr), executable specs (use gherkin or gauge)

Use when setting up or improving static analysis tooling — type checking, linting, security scanning (SAST), and code formatting. Covers cross-platform tools including TypeScript, mypy, ESLint, Biome, Ruff, Semgrep, CodeQL, Roslyn analyzers, Prettier, Black, and dotnet format with configuration examples and CI integration patterns. USE FOR: linting, type checking, SAST, code formatting, Semgrep rules, ESLint configuration, Roslyn analyzers DO NOT USE FOR: runtime testing (use unit-testing or integration-testing), E2E tests (use e2e-testing), performance profiling (use performance-testing)

Use when building applications with Deno, the TypeScript-first runtime with built-in security, web standard APIs, and modern tooling. Covers Deno 2.x features, permissions, module system, standard library, built-in tools, HTTP servers, testing, npm compatibility, Deno Deploy, KV, and frameworks. USE FOR: Deno runtime projects, TypeScript-first server-side development, secure sandboxed execution, edge functions with Deno Deploy, key-value storage with Deno KV, Fresh or Oak web applications, scripts leveraging web standard APIs, npm-compatible Deno projects, Deno 2.x migrations DO NOT USE FOR: Node.js-only projects without Deno compatibility (use express or nestjs), frontend-only React/Vue/Angular apps (use nextjs or relevant framework skill), Bun-specific tooling, Cloudflare Workers-specific bindings (use hono)

Use when designing or evaluating enterprise integration architectures based on Hohpe & Woolf's Enterprise Integration Patterns. USE FOR: Enterprise Integration Patterns, messaging architecture, choosing integration patterns, pipes and filters, message-oriented middleware DO NOT USE FOR: specific pattern implementations in code (use sub-skills), API design (use dev/backend/api-design), event sourcing (use dev/architecture/event-driven)

USE FOR: Persisting and restoring application state such as window positions, user preferences, form values, and UI settings in desktop applications (WPF, WinForms, Avalonia). DO NOT USE FOR: Server-side configuration management, web application session state, database-backed settings, or security-sensitive credential storage.

Use when building concurrent, distributed, or fault-tolerant .NET applications with the actor model using Akka.NET. USE FOR: actor-based concurrency, distributed systems, supervision hierarchies, event sourcing with actors, cluster sharding, CQRS with persistent actors DO NOT USE FOR: simple in-process mediator patterns (use mediatr), lightweight message queues (use rebus or masstransit), basic pub/sub without actor semantics (use event-driven)

Use when writing F# code on .NET, leveraging functional-first programming with discriminated unions, pattern matching, computation expressions, and type inference. USE FOR: functional-first .NET programming, discriminated unions and pattern matching, computation expressions, type-safe domain modeling, data pipeline processing, F# interop with C# DO NOT USE FOR: C# functional patterns (use functional-programming or language-ext), C# parser combinators (use pidgin), imperative OOP patterns

Use when building high-performance parsers in C# using Pidgin's parser combinator library for structured text, DSLs, and expression grammars. USE FOR: C# parser combinators, high-performance text parsing, expression parsers, DSL implementation, protocol parsing, structured data extraction DO NOT USE FOR: F# parser combinators (use fparsec), PEG grammar-class style parsing (use parakeet), JSON/XML parsing (use System.Text.Json), simple regex matching

Guidance for internationalization (i18n) architecture in .NET applications. USE FOR: designing i18n-ready applications, externalizing user-facing strings, building multi-language ASP.NET Core apps, Razor view localization, data annotation localization. DO NOT USE FOR: low-level culture formatting (use globalization-localization), ICU plural/gender patterns (use messageformat-net), basic resource file operations (use resources-localization).