sealad886/mindrally-skills

Use when implementing or auditing accessible web navigation, forms, dialogs, visual content, or keyboard interactions.

Use when building or repairing lightweight Alpine.js reactive components and backend-rendered interactions.

Use when performing exploratory data analysis, cleaning datasets, creating statistical plots, or building reproducible analytics notebooks.

Use when implementing or debugging Kotlin Android UI, navigation, lifecycle, background work, or app architecture.

Use when implementing or debugging Angular components, templates, signals, dependency injection, forms, or routing.

Use when implementing or debugging Angular components, templates, signals, dependency injection, forms, or routing.

Use when building or diagnosing Anime.js timelines, SVG motion, interactive animations, or framework integration.

Use when integrating Anthropic Messages, streaming, tool use, vision, caching, or batch processing.

Use when designing or implementing HTTP APIs in Go net/http or NestJS TypeScript.

Use when implementing Apollo Client GraphQL queries, mutations, normalized caching, pagination, or React integration.

Use when implementing ASP.NET Core APIs, middleware, authentication, authorization, caching, or configuration.

Use when implementing Astro pages, islands, content collections, routing, styling, or rendering performance.

Use when integrating Auth0 login, API token validation, sessions, Actions, refresh rotation, or MFA.

Use when building AutoGen AgentChat agents, tools, teams, state persistence, or controlled code execution.

Use when designing or running bounded AutoML and hyperparameter searches with Optuna, Ray Tune, PyCaret, or forecasting tools.

Use when implementing AWS Lambda, SAM/CDK infrastructure, DynamoDB access, API Gateway, or Step Functions.

Use when implementing Azure infrastructure, managed identity, Pipelines, monitoring, or AKS workloads.

Use when implementing backend logic in C++ or Elixir/Phoenix.

Use when writing or debugging Bash automation, argument parsing, pipelines, cleanup, or scheduled scripts.

Use when extracting or navigating HTML/XML using Python BeautifulSoup.

Use when working on Bitbucket pull requests, Pipelines, merge checks, or Jira-linked development.

Use when implementing Blazor components, data binding, render modes, lifecycle, state, or authorization.

Use when building Blender bpy operators, panels, properties, registration, or extension packages.

Use when working on CosmWasm/Cosmos contracts, storage, migration, or IBC cross-chain messages.

Use when implementing Bootstrap responsive layouts, interactive components, forms, or themes.

Use when implementing Business Central AL tables, pages, codeunits, extensions, reports, or job queues.

Use when implementing or reviewing C#/.NET logic, asynchronous APIs, resource lifetimes, Blazor, or Unity code.

Use when parsing or extracting HTML/XML with Cheerio in Node.js.

Use when building Manifest V3 Chrome extensions, content scripts, service workers, popups, messaging, or storage.

Use when implementing or diagnosing build/test pipelines, artifact promotion, deployment gates, or rollback procedures.

Use when designing or refactoring dependency boundaries in Flutter or Go applications.

Use when writing, reviewing, or simplifying code for readability, maintainability, and justified abstraction.

Use when integrating Clerk authentication, server authorization, organization access, or session handling in Next.js.

Use when implementing Cloudflare Workers, KV, D1, R2, Durable Objects, Pages Functions, or edge caching.

Use when building OpenCV image/video processing, feature matching, detection, tracking, or neural vision pipelines.

Use when implementing Convex queries, mutations, actions, HTTP routes, subscriptions, scheduled jobs, or file storage.

Use when implementing or reviewing C++ ownership, concurrency, language features, error handling, or performance.

Use when implementing or debugging responsive CSS layout, cascade, themes, typography, or motion.

Use when writing or diagnosing Cypress component or end-to-end tests, sessions, network assertions, or flaky workflows.

Use when building or auditing an executed Jupyter analysis notebook with pandas, NumPy, and statistical plots.

Use when analyzing datasets and reporting clear, reproducible findings with validated tables and visualizations.

Use when implementing reusable Python data transformations and Jupyter analysis workflows.

Use when designing, training, evaluating, or profiling neural networks and distributed training.

Use when integrating PyTorch training, Transformer/diffusion models, or bounded inference demos.

Use when implementing or debugging PyTorch neural models, training loops, fine-tuning, and inference.

Use when implementing Deno TypeScript services, permissions, module resolution, KV, or native tooling.

Use when creating or evolving design tokens, component libraries, theming, UI documentation, or governance.

