Tyler R Kendrick Skills

Guidance for Twilio .NET SDK for communications APIs. USE FOR: sending SMS and MMS, making voice calls, Twilio Verify for phone verification, WhatsApp messaging, webhook handling for incoming messages/calls, Twilio programmable video. DO NOT USE FOR: email sending (use mimekit), HTTP APIs (use ASP.NET Core), gRPC services (use grpc-dotnet), custom socket protocols (use dotnetty).

USE FOR: Implementing high-performance producer/consumer queues with backpressure using System.Threading.Channels for background processing, pipelines, and async message passing. DO NOT USE FOR: Simple async/await workflows without queuing, IObservable-based event streams (use Reactive Extensions), or distributed message queues (use RabbitMQ, Azure Service Bus).

Guidance for Casbin.NET authorization library (Enforcer). USE FOR: access control list (ACL) enforcement, role-based access control (RBAC), attribute-based access control (ABAC), policy management, multi-tenant authorization, API endpoint protection. DO NOT USE FOR: authentication or login flows (use ASP.NET Core Identity), encryption (use CryptoNet), relationship-based access control with graph traversal (use Topaz), or input sanitization (use Hygiene).

Use when identifying legal obligations for platforms hosting user-generated content. Covers intermediary liability (Section 230, EU DSA), DMCA takedown procedures, illegal content obligations, CSAM reporting requirements, and content moderation transparency mandates. USE FOR: Section 230, EU Digital Services Act, DMCA, intermediary liability, content moderation, takedown procedures, CSAM reporting, terrorist content regulation, online safety, platform liability, safe harbor DO NOT USE FOR: content filtering implementation (use platform-specific skills), intellectual property strategy (use intellectual-property), consumer protection terms (use consumer-protection)

Use when implementing data protection controls for compliance and privacy. Covers encryption at rest and in transit, PII handling, data classification, GDPR, CCPA, HIPAA requirements, and data retention policies. USE FOR: data encryption, PII handling, GDPR, CCPA, HIPAA, data classification, data retention, data masking, tokenization, privacy by design, data minimization DO NOT USE FOR: cryptographic algorithm selection (use cryptography), access control design (use authentication), audit logging (use logging-monitoring)

Use when identifying and prioritizing security threats during system design. Covers STRIDE and DREAD frameworks, threat modeling processes, data flow diagrams for security, and integrating threat analysis into the SDLC. USE FOR: STRIDE, DREAD, threat modeling, data flow diagrams for security, attack surface analysis, security design review, threat prioritization DO NOT USE FOR: runtime vulnerability scanning (use security-testing), incident response (use logging-monitoring), specific vulnerability remediation (use owasp)

Use when setting up or improving contract tests that verify API compatibility between services. Covers Pact (consumer-driven contracts), PactFlow (bi-directional contracts), Spring Cloud Contract, Pact Broker, can-i-deploy, and strategies for choosing between contract testing approaches. USE FOR: Pact, PactFlow, Spring Cloud Contract, consumer-driven contracts, bi-directional contracts, API compatibility verification, can-i-deploy, Pact Broker DO NOT USE FOR: full user flow tests (use e2e-testing), API functional testing (use api-testing), unit testing (use unit-testing)

Use when designing database schemas, choosing data modeling strategies, or making decisions about data storage architecture across relational, document, graph, key-value, and time-series paradigms. USE FOR: database schema design, data modeling patterns, normalization/denormalization, document modeling, graph modeling, key-value design, time-series modeling, schema migration strategies, database-per-service decisions DO NOT USE FOR: ERD diagramming (use specs/diagramming/erd), API design (use api-design), caching strategy (use caching)

Use when building AI agents with Microsoft.SemanticKernel or Microsoft.Extensions.AI.Agent frameworks. Covers agent creation, tool/plugin registration, multi-agent orchestration, chat completion agents, and OpenAI Assistants integration. USE FOR: building AI agents with tools and plugins, multi-agent chat workflows, Semantic Kernel agent orchestration, OpenAI Assistants API integration, agent-based automation pipelines DO NOT USE FOR: simple chat completions without agent patterns (use microsoft-extensions-ai), inter-service agent communication over A2A protocol (use a2a), ML model training (use mlnet), raw ONNX inference (use onnx)

Use when applying function currying and partial application patterns in C# to create specialized, reusable function compositions. USE FOR: function currying, partial application, function composition, creating specialized functions from general ones, builder-like functional APIs DO NOT USE FOR: full functional programming library (use language-ext), parser combinators (use pidgin or fparsec), optional value handling (use optional)

