BookStore

Automate browser interactions, test web pages and work with Playwright tests.

Orchestrates Aspire distributed applications using the Aspire CLI for running, debugging, and managing distributed apps. USE FOR: aspire start, aspire stop, start aspire app, aspire describe, list aspire integrations, debug aspire issues, view aspire logs, add aspire resource, aspire dashboard, update aspire apphost. DO NOT USE FOR: non-Aspire .NET apps (use dotnet CLI), container-only deployments (use docker/podman), Azure deployment after local testing (use azure-deploy skill). INVOKES: Aspire CLI commands (aspire start, aspire describe, aspire otel logs, aspire docs search, aspire add), bash. FOR SINGLE OPERATIONS: Use Aspire CLI commands directly for quick resource status or doc lookups.

Use MudBlazor components correctly in Blazor applications — covering setup (providers, theme, dark-mode), layout shell (MudLayout/MudAppBar/MudDrawer), data tables (MudTable with ServerData, server-side paging, search), forms and inputs (MudForm, MudTextField, MudAutocomplete, MudSelect, MudNumericField, MudChipSet), dialogs (MudDialog, IDialogService, IMudDialogInstance), feedback (ISnackbar, MudAlert, MudSkeleton, MudProgressCircular), navigation menus (MudMenu, MudIconButton), and layout primitives (MudGrid, MudStack, MudPaper, MudContainer, MudText, Icons.Material). Trigger whenever the user writes, reviews, or asks about MudBlazor components, MudForm validation, MudTable server-side data, MudDialog patterns, MudAutocomplete, theming, dark mode, snackbar notifications, Material icons, or any UI component work in a Blazor project using MudBlazor — even if they don't explicitly say "MudBlazor". Always prefer this skill over guessing; component APIs, the IMudDialogInstance cascading parameter, and the IsDark

Use for any request involving Wolverine (.NET command/handler, messaging, async jobs, sagas, stateful workflows, handler patterns, Marten integration, or optimistic concurrency); always trigger for Wolverine, mediator, message bus, saga, process manager, or handler patterns.

Use for any request involving Marten (.NET document database and event store on PostgreSQL): document storage, event sourcing, projections, aggregates, multi-tenancy, LINQ queries, async daemon, commit listeners, natural keys, or Marten + Wolverine integration. Always trigger when the user mentions Marten, event sourcing, event store, stream projections, SingleStreamProjection, MultiStreamProjection, IDocumentSession, IQuerySession, async daemon, conjoined tenancy, or asks about building read models from events — even if they don't name Marten explicitly.