Use when implementing DevOps automation, Ansible, Kubernetes, CI/CD, infrastructure, or operational recovery.

Use when implementing Django models, forms, views, authentication, migrations, or query performance.

Use when building Django REST Framework serializers, views, permissions, pagination, or transactional APIs.

Use when building or diagnosing Docker images, Compose services, container security, networking, or persistent data.

Use when implementing .NET backend APIs, EF Core data access, DI, async operations, validation, or integration tests.

Use when implementing Drizzle schema, typed queries, relations, transactions, drivers, or migrations.

Use when implementing Drupal modules, services, entities, routes, forms, queues, caching, or updates.

Use when designing Elasticsearch mappings, analysis, queries, pagination, bulk indexing, lifecycle, or cluster performance.

Use when implementing Electron windows, preload bridges, IPC, native modules, updates, or desktop packaging.

Use when implementing Elixir/Phoenix contexts, OTP processes, Ecto data access, LiveView, or error handling.

Use when implementing STM32 HAL peripherals, DMA, interrupts, RTOS coordination, memory, or firmware diagnostics.

Use when configuring esbuild entries, loaders, targets, splitting, plugins, watch/serve, or production output.

Use when implementing or reviewing Ethereum Solidity contracts, OpenZeppelin integrations, upgrades, or tests.

Use when building JavaScript Expo/React Native screens, navigation, lists, images, or native interactions.

Use when building typed Expo/React Native screens, state, navigation, safe areas, or device integrations.

Use when implementing Express TypeScript routers, middleware, validation, authentication, or error handling.

Use when deploying or adapting FastAPI services to serverless gateways, stateless scaling, or distributed workloads.

Use when implementing FastAPI endpoints, dependencies, Pydantic models, lifespan, or async data access.

Use when implementing Fastify routes, schemas, plugins/decorators, database integrations, or request tests.

Use when implementing a Figma design, mapping design tokens/components, exporting assets, or comparing design and rendered UI.

Use when implementing Firebase Firestore, Authentication, Functions, Storage, offline state, or security rules.

Use when implementing Flask application factories, blueprints, validation, persistence, authentication, or request handling.

Use when implementing Flutter/Dart widgets, state management, navigation, asynchronous data, or app architecture.

Use when implementing or reviewing modern Fortran modules, numerical procedures, kinds, arrays, C interfaces, or builds.

Use when implementing FPGA RTL, clock/reset domains, timing constraints, AXI/DMA interfaces, or resource/power optimization.

Use when implementing Motion/Framer Motion React animations, gestures, layout transitions, scroll motion, or exit behavior.

Use when implementing or reviewing web UI in React, Next.js, JavaScript, TypeScript, HTML, or CSS.

Use when implementing Unity C# gameplay or Lua game logic, assets, state, physics, or performance.

Use when implementing GML scripts, object events, gameplay state machines, collision, save data, or performance.

Use when implementing Google Cloud Run/functions, Firestore, BigQuery, Storage, Terraform, IAM, or operational telemetry.

Use when reviewing cross-stack engineering quality, testing, security, performance, observability, or maintainability.

Use when implementing Ghost CMS Handlebars themes, assets, membership UI, metadata, or performance.

Use when planning or performing authorized Git branching, selective commits, synchronization, conflict handling, or integration.

Use when working in a repository that explicitly uses Gitflow feature, develop, release, or hotfix branches.

Use when working on GitHub pull requests, review outcomes, issues, Actions, CODEOWNERS, or repository workflows.

Use when working on GitLab merge requests, pipelines, environments, security jobs, issues, or repository gates.

Use when implementing idiomatic Go libraries, HTTP services, errors, concurrency or modules.

Use when implementing Go net/http handlers, ServeMux routing, JSON APIs, middleware or request tests.

Use when implementing Go service boundaries, request cancellation, distributed calls, telemetry or graceful shutdown.

Use when building Google ADK agents, typed tools, workflow orchestration, sessions/state, artifacts, memory or evaluations.

Use when building or diagnosing GraalVM native images, reachability metadata, framework AOT, or native performance.

Use when designing GraphQL schemas, resolvers, mutations, generated clients, pagination, or query limits.

Use when designing GraphQL schemas, resolvers, typed operations, pagination, or React and Next.js client integration.

Use when defining protobuf contracts, implementing gRPC unary or streaming services, deadlines, authentication, or observability.

Use when building GSAP timelines, ScrollTrigger behavior, SVG animation, or lifecycle-safe React animation.