Guidance for AspectCore AOP framework for .NET Core. USE FOR: cross-cutting concerns via interceptors, method-level AOP, dynamic proxies, logging/caching/authorization interception, decorating service interfaces. DO NOT USE FOR: compile-time weaving (use PostSharp), full IL rewriting, non-DI scenarios, .NET Framework-only projects.

Guidance for Nethermind Ethereum client and Ethereum development in .NET. USE FOR: running Ethereum full/archive nodes, interacting with Ethereum via JSON-RPC, building Ethereum plugins, blockchain data indexing, smart contract interaction from .NET, EVM chain development. DO NOT USE FOR: Solidity smart contract authoring (use Foundry/Hardhat), front-end dApp UI (use JavaScript/TypeScript), non-EVM blockchains, cryptocurrency trading bots.

Guidance for AutoMapper convention-based object mapping library. USE FOR: convention-based object-to-object mapping, Profile-based mapping configuration, flattening/unflattening, ProjectTo with EF Core IQueryable, reverse mapping, value resolvers, type converters. DO NOT USE FOR: compile-time source-generated mapping (use mapperly), manual mapping in performance-critical paths, mapping that involves complex business logic.

Guidance for MimeKit and MailKit email libraries in .NET. USE FOR: creating and parsing MIME email messages, sending email via SMTP with MailKit, reading email via IMAP/POP3, attachments, HTML email, S/MIME and PGP signing/encryption. DO NOT USE FOR: SMS/voice messaging (use twilio), HTTP APIs (use ASP.NET Core), custom TCP protocols (use dotnetty), gRPC services (use grpc-dotnet).

Guidance for CryptoNet cryptography library in .NET. USE FOR: RSA encryption/decryption, symmetric AES encryption, X.509 certificate-based crypto, self-signed certificate generation, key pair management, encrypting sensitive data at rest. DO NOT USE FOR: password hashing (use ASP.NET Core Identity), TLS/HTTPS configuration, JWT token signing (use Microsoft.IdentityModel), or authorization (use Casbin/Enforcer).

Guidance for Microsoft Bond schematized data serialization framework. USE FOR: cross-platform schema-first serialization, Compact Binary and Fast Binary wire formats, schema evolution with backward/forward compatibility, high-performance RPC data contracts, strongly typed data interchange between .NET, C++, Python, and Java services. DO NOT USE FOR: JSON REST APIs (use System.Text.Json), human-readable config files, simple key-value storage, or when schema-less flexibility is required.

Guidance for Playwright browser automation and end-to-end testing in .NET. USE FOR: cross-browser end-to-end testing, UI automation, screenshot and visual regression testing, network request interception, mobile viewport emulation, testing SPAs and server-rendered pages, CI/CD browser testing in headless mode. DO NOT USE FOR: unit testing (use xUnit with Moq), API contract testing (use Pact), load testing (use k6 or NBomber), or testing non-web applications.

USE FOR: Defining high-performance validation specifications using Validot's fluent specification builder. Use when you need allocation-free validation with reusable specifications, fast execution, and detailed error output. DO NOT USE FOR: Async validation with database lookups (Validot is synchronous), ASP.NET Core automatic model validation integration (use FluentValidation), or guard-clause-style argument checking (use CommunityToolkit Guard).

Use when identifying consumer protection laws that apply to software products and digital services. Covers terms of service, EULAs, refund policies, dark patterns regulation, subscription practices, the EU Digital Markets Act, and consumer rights across jurisdictions. USE FOR: terms of service, EULA, consumer rights, refund policies, dark patterns, auto-renewal laws, Digital Markets Act, Digital Services Act, FTC Act, CAN-SPAM, children's privacy (COPPA), subscription traps DO NOT USE FOR: data privacy regulations (use privacy-data-protection), content liability (use content-moderation), contract drafting (consult legal counsel)

Guidance for Python package management, dependency resolution, virtual environments, and lockfiles. USE FOR: installing packages, managing dependencies, choosing between pip/uv/poetry/pdm/conda, virtual environment setup, lockfile strategies, private package indexes, pipx for CLI tools DO NOT USE FOR: configuring pyproject.toml or build backends (use project-system), building CLI applications (use cli)