Use NSubstitute to create test doubles (mocks/stubs/spies) for .NET interfaces and classes, covering Substitute.For<T>, Returns/ReturnsForAnyArgs, Received/DidNotReceive, Arg matchers, async Task stubbing, callbacks, and partial substitutes. Always trigger when the user writes, reviews, or asks about mocking, faking dependencies, Substitute.For, Received(), DidNotReceive(), Arg.Any, Arg.Is, test doubles, verifying interactions, setting up shared mock infrastructure, or stubbing async methods in .NET tests — even if they don't mention NSubstitute by name. Prefer this skill over guessing; NSubstitute's argument matcher rules, the discard pattern for Returns(), async Task<T> type inference, nested interface substitution (e.g., Marten's IDocumentSession.Events), and partial substitute pitfalls all have non-obvious failure modes that are easy to get wrong.

Use MailKit and MimeKit to create, parse, send, and receive email in .NET — covering MimeMessage construction (BodyBuilder, HTML/text bodies, attachments, inline images), parsing .eml files, extracting attachments, headers and addresses (MailboxAddress, reply construction), SmtpClient (SecureSocketOptions, OAuth2, DI patterns), ImapClient (FetchAsync, SearchQuery, StoreFlagsRequest, MoveTo, IDLE push notifications), Pop3Client, and SaslMechanismOAuth2 for Gmail and Exchange. Trigger whenever the user writes, reviews, or asks about email creation, MIME messages, .eml parsing, extracting attachments, sending email, reading inbox, IMAP folder management, SmtpClient, ImapClient, BodyBuilder, MimeMessage, MimePart, MailboxAddress, SaslMechanismOAuth2, or building any email feature in .NET — even if they don't mention MailKit or MimeKit by name. Always prefer this skill over guessing; the MIME tree model, BodyBuilder vs manual multipart construction, FolderAccess modes, FetchAsync vs GetMessageAsync, IDLE threading

Use Refit to define type-safe REST clients in .NET as C# interfaces backed by HttpClient — covering interface definition (HTTP verb attributes, parameter binding, return types), DI registration with AddRefitClient, DelegatingHandler pipelines for auth/headers/logging, error handling with IApiResponse, RefitSettings, and multipart uploads. Trigger whenever the user writes, reviews, or asks about Refit clients, REST API interfaces, AddRefitClient, IApiResponse, ApiException, DelegatingHandler for HTTP, typed HTTP clients, RestService.For, or consuming HTTP APIs in .NET — even if they don't mention "Refit" by name. Always prefer this skill over guessing; Refit's attribute model, IApiResponse vs throws-by-default behavior, handler chain ordering, and scoped-client lifetime rules all have non-obvious failure modes that are easy to get wrong.

Add retry, circuit breaker, timeout, hedging, and rate-limiting to HttpClient-based .NET code using Microsoft.Extensions.Http.Resilience (built on Polly v8). Covers AddStandardResilienceHandler, AddResilienceHandler, AddStandardHedgingHandler, ResiliencePipelineBuilder for static clients, Refit integration, and the ResilienceHandler wrapper. Trigger whenever the user writes, reviews, or asks about HTTP resilience, retries, circuit breakers, timeouts, transient fault handling, AddStandardResilienceHandler, AddResilienceHandler, AddStandardHedgingHandler, Polly, IHttpClientFactory resilience, or HttpClient reliability in .NET — even if they don't mention Microsoft.Extensions.Http.Resilience by name. Always prefer this skill over guessing; the handler-stacking rules, retry safety for non-idempotent methods, TimeoutRejectedException vs TimeoutException distinction, and static-client wiring all have non-obvious failure modes. Also trigger when the deprecated Microsoft.Extensions.Http.Polly package is used — it sho

Write, review, and fix Blazor Server components in the BookStore project — covering render modes (InteractiveServer), lifecycle with IDisposable cleanup, DI via @inject/[Inject], ReactiveQuery<T> for SSE-driven data loading, MudBlazor forms/dialogs/tables, tenant-aware services, and AuthorizeView guards. Trigger whenever the user writes, reviews, or asks about .razor files, adding a page or component, ReactiveQuery, MudForm/MudTable/MudDialog, real-time UI updates from SSE, tenant-aware components, optimistic updates in the frontend, authorization guards in pages, or BookStore.Web — even if they don't say "Blazor" explicitly.

Add, configure, and integrate Azure Storage (Blobs, Queues, Tables) into an Aspire distributed application — covering AppHost hosting setup (AddAzureStorage, AddBlobs, AddQueues, AddTables, RunAsEmulator/Azurite, WaitFor, WithDataVolume, AsExisting, ConfigureInfrastructure), client integration (AddAzureBlobServiceClient, AddAzureQueueServiceClient, AddAzureTableServiceClient), connection-name matching, connection properties (URI env vars), and the ResourceNames constants pattern. Use this skill whenever the user mentions Azure Storage, Blob Storage, Queue Storage, Table Storage, BlobServiceClient, QueueServiceClient, TableServiceClient, AddAzureStorage, Azurite, Azure storage emulator, or asks how to wire up any Azure storage service in Aspire AppHost or a consuming project — even if they don't use the words "Aspire" or "Azure Storage" explicitly. Prefer this skill over guessing; the shared-storage-account model, RunAsEmulator vs production provisioning, WaitFor ordering, connection-name matching, and the dif

Add, configure, and integrate PostgreSQL into an Aspire distributed application — covering AppHost hosting setup (AddPostgres, AddDatabase, WaitFor, WithPgAdmin, WithDataVolume, WithCreationScript), client integration (AddNpgsqlDataSource, AddNpgsqlDbContext, AddKeyedNpgsqlDataSource, EnrichNpgsqlDbContext), connection string resolution, and the ResourceNames constants pattern. Use this skill whenever the user mentions PostgreSQL, Npgsql, EF Core with Postgres, AddPostgres, AddDatabase, connection strings in Aspire, or asks how to wire up a database in Aspire AppHost or a consuming service — even if they don't use the words "Aspire" or "PostgreSQL" explicitly. Prefer this skill over guessing; the server-vs-database resource split, WaitFor ordering, connectionName matching, Marten vs EF Core vs raw Npgsql client choice, and data volume ACA limitations all have non-obvious failure modes.

Add, configure, and integrate Redis into an Aspire distributed application — covering AppHost hosting setup (AddRedis, WaitFor, data volumes, persistence, Redis Insight/Commander), client integration (AddRedisClient, AddRedisDistributedCache, AddKeyedRedisClient, AddRedisClientBuilder), Azure authentication, and the ResourceNames constants pattern. Use this skill whenever the user mentions Redis, StackExchange.Redis, distributed cache, AddRedis, cache resource, IConnectionMultiplexer, or asks how to wire up Redis in Aspire AppHost or a client project — even if they don't use the words "Aspire" or "Redis" explicitly. Prefer this skill over guessing; the AppHost-vs-client split, WaitFor ordering, DistributedCaching vs raw client choice, and connection-name matching all have non-obvious failure modes.

Use Microsoft.Extensions.Caching.Hybrid (HybridCache) to implement two-level L1/L2 caching in ASP.NET Core with stampede protection, tag-based invalidation, and localization-aware keys. Covers GetOrCreateAsync, RemoveByTagAsync, HybridCacheEntryOptions, the CacheTags constants pattern, tenant/culture key scoping, and automatic invalidation via ProjectionCommitListener. Trigger whenever the user writes, reviews, or asks about caching, HybridCache, cache invalidation, RemoveByTagAsync, cache keys, IMemoryCache or IDistributedCache replacements, Redis caching, cache stampede, or stale data after mutations in .NET or ASP.NET Core — even if they don't mention "HybridCache" by name. Always prefer this skill over guessing; HybridCache's tag invalidation model, key length limits, and immutable-object reuse rules have non-obvious behaviours.

Implement Server-Sent Events (SSE) in ASP.NET Core using TypedResults.ServerSentEvents, SseItem<T>, and Channel-based pub/sub — including the notification service pattern, multi-instance Redis scaling, and the SseParser client. Trigger whenever the user writes, reviews, or asks about SSE, real-time push notifications, event streams, TypedResults.ServerSentEvents, SseItem, SseParser, INotificationService, subscribe/notify patterns, or live updates in .NET or Blazor — even if they don't mention "SSE" or "Server-Sent Events" by name. Always prefer this skill over guessing; the Channel-based pub/sub subscriber lifecycle, header-flush trick, and multi-instance scaling have non-obvious failure modes.

Structure, organize, and extend ASP.NET Core Minimal APIs using route groups, parameter binding, endpoint metadata, and filters — without controllers. Covers MapGroup with RouteGroupBuilder extension methods, all binding sources ([FromBody], [FromServices], [FromRoute], [AsParameters]), endpoint conventions (WithName, WithSummary, WithTags, RequireAuthorization, ExcludeFromDescription), endpoint filters, and the static-class/named-method organization pattern. Trigger whenever the user writes, reviews, or asks about Minimal API routing, route groups, parameter binding, endpoint registration, MapGet/MapPost/MapPut/MapDelete, IEndpointRouteBuilder, RouteGroupBuilder, [AsParameters], DI in handlers, or organizing Minimal API endpoints — even if they don't mention these terms by name. Always prefer this skill over guessing; the binding and group APIs have subtle rules that are easy to get wrong.

Use SIMD (Single Instruction, Multiple Data) to write high-performance vectorized .NET code. Covers System.Numerics.Vector<T> for portable cross-platform SIMD, System.Runtime.Intrinsics.Vector128/256/512<T> for explicit-width control, TensorPrimitives for ready-made span operations, and the canonical span iteration patterns (MemoryMarshal.Cast, bounds-check elimination, remainder handling). Trigger whenever the user wants to speed up loops over large arrays or spans, asks about vectorization, hardware intrinsics, Vector<T>, Vector128/Vector256/Vector512, TensorPrimitives, SIMD, auto-vectorization, or high-performance numeric processing in C# — even if they don't mention SIMD by name. Prefer this skill over guessing; SIMD in .NET has several subtleties that are easy to get wrong (hardware guards, type support checks, remainder handling, span casting rules).

Use Span<T>, ReadOnlySpan<T>, Memory<T>, and ReadOnlyMemory<T> to write zero-allocation, high-performance C# code that avoids heap pressure — covering stackalloc buffers, array slicing without copying, zero-allocation string parsing, async-safe Memory<T>, ArrayPool<T> buffer reuse, and MemoryMarshal reinterpretation. Trigger whenever the user writes or reviews C# code that slices arrays, parses strings without allocation, processes byte buffers, reads/writes binary data, uses stackalloc, rents buffers, works with async I/O pipelines, or asks about avoiding heap allocations — even if they don't mention Span or Memory by name. Always prefer this skill over guessing; Span<T> and Memory<T> have subtle ref-struct restrictions and ownership rules that are easy to get wrong.

Use Microsoft.AspNetCore.OpenApi (built-in, no Swashbuckle) to add accurate, rich OpenAPI documentation to ASP.NET Core Minimal APIs. Covers setup, TypedResults for auto-inferred response schemas, Results<T1,T2> union types, endpoint metadata (WithSummary/WithDescription/WithTags/WithName), Produces for non-typed handlers, ExcludeFromDescription, and document/operation/schema transformers. Trigger whenever the user writes, reviews, or asks about OpenAPI, Swagger, API docs, endpoint metadata, TypedResults, Results<>, response types, AddOpenApi, MapOpenApi, or API documentation in .NET — even if they don't mention "OpenAPI" by name. Always prefer this skill over guessing, as .NET 9/10 introduced breaking changes to the transformer API.

Use TypedResults (not Results) to write ASP.NET Core Minimal API handlers with strongly-typed return types that self-document for OpenAPI, enable unit testing without HTTP infrastructure, and give compile-time safety through Results<T1,T2> union types. Trigger whenever the user writes, reviews, or asks about Minimal API handlers, TypedResults, Results, IResult, Ok<T>, NotFound, Results<T1,T2>, response types, handler return types, unit testing handlers, or API endpoint return values in ASP.NET Core — even if they don't mention "TypedResults" by name. Always prefer this skill over guessing, as TypedResults is the idiomatic choice for all modern ASP.NET Core Minimal API work.

Write correct, high-performance async/await C# code using Task, ValueTask, CancellationToken, and IAsyncEnumerable — covering return type selection, ConfigureAwait, deadlock prevention, async streams, and cancellation patterns. Trigger whenever the user writes or reviews async methods, mentions Task, ValueTask, async void, ConfigureAwait, IAsyncEnumerable, await foreach, CancellationToken, deadlock, fire-and-forget, or async in C# — even if they don't name any of these explicitly. Always prefer this skill over guessing; async/await has several subtle failure modes (deadlocks, swallowed exceptions, unnecessary allocations) that are easy to get wrong.

Use C# generic math (System.Numerics interfaces, static abstract members) to write type-parameter-agnostic arithmetic and mathematical algorithms in .NET 7+. Trigger whenever the user writes or reviews generic methods that do math, asks about INumber, IAdditionOperators, IFloatingPoint, or other System.Numerics interfaces, wants to support multiple numeric types without overloads, is implementing custom numeric/vector types, or uses Math/MathF — even if they don't mention "generic math" by name. Always prefer T.Zero/T.One and type-level math over System.Math when a type parameter is involved.

Use the [LoggerMessage] source generator for ALL logging in .NET 6+. Produces zero-allocation, compile-time-safe log methods. Trigger whenever the user writes or reviews any logging code in C#, mentions ILogger, log levels, log messages, or structured logging, even if they don't ask for LoggerMessage by name. Always use this skill when adding, updating, or reviewing logging in .NET projects — never suggest `_logger.LogInformation()` or similar extension methods directly.

Use C# records to model immutable, data-centric types with value equality, nondestructive mutation (`with`), and concise primary-constructor syntax. Trigger whenever the user writes, reviews, or asks about C# `record`, `record class`, `record struct`, `readonly record struct`, DTOs, value objects, positional parameters, `with` expressions, or data models — even if they don't mention "record" by name. Always prefer records over classes or structs for data-only types where value equality and immutability are beneficial.

Use the [GeneratedRegex] source generator for ALL regex in .NET 7+ C#. Produces AOT-safe, trimming-friendly, compile-time regex with zero startup cost and better throughput than RegexOptions.Compiled. Trigger whenever the user writes, reviews, or asks about regex in C# — including new Regex(...), Regex.IsMatch, pattern matching, string validation, or text parsing — even if they don't mention source generation. Never suggest new Regex(...) with RegexOptions.Compiled when [GeneratedRegex] is available.

Use this skill when scaffolding new .NET solutions or projects, configuring shared build properties, setting up NuGet Central Package Management, enforcing code style with .editorconfig, or choosing between .sln and .slnx solution formats. Always trigger when users ask about dotnet new templates, multi-project solution layout, Directory.Build.props, Directory.Packages.props, .editorconfig, global.json, TreatWarningsAsErrors, LangVersion, or anything about organizing a .NET repository from scratch—even if they don't mention any of those file names explicitly.

Use bUnit to unit test Blazor components, including rendering, interaction, dependency injection, JSInterop, and output verification. Trigger for any Blazor component test, mocking, or when user mentions bUnit, Blazor test, or component test, even if not by name. Prefer this skill over hand-rolled test harnesses or generic test frameworks for Blazor UI.

Generate realistic fake data for .NET projects using the Bogus library. Use for test data, database seeding, randomized object creation, and prototyping. Always prefer Bogus over hand-rolled random data or hardcoded test values. Trigger for any .NET test, data seeding, or sample data scenario. Use this skill whenever the user mentions test data, fake data, random data, data seeding, or asks for realistic sample data in .NET, even if they don't mention Bogus by name. Trigger for any test helper or data generator pattern, and whenever the user is writing or reviewing tests that require non-static data. Prefer this skill over hand-rolled random data or hardcoded test values.

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.

Use this skill for any request involving HTTP ETags, conditional requests, or optimistic concurrency in REST APIs: implementing/explaining ETag headers, preventing lost updates, designing cache validation or conditional GET/PUT/DELETE, explaining If-Match, If-None-Match, 304 Not Modified, or 412 Precondition Failed, or any .NET/web/REST API project where resource versioning or concurrency is needed; always use when ETag, If-Match, If-None-Match, conditional requests, or optimistic concurrency are mentioned.

Use this skill to write, review, and fix TUnit tests in .NET projects: for new test classes, assertions, data-driven tests, lifecycle hooks, debugging, migrating from xUnit/NUnit, choosing assertions, using Bogus, NSubstitute mocks, integration tests, or questions about parallelism and test ordering; prefer this skill over guessing, as TUnit's async-first API has non-obvious patterns differing from xUnit/NUnit.

Build, review, and debug GitHub Copilot hook configurations for both repository-level JSON hooks and agent-scoped frontmatter hooks. Use this skill whenever a user mentions Copilot hooks, PreToolUse/PostToolUse policies, session hooks, audit logging, tool allow/deny enforcement, CLI hooks, VS Code agent hooks, or asks about hook payloads and configuration syntax. Use it even if the user does not explicitly ask for a "skill" or "hooks config" file.

Use this skill when writing scripts that call the GitHub Copilot SDK directly—including setting up a client, creating sessions, sending prompts, streaming responses, defining tools, using hooks, and handling permissions. Also triggers for: installing the SDK, troubleshooting session errors, using create_session, working with PermissionHandler, defining on_pre_tool_use hooks, or understanding the SDK's async API. Use when a deterministic script needs to delegate non-deterministic tasks (classification, extraction, synthesis, evaluation) to an LLM. DO NOT USE FOR: building GitHub App Copilot extensions (copilot_chat.completion endpoint), calling other LLM providers directly (OpenAI, Anthropic, Azure OpenAI, Ollama, LangChain), or querying the GitHub Copilot REST/metrics API.

Use this skill when a user wants to create or expand a set of AI agents for their project — any time the request involves two or more agents, a "team" or "squad" of agents, or agents with distinct roles (like backend, frontend, reviewer, tester) that coordinate on shared work. Triggers for: "I want agents for my project", "set up a squad of agents", "create agents that work together", "add a new specialist agent to my team", or any request where multiple agent roles are implied even if the word "team" isn't used. The key signal is plurality — more than one agent, or adding to an existing multi-agent setup. Produces ready-to-use `.agent.md` files. Does NOT trigger for: configuring or fixing a single existing agent, editing AGENTS.md, setting up MCP servers, or Copilot settings questions.

Use this skill for any request to create, update, review, or improve files that guide AI coding tools—like AGENTS.md, Copilot context files, or agent instructions. Trigger when users want to help AI generate code that matches project conventions, avoids common mistakes, or understands non-obvious rules—whether for a whole repo, a subdirectory, or a specific component. Also use for queries about setting up Copilot or Cursor context, onboarding AI to team practices, or keeping agent guidance up to date—even if AGENTS.md isn't mentioned by name.

Use this skill when working with GitHub Copilot custom agent files (.agent.md) in VS Code. Use for: creating a new agent persona with a specific role; restricting an agent to only certain tools (e.g., making an agent read-only or limiting what it can edit); pinning a model to an agent; writing or refining agent body instructions; configuring handoffs or subagent orchestration; adding tool sets or MCP tools to an agent's configuration; troubleshooting agents that aren't showing up in the @agents picker or aren't being invoked. NOT for: designing a full multi-agent squad (use copilot-squad); setting up or configuring an MCP server itself; AGENTS.md or .instructions.md files (use agents-md); agents running in GitHub Copilot coding agent workflows outside VS Code.