Use when building HarmonyOS ArkTS and ArkUI components, state models, resources, lifecycle behavior, or accessible layouts.

Use when implementing typed Hono routes, middleware, validation, runtime bindings, or API tests on supported JavaScript runtimes.

Use when writing semantic HTML documents, forms, media, interactive elements, or accessible document structure.

Use when building server-rendered interactions with htmx requests, swaps, history, validation, or progressive enhancement.

Use when engineering multilingual web or mobile interfaces, locale-aware formatting, translation loading, or RTL behavior.

Use when building Ionic interfaces, routing, platform-aware navigation, or Capacitor native integrations.

Use when developing Java language features, application modules, concurrency, persistence boundaries, or enterprise services.

Use when building Java Quarkus REST services, configuration, persistence, observability, or native-image paths.

Use when implementing Spring Boot services, dependency injection, web contracts, persistence, security, or asynchronous work.

Use when implementing or profiling JAX transformations, differentiable numerical code, pytrees, randomness, or device execution.

Use when writing Jest behavior tests, async assertions, mocks, spies, fake timers, or test isolation.

Use when developing Julia multiple-dispatch APIs, type-stable numerical kernels, scientific code, or performance measurements.

Use when implementing JWT issuance, validation, key rotation, refresh tokens, or token storage.

Use when building Kafka producers, consumers, schemas, topic partitioning, stream processing, or CDC pipelines.

Use when implementing typed Koa middleware, routing, validation, authentication, or API tests.

Use when implementing Kotlin domain models, null safety, functions, collections, or coroutine-backed behavior.

Use when designing Kubernetes manifests, workloads, resource/probe configuration, identities, or deployment validation.

Use when building typed Kysely SQL queries, dialect integration, transactions, migrations, or generated database types.

Use when building LangChain or LangGraph agents, runnables, tool workflows, persistence, or RAG.

Use when developing Laravel routes, Eloquent relationships, validation, Blade views, queues, or API resources.

Use when implementing Laravel application architecture, service-container integration, migrations, jobs, or frontend bundling.

Use when managing Lerna workspace tasks, versioning modes, changed-package selection, or authorized package publication.

Use when authoring Less variables, mixins, guards, imports, responsive styles, or stylesheet build configuration.

Use when building LlamaIndex ingestion, indexes, retrievers, query engines, agents, or persistent RAG applications.

Use when developing language-model training, parameter-efficient adaptation, evaluation, tokenization, or inference serving.

Use when adapting application content, regional terminology, formatting, layouts, or release QA for selected locales.

Use when designing structured application logs, severity, trace correlation, redaction, retention, or logging reliability.

Use when integrating Lottie or dotLottie web animation, playback events, loading, accessibility, or lifecycle cleanup.

Use when developing Lua modules, tables, metatables, protected errors, memory-sensitive loops, or engine integration.

Use when developing JAX-based machine-learning models, functional training state, automatic differentiation, or device-efficient training.

Use when creating Matplotlib scientific plots, multi-panel figures, accessible visual encodings, or export artifacts.

Use when extending Medusa v2 modules, data models, workflows, routes, subscribers, jobs, or admin interfaces.

Use when evaluating AI responses or supplied action traces with evidence-based rubrics and prompt revisions.

Use when developing Micronaut dependency injection, HTTP services, configuration, data/security integrations, or native builds.

Use when designing service boundaries, inter-service contracts, retries, asynchronous jobs, observability, or graceful shutdown.

Use when building modern TypeScript web features involving React/Next.js, data clients, responsive UI, or accessible interactions.

Use when designing MongoDB documents, indexes, aggregation, transactions, or version-aware Mongoose and Payload integration.

Use when defining service metrics, SLOs, actionable alerts, dashboards, probes, or capacity signals.

Use when organizing JavaScript/TypeScript workspaces, shared packages, cross-platform application boundaries, or task caching.

Use when building Tamagui cross-platform UI and shared packages in a Next.js and Expo workspace.

Use when building Motion JavaScript animations, sequences, scroll/in-view behavior, playback control, or cleanup.

Use when implementing MQTT topics, QoS, persistent sessions, retained state, reconnect behavior, or device messaging security.

Use when designing MySQL schemas, indexes, transactions, queries, replication diagnostics, or safe maintenance plans.

Use when developing typed NestJS modules, providers, DTO validation, guards, persistence, or API tests.

Use when configuring Netlify builds, Functions or Edge Functions, scheduled/background work, Blobs, Image CDN, or deploy contexts.