Hexagonal Architecture (Ports and Adapters), Onion Architecture, and their relationship to Clean Architecture -- enabling technology-independent domain logic with high testability. USE FOR: hexagonal architecture, ports and adapters, onion architecture, driving/driven adapters, technology-independent domain design, adapter-based testability DO NOT USE FOR: clean architecture layers specifically (use dev/craftsmanship/clean-architecture), microservice boundaries (use microservices), domain model design (use domain-driven-design)

Monolithic architecture patterns including modular monolith design, monolith-first strategy, and migration paths to microservices via the Strangler Fig pattern. USE FOR: monolith-first strategy, modular monolith design, monolith decomposition, Strangler Fig migration, avoiding Big Ball of Mud, when to keep a monolith DO NOT USE FOR: microservice decomposition (use microservices), event-driven architecture (use event-driven), clean architecture layers (use dev/craftsmanship/clean-architecture)

Use when building rich terminal UIs in .NET with Spectre.Console. Covers tables, trees, progress bars, prompts, live rendering, markup formatting, and the Spectre.Console.Cli command framework. USE FOR: rendering tables and grids in the terminal, progress bars and spinners, interactive prompts and selections, colorized and styled console output, building CLI apps with Spectre.Console.Cli DO NOT USE FOR: executing external processes (use cliwrap), argument parsing without UI (use commandline-cheatsheet), building web UIs (use Blazor), logging output (use ILogger with console provider)

USE FOR: Unified cloud storage abstraction across Azure Blob Storage, AWS S3, Google Cloud Storage, local filesystem, and FTP. Blob read/write, listing, streaming large files, and switching storage providers without code changes. DO NOT USE FOR: Relational data access, message queuing, low-level storage operations requiring provider-specific APIs (e.g., Azure Blob leases, S3 multipart upload tuning), or in-memory caching.

USE FOR: GraphQL-like selective field projection in REST APIs, reducing over-fetching by returning only client-requested fields, dynamic response shaping based on query parameters, and bandwidth optimization for mobile or low-bandwidth clients. DO NOT USE FOR: Full GraphQL implementations (use HotChocolate or GraphQL.NET), server-side data filtering or authorization, complex nested relationship loading, or replacing proper DTOs and view models.

Use when building text parsers in C# using Parakeet, a parser combinator library focused on simplicity and PEG grammars. USE FOR: C# PEG parser combinators, grammar definition, text parsing, DSL implementation, rule-based parsing DO NOT USE FOR: F# parser combinators (use fparsec), high-performance C# parsing (use pidgin), regex-based matching, JSON/XML parsing (use System.Text.Json)

Guidance for DotNetty event-driven asynchronous network application framework. USE FOR: high-performance TCP/UDP servers and clients, custom binary protocol implementations, Netty-style channel pipelines, event loop groups, codec handlers, TLS/SSL socket connections. DO NOT USE FOR: HTTP APIs (use ASP.NET Core), gRPC services (use grpc-dotnet), email sending (use mimekit), high-level stream processing (use system-io-pipelines).

USE FOR: IL weaving at build time to inject cross-cutting concerns such as INotifyPropertyChanged implementation, null-guard checks, method timing, logging, and resource embedding into .NET assemblies. DO NOT USE FOR: Runtime AOP frameworks, source generators that produce C# code, or scenarios where compile-time code generation (Roslyn generators) would be more transparent and debuggable.

USE FOR: Choosing between and implementing .NET web application patterns including MVC, Razor Pages, Minimal APIs, and Blazor. Use when deciding on architecture, project structure, and routing strategies for ASP.NET Core web applications. DO NOT USE FOR: Native mobile/desktop apps (use MAUI or Avalonia), game development (use Unity or MonoGame), or projects that exclusively need a REST API without any server-rendered content (use the aspnet-core skill directly).

Use when identifying financial regulations that apply to software handling payments, banking, or financial data. Covers PCI DSS, PSD2/PSD3, SOX, AML/KYC, Dodd-Frank, MiFID II, open banking, and fintech licensing across jurisdictions. USE FOR: PCI DSS, PSD2, PSD3, SOX, AML, KYC, Dodd-Frank, MiFID II, open banking, fintech licensing, payment processing compliance, money transmission, crypto regulation DO NOT USE FOR: payment gateway integration (use platform-specific skills), encryption implementation (use security/cryptography), financial data modeling (use dev/backend/data-modeling)

Use when creating UML and architecture diagrams using PlantUML's text-based DSL. Covers all major diagram types, syntax, skinparam theming, C4-PlantUML integration, and preprocessing directives. USE FOR: sequence diagrams, class diagrams, activity diagrams, component diagrams, state diagrams, use case diagrams, object diagrams, deployment diagrams, PlantUML syntax, skinparam theming, C4-PlantUML library, preprocessing directives, text-to-UML rendering DO NOT USE FOR: inline Markdown diagrams (use mermaidjs), enterprise architecture (use togaf or archimate), C4-specific DSL (use c4-diagrams with Structurizr)

Use when authoring, structuring, or consuming design tokens in the W3C Design Tokens Community Group (DTCG) format. Covers token types, groups, aliases, composite tokens, and file conventions. USE FOR: W3C DTCG token files, token types (color, dimension, typography), token aliases and references, token groups, composite tokens, .tokens.json files DO NOT USE FOR: transforming tokens into platform code (use style-dictionary), Figma variable management (use figma), component styling (use the relevant framework skill)

Guidance for PdfSharpCore PDF generation and modification library for .NET. USE FOR: creating PDF documents programmatically, drawing text/shapes/images on PDF pages, modifying existing PDFs, merging PDF files, generating reports and invoices as PDF, adding headers/footers/page numbers. DO NOT USE FOR: extracting text from PDFs (use PdfPig), PDF form filling with complex logic, high-volume HTML-to-PDF conversion (use a headless browser), PDF/A compliance.

Guidance for TimeProvider abstraction for testable time-dependent code. USE FOR: making time-dependent code testable, replacing DateTime.UtcNow and DateTimeOffset.UtcNow with injectable abstractions, controlling time in unit tests with FakeTimeProvider, testing expiration logic, scheduling, token lifetimes, and time-based business rules. DO NOT USE FOR: high-precision timing or benchmarking (use Stopwatch), NTP synchronization, or scenarios running on .NET versions prior to .NET 8.

Use when identifying intellectual property considerations for software products. Covers patents, copyrights, trademarks, trade secrets, and IP assignment with jurisdiction-specific considerations for software companies. USE FOR: software patents, copyright, trademarks, trade secrets, IP ownership, IP assignment, work-for-hire, patent trolls, IP due diligence, prior art, DMCA takedowns DO NOT USE FOR: open-source license selection (use open-source-licensing), content moderation (use content-moderation), drafting patent applications (consult a patent attorney)

Use when modeling enterprise architecture with ArchiMate, the Open Group standard visual notation (v3.2). Covers Business, Application, and Technology layers, element types, relationship types, viewpoints, and modeling best practices. USE FOR: enterprise architecture modeling, layered architecture visualization, Business-Application-Technology mapping, ArchiMate element and relationship notation, architecture viewpoint selection, motivation modeling, cross-layer dependency analysis DO NOT USE FOR: architecture development process (use togaf), system decomposition (use c4-diagrams), general-purpose diagrams (use mermaidjs or d2)

Use when creating text-based diagrams that render in Markdown environments. Mermaid.js is the most widely supported diagrams-as-code tool, with native rendering in GitHub, GitLab, Notion, and many documentation platforms. USE FOR: flowcharts, sequence diagrams, class diagrams, state diagrams, ER diagrams, Gantt charts, pie charts, mindmaps, timelines, git graphs, quadrant charts, C4 diagrams in Markdown, diagrams embedded in PRs and wikis, GitHub-native diagram rendering DO NOT USE FOR: enterprise architecture (use togaf or archimate), C4-specific DSL tooling (use c4-diagrams), advanced layout control (use d2)

Use when writing Behavior-Driven Development specifications in Gherkin syntax. Covers Feature files, Scenario/Scenario Outline, Given/When/Then steps, Background, Examples tables, tags, data tables, doc strings, and step definition patterns. USE FOR: BDD acceptance criteria, executable specifications, Given/When/Then scenarios, feature files, Cucumber/SpecFlow/Reqnroll/Behave test specs, scenario outlines with examples, living documentation DO NOT USE FOR: free-form markdown test specs (use gauge), requirements documents (use prd or trd), architecture decisions (use adr)

Use when writing or improving integration tests that verify multiple components working together. Covers Testcontainers, ASP.NET WebApplicationFactory, Supertest, pytest with real databases, Spring Boot testing, test database patterns, and CI/Docker-in-Docker strategies. USE FOR: integration tests, Testcontainers, WebApplicationFactory, testing with real databases, testing multi-component interactions, service integration tests DO NOT USE FOR: isolated function tests (use unit-testing), full browser tests (use e2e-testing), service boundary verification (use contract-testing)