Use when diagnosing target-scoped developer DNS, TCP, TLS, proxy, HTTP, or registry connectivity failures.

Use when integrating Auth.js or NextAuth sessions, providers, callbacks, server authorization, or runtime-compatible adapters.

Use when building Next.js and React features using Redux Toolkit, typed state, hydration, or client/server data boundaries.

Use when developing typed Next.js App Router components, rendering boundaries, URL state, or responsive accessible UI.

Use when building Next.js and Tailwind interfaces with Supabase authentication, database access, or SSR.

Use when building NLP preprocessing, tokenization, classification, entity extraction, embeddings, or generation pipelines.

Use when developing Node.js TypeScript services, Payload integrations, validated APIs, or Vue-backed client/server contracts.

Use when implementing NumPy array operations, broadcasting, dtype control, random sampling, numerical validation, or performance tuning.

Use when building typed Nuxt/Vue pages, composables, server APIs, runtime configuration, or SSR data flows.

Use when configuring Nx project graphs, inferred tasks, module boundaries, generators, affected checks, or computation caching.

Use when implementing OAuth authorization-code and PKCE flows, OIDC sign-in, token exchange, scopes, or refresh behavior.

Use when instrumenting distributed tracing, metrics, structured logs, context propagation, sampling, or telemetry pipelines.

Use when extending Odoo models, computed fields, constraints, XML views, controllers, security rules, or scheduled jobs.

Use when integrating OnchainKit identity, wallet, transaction, swap, or supported mini-app components.

Use when integrating OpenAI text, tools, structured output, embeddings, multimodal inputs, streaming, or API error handling.

Use when profiling and optimizing Next.js TypeScript rendering, bundles, data loading, images, or interactive responsiveness.

Use when processing pandas DataFrames, joins, missing data, time series, dtype conversion, or memory-sensitive analysis.

Use when configuring Parcel entries, targets, assets, CSS/TypeScript transforms, code splitting, or development proxying.

Use when measuring and improving web loading, rendering, runtime work, assets, caching, or query performance.

Use when developing Phoenix contexts, Ecto persistence, LiveView interactions, real-time processes, or authenticated web flows.

Use when implementing PHP application modules, types, Composer autoloading, data access, validation, or error handling.

Use when building PixiJS scenes, assets, tickers, pointer interaction, texture caching, or mobile rendering performance.

Use when writing Playwright end-to-end tests, semantic locators, web-first assertions, browser projects, or trace diagnosis.

Use when maintaining Playwright tests with stable locators, conditional waits, fixtures, parallel isolation, or browser coverage.

Use when managing pnpm workspaces, dependency protocols, filters, lockfiles, install policy, or package release preparation.

Use when configuring PostCSS transforms, browser targets, nesting, prefixing, minification, or CSS plugin pipelines.

Use when designing PostgreSQL schema/indexes, inspecting query plans, transactions, RLS, pooling, or maintenance plans.

Use when reviewing a pull request or diff for correctness, security, regressions, tests, performance, or architecture.

Use when implementing Prisma schemas, typed queries, transactions, pagination, or version-aware query instrumentation.

Use when evolving Prisma schemas, migrations, generated TypeScript clients, data access boundaries, or persistence tests.

Use when automating browser interactions, extraction, screenshots, PDFs, interception, or isolated browser sessions with Puppeteer.

Use when building web manifests, service-worker offline behavior, cache updates, background sync, or push notifications.

Use when building PySpark transformations, joins/windows, idempotent ETL, or Apache Iceberg writes and metadata checks.

Use when developing Python application code, automation, data processing, or version-aware web services.

Use when building authorized Python security diagnostics, bounded network probes, secure command execution, or findings reporting.

Use when developing Python Odoo addons, ORM methods, XML/QWeb views, controllers, translations, or security rules.

Use when designing Python tests, pytest fixtures/parametrization, mocks, integration checks, or property-based invariants.

Use when managing uv project dependencies, lockfiles, environments, or PEP723 standalone Python scripts.

Use when developing PyTorch modules, training/evaluation, autograd, mixed precision, data loading, or device-aware inference.

Use when developing Quarkus configuration, CDI, REST/data/security integrations, observability, or JVM/native artifacts.

Use when designing RabbitMQ exchanges/queues, delivery acknowledgments, publisher confirms, retry/DLX handling, or broker integration.

Use when implementing React components, hooks, state ownership, accessibility, or measured rendering improvements.