Use for load, stress, and scalability testing of applications and APIs. Covers k6 (Grafana), JMeter, Gatling, Artillery, and Lighthouse for web performance audits. Includes test type definitions, key metrics, thresholds, CI integration patterns, and performance budgets. USE FOR: k6, JMeter, Gatling, Artillery, Lighthouse, load testing, stress testing, performance benchmarks, Core Web Vitals, throughput testing, spike testing, soak testing, capacity planning, performance budgets DO NOT USE FOR: functional API testing (use api-testing), browser E2E tests (use e2e-testing), visual regression (use visual-testing)

Use when writing or reviewing code for readability, maintainability, and expressiveness — based on Robert C. Martin's "Clean Code." USE FOR: naming conventions, function design, comment quality, formatting standards, error handling strategy, code readability improvements DO NOT USE FOR: architecture layers (use clean-architecture), refactoring techniques (use refactoring), SOLID principles (use solid)

Micro-frontend architecture — composition approaches, Module Federation, single-spa, web components, shared state, and inter-app communication. Covers the patterns and tradeoffs for splitting a frontend across independent teams. USE FOR: micro-frontend architecture, Module Federation, single-spa, runtime composition, independent frontend deployment, cross-team frontend development DO NOT USE FOR: single-team SPA development (use spa), server-side rendering (use ssr), backend service decomposition (use dev/architecture/microservices)

Use when calling Azure-hosted AI models via the Azure.AI.Inference SDK. Covers chat completions, embeddings, streaming, model selection, and Azure AI model catalog integration. USE FOR: calling Azure AI model catalog models, Azure OpenAI chat completions, generating embeddings from Azure-hosted models, streaming chat responses, working with Mistral/Cohere/Llama models on Azure DO NOT USE FOR: provider-agnostic AI abstractions (use microsoft-extensions-ai), building agent workflows with tools (use agent-framework), on-device ML inference (use onnx), training custom ML models (use mlnet)

Use when building serverless event-driven applications with Azure Functions in .NET. Covers the isolated worker model, HTTP/Timer/Queue/Blob triggers, dependency injection, Durable Functions orchestration, and deployment. USE FOR: serverless HTTP APIs, event-driven processing (queues, blobs, timers), Durable Functions for long-running workflows, lightweight microservices without infrastructure management, scheduled background jobs DO NOT USE FOR: always-on web applications with WebSockets (use ASP.NET Core), complex multi-service orchestration with service discovery (use aspire), long-running compute without orchestration (use Azure Container Apps), Dapr-based microservices (use dapr)

USE FOR: Per-user or per-assembly sandboxed file storage in desktop applications, small settings or cache data scoped to user identity, and legacy ClickOnce or partial-trust application scenarios. DO NOT USE FOR: Server-side web applications, cross-machine shared storage, large file storage, modern applications where application data folders are preferred, or .NET Core/5+ applications targeting Linux or macOS (limited support).

Use when documenting .NET APIs with OpenAPI (Swagger) specifications, generating client SDKs, and configuring Swashbuckle or NSwag. USE FOR: API documentation with OpenAPI/Swagger, Swashbuckle configuration, NSwag client generation, XML comment documentation, API versioning with OpenAPI, minimal API documentation DO NOT USE FOR: general REST API design patterns (use aspnet-core), API gateway configuration, GraphQL schema documentation

Use when implementing the mediator pattern with Mediator.NET (source-generated) for high-performance in-process command/query dispatch in .NET. USE FOR: source-generated mediator pattern, in-process command dispatch, query handling, notification pub/sub, high-performance zero-reflection dispatch DO NOT USE FOR: distributed messaging (use masstransit or nservicebus), reflection-based mediator with large ecosystem (use mediatr), actor concurrency (use akka-net)

USE FOR: Reactive collection management using observable caches and lists with LINQ-style operators for filtering, sorting, grouping, transforming, and binding to UI collections. DO NOT USE FOR: Simple ObservableCollection scenarios, non-reactive LINQ queries, or server-side data access (use Entity Framework or Dapper).

Guidance for Migrant fast binary serialization library for .NET. USE FOR: fast binary serialization of complex object graphs, version-tolerant deserialization, simulation state snapshots, game save/load systems, deep object cloning via serialization, internal data persistence with circular reference support. DO NOT USE FOR: cross-language interop (use protobuf-net), REST API responses (use System.Text.Json), human-readable data formats, or long-term archival storage with strict schema guarantees.