Use when changing React Native components, virtualized lists, navigation, styling, or device performance.

Use when building React Three Fiber scenes, especially when selecting web versus React Native rendering and assets.

Use when maintaining React Query or TanStack Query fetching, cache keys, invalidation, pagination, or optimistic mutations.

Use when implementing React Router v7 framework routes, loaders, actions, forms, pending UI, or route error boundaries.

Use when writing or reviewing a project README, installation instructions, quick start, examples, or repository documentation links.

Use when implementing Redis caching, structures, expiration, streams, transactions, connection handling, or operational diagnostics.

Use when implementing Redux Toolkit stores, slices, selectors, thunks, RTK Query, or typed React integration.

Use when maintaining a Remix application’s routes, loaders, actions, sessions, progressive forms, or migration decisions.

Use when adapting web layouts, typography, imagery, and interactions across viewport sizes, zoom levels, and input modes.

Use when implementing Django REST Framework endpoints, serializers, permissions, ORM queries, or API failure handling.

Use when implementing Robocorp Python tasks, RPA workflows, task lifecycle, logging, or controlled external automation.

Use when configuring Rollup outputs, plugins, externals, code splitting, tree shaking, or package exports.

Use when implementing ROS 2 packages, nodes, interfaces, QoS, frames, launch configuration, or colcon tests.

Use when designing or maintaining RSpec examples, test data, shared behaviors, doubles, or Ruby/Rails regression coverage.

Use when implementing RTL locales, logical layout properties, mixed-direction text, or direction-aware controls.

Use when implementing Ruby objects, modules, collections, errors, or version-specific language behavior.

Use when changing Rails models, controllers, migrations, jobs, caching, Hotwire views, or integration behavior.

Use when implementing Rust ownership, errors, modules, async tasks, channels, or measured performance changes.

Use when implementing Apex, bulk triggers, SOQL, Lightning Web Components, or Salesforce metadata security.

Use when managing Salesforce DX source, scratch-org configuration, metadata validation, packaging, or sf CLI workflows.

Use when changing Sanity Studio schemas, GROQ queries, typed content access, previews, or client configuration.

Use when implementing .sass stylesheets, modules, mixins, maps, calculations, or compilation fixes.

Use when building scikit-learn preprocessing pipelines, model selection, evaluation, or persisted estimators.

Use when implementing SciPy optimization, interpolation, integration, linear algebra, statistics, or signal processing.

Use when implementing Scrapy spiders, selectors, request scheduling, pipelines, crawl limits, or reproducible extraction tests.

Use when changing .scss stylesheets, tokens, modules, mixins, selector output, or Dart Sass compilation.

Use when reviewing or implementing input handling, authorization, secrets, sessions, injection defenses, or backend security controls.

Use when integrating security review, secret/dependency checks, CI trust boundaries, or evidence-based vulnerability remediation.

Use when implementing Selenium browser tests, resilient locators, explicit waits, page abstractions, or cross-browser checks.

Use when reviewing crawlability, metadata, canonical URLs, structured data, page performance, or search-facing content.

Use when changing Sequelize models, associations, migrations, transactional writes, hooks, or query behavior.

Use when adapting functions or APIs to serverless event sources, retries, cold starts, quotas, or managed service boundaries.

Use when changing Shopify Liquid, Online Store theme sections, JSON templates, cart interactions, images, or localization.

Use when designing Shopify theme structure, merchant settings, section/block schemas, locale keys, or theme-editor behavior.

Use when designing Snowflake AI SQL calls, extraction/classification, Cortex Search retrieval, or bounded model evaluation.

Use when designing Snowflake SQL pipelines, semi-structured data, streams/tasks, dynamic tables, warehouse performance, or recovery.

Use when implementing Snowpark DataFrames/UDFs or dbt-snowflake models, incremental updates, tests, and environment isolation.

Use when implementing Solana or Anchor instructions, account validation, PDAs, compute limits, or transaction clients.

Use when implementing or reviewing Solidity state transitions, permissions, token interactions, gas behavior, or wallet transaction integration.

Use when changing Spring Boot configuration, REST endpoints, persistence, security, async work, or application tests.

Use when implementing Spring dependency injection, bean lifecycle, web handling, transactions, scheduling, or framework integration.

Use when writing or reviewing SQL queries, schema constraints, indexes, transactions, pagination, or database performance.

Use when writing Storybook stories, controls, documentation, interaction checks, themes, or component accessibility examples.

Use when implementing Stripe checkout, PaymentIntents, subscriptions, customer ownership, webhooks, or payment-state reconciliation.

Use when implementing styled-components themes, dynamic styles, transient props, SSR, or React styling performance.

Use when implementing Supabase database access, authentication, RLS, storage, realtime, or Edge Function integration.

Use when connecting Supabase to application SSR, database migrations, auth lifecycle, storage, realtime, or Edge Functions.

Use when implementing Svelte components, runes, snippets, state sharing, effects, or a deliberate legacy-to-runes migration.

Use when implementing SvelteKit routes, load functions, actions, endpoints, rendering options, or server/client state.

Use when changing Swift models, concurrency, errors, persistence, platform integration, or SwiftUI-facing application behavior.

Use when implementing SwiftUI views, Observation/state ownership, async UI flow, navigation, adaptive layout, or measured rendering performance.

Use when implementing SWR data keys, conditional fetching, cache scope, optimistic mutations, pagination, or revalidation.

Use when implementing SystemVerilog modules, sequential/combinational logic, CDC, memory inference, assertions, or timing closure.

Use when implementing Tailwind utilities, responsive states, themes, content detection, or version-specific configuration.

Use when implementing TanStack Query v5 options, cache ownership, server-state transitions, mutations, infinite queries, or Suspense.

Use when implementing TanStack Router routes, search validation, context, beforeLoad guards, loaders, or query integration.

Use when implementing TanStack Start server functions, server routes, SSR/streaming, build configuration, or deployment adapters.

Use when implementing Tauri frontend/Rust commands, permissions, events, filesystem access, native builds, or desktop/mobile integration.

Use when writing developer tutorials, API explanations, operational guides, or implementation documentation grounded in actual behavior.

Use when implementing TensorFlow/Keras input pipelines, training, evaluation, callbacks, or serving exports.

Use when preparing Terraform configuration, provider/module constraints, plans, state handling, or infrastructure change review.

Use when selecting or improving tests that prove a requirement, failure mode, public contract, or regression.

Use when implementing Three.js rendering, scene resources, loaders, animation, draw-call optimization, or React Three Fiber integration.

Use when loading, adapting, training, generating with, or evaluating Hugging Face Transformers models and processors.

Use when implementing tRPC procedures, input validators, auth context, transport links, errors, or React/query integration.

Use when configuring or debugging Next.js Turbopack resolution, loaders, caching, build compatibility, or measured build performance.

Use when configuring Turborepo task graphs, workspace dependencies, inputs/outputs, filters, or local/remote caching.

Use when implementing TypeORM entities, relations, DataSource, migrations, transaction handling, or database query behavior.

Use when designing TypeScript interfaces, narrowing unknown data, generics, module boundaries, or strictness improvements.

Use when designing or reviewing interface hierarchy, controls, visual states, responsive layout, or accessibility.

Use when implementing Unity C# components, game state, input/UI, resource lifetime, physics, or measured performance.

Use when investigating or improving user tasks, navigation, content disclosure, recovery, or usability evaluation.

Use when preparing Vercel application builds, function runtimes, environment scope, preview behavior, or Next.js/AI integration.

Use when integrating an existing ViewComfy workflow endpoint, parameter schema, streamed logs, or generated outputs.

Use when configuring Vite framework plugins, assets, environment exposure, development proxying, HMR, or production builds.

Use when implementing Pinia stores, reactive selectors, async actions, SSR scope, persistence, or store/component tests.

Use when implementing typed Vue components, props/emits, refs, composables, or build/type integration.

Use when reviewing Vue/TypeScript component architecture, composables, reactive boundaries, accessibility, or measured performance.

Use when implementing HTML/CSS, Bootstrap, Django templates/forms, or HTMX-enhanced web interactions.

Use when extracting authorized website data, choosing HTTP/parser/browser tools, or implementing bounded crawl and validation behavior.

Use when configuring Webpack entry/output, loaders/plugins, code splitting, side effects, caching, or build diagnostics.

Use when implementing WebSocket authentication, message validation, reconnect/replay, fanout, or slow-consumer handling.

Use when implementing WooCommerce hooks, products/orders, checkout extensions, REST endpoints, or data integrity.

Use when implementing WordPress hooks, admin/REST handlers, settings, data queries, scheduled work, or theme extensions.

Use when defining Zod schemas, parsing untrusted data, inferring input/output types, transforming values, or reporting validation errors.

Use when implementing Zustand stores, selectors, middleware, persistence, SSR scope, or async client workflow state.