Use when planning or conducting authorized penetration tests against web applications, APIs, networks, and mobile apps. Covers pen testing methodologies (OWASP, PTES, OSSTMM), scoping and rules of engagement, tool selection, reporting, and remediation verification. USE FOR: penetration testing, pen test methodology, PTES, OSSTMM, OWASP Testing Guide, web app pen testing, API pen testing, network pen testing, mobile pen testing, vulnerability assessment, bug bounty, responsible disclosure, rules of engagement DO NOT USE FOR: automated security scanning in CI/CD (use security-testing), threat modeling before implementation (use threat-modeling), AI/LLM-specific adversarial testing (use ai-security or red-teaming)

Event-Driven Architecture (EDA), Event Sourcing, and CQRS -- complementary but independent patterns for building reactive, scalable systems with rich audit trails and temporal queries. USE FOR: event-driven architecture, event sourcing, CQRS, event stores, projections, eventual consistency, compensating transactions, temporal queries DO NOT USE FOR: messaging channel patterns (use dev/integration-patterns), message routing (use dev/integration-patterns/message-routing), domain modeling (use domain-driven-design)

Use when identifying code smells and applying systematic refactoring techniques — based on Martin Fowler's "Refactoring." USE FOR: code smell identification, refactoring technique selection, safe code transformation, incremental improvement workflows, legacy code improvement DO NOT USE FOR: clean code principles (use clean-code), design pattern application (use dev/design-patterns), architecture restructuring (use dev/architecture)

Use when configuring Docker-in-Docker inside a dev container or Codespace. Covers the DinD feature, Docker Compose, building images, and running containers from within the dev environment. USE FOR: running Docker inside dev containers, DinD feature configuration, building images in Codespaces, Compose inside containers DO NOT USE FOR: general devcontainer.json schema (use devcontainer), sidecar services via Compose (use multi-container-workspaces), production Docker builds (use iac/docker)

Use when implementing Command Query Separation (CQS) or CQRS patterns to separate read and write operations in .NET applications. USE FOR: separating read/write models, CQS pattern implementation, CQRS architecture, dedicated command and query handlers, read/write model optimization DO NOT USE FOR: simple CRUD without separation concerns (use entity-framework-core), distributed messaging between services (use masstransit or nservicebus), in-process mediator with pipeline behaviors (use mediatr)

Guidance for Handlebars.NET template engine for .NET. USE FOR: logic-less HTML templating, email template rendering, code generation templates, report formatting, Mustache-compatible templates with helpers and partials. DO NOT USE FOR: sandboxed user-generated templates (use DotLiquid), full C# expression templates (use Razor), complex data transformations, server-side view rendering in ASP.NET.

Guidance for gRPC in .NET using Grpc.AspNetCore and Grpc.Net.Client. USE FOR: gRPC service definitions, proto file compilation, unary and streaming RPCs, gRPC client factory, deadline/cancellation, interceptors, gRPC-Web for browser clients. DO NOT USE FOR: REST/HTTP APIs (use ASP.NET Core), real-time browser push (use SignalR), custom TCP protocols (use dotnetty), email protocols (use mimekit).

USE FOR: Writing and running pattern-based static analysis rules for C# to detect security vulnerabilities, enforce coding standards, find anti-patterns, and automate code migrations. DO NOT USE FOR: Compile-time diagnostics (use Roslyn analyzers), dependency-level metrics (use NDepend), or runtime security scanning (use OWASP ZAP or Burp Suite).

USE FOR: Building Blazor applications with real-time state synchronization using Stl.Fusion computed observables, automatic invalidation, and server-to-client state replication. DO NOT USE FOR: Simple Blazor components without real-time needs, SignalR-only applications, or scenarios where standard Blazor state management (Fluxor, cascading values) is sufficient.

Guidance for Hyperion high-performance polymorphic serializer for .NET. USE FOR: Akka.NET actor message serialization, polymorphic type handling, object graph serialization with circular references, high-throughput binary serialization, version-tolerant deserialization of actor system messages. DO NOT USE FOR: human-readable serialization (use System.Text.Json), cross-language interop (use protobuf-net or Bond), REST API payloads, or long-term data storage requiring schema evolution.

Guidance for Behavior-Driven Development (BDD) patterns and Gherkin syntax in .NET. USE FOR: writing Gherkin feature files, structuring Given-When-Then scenarios, creating scenario outlines with data tables, organizing BDD step definitions, mapping business requirements to executable specifications with Reqnroll or SpecFlow. DO NOT USE FOR: unit test design (use xUnit/NUnit directly), performance testing, API contract testing (use Pact), or end-to-end browser automation (use Playwright).