Mindrally

Best practices for Zustand state management in React and TypeScript applications, covering store design, selectors, middleware, SSR, and testing. Use when creating or refactoring Zustand stores, deciding whether state belongs in Zustand vs component state vs a server-state library, optimizing selector re-renders, adding persist/devtools/immer middleware, or handling Zustand with SSR/React Server Components.

Best practices for Zod schema validation and type inference in TypeScript applications.

Expert in WordPress and WooCommerce development with PHP best practices

WordPress and WooCommerce development guidelines with PHP best practices, security standards, and extensibility patterns

Best practices and guidelines for building real-time applications with WebSocket communication

Best practices and guidelines for Webpack module bundler configuration, optimization, and development workflows

Expert in web scraping and data extraction with Python tools

Web development guidelines covering Bootstrap, Django, HTMX, and general web best practices

Vue.js and TypeScript best practices for building performant applications with Vite, Pinia, VueUse, and Tailwind CSS.

Expert in Vue.js TypeScript development with Vite, Pinia, and modern UI frameworks

Vue 3 state management with Pinia using the Composition API, covering setup stores, SSR/Nuxt integration, persistence, and testing. Use when creating or refactoring Pinia stores, deciding what state belongs in a store versus a component, wiring stores into router guards, persisting store state to storage, or testing store actions with @pinia/testing.

Expert guidance for Vite development with modern build tooling, HMR, framework integrations, and performance optimization

Expert guidance for integrating ViewComfy API into web applications using Python and FastAPI

Vercel and Next.js deployment best practices including server components, edge functions, AI SDK integration, and performance optimization.

UX design principles for creating intuitive, accessible, and user-centered digital experiences

Expert in Unity and C# game development with performance optimization patterns

UI design best practices for building accessible, performant, and user-friendly interfaces with modern web standards

Expert in TypeScript development with best practices for type safety and clean code

Guidelines for developing with TypeORM, a full-featured ORM for TypeScript and JavaScript supporting multiple databases

Best practices for Turborepo monorepo build system configuration and optimization

Best practices and guidelines for Turbopack, the Rust-powered incremental bundler for Next.js and modern web development

Guidelines for writing Next.js apps with tRPC v11 for end-to-end typesafe APIs

Expert guidance for working with Hugging Face Transformers library for NLP, computer vision, and multimodal AI tasks.

Expert guidance for Three.js and React Three Fiber development with modern React, TypeScript, and performance best practices

General testing best practices and guidelines for writing comprehensive, maintainable tests across different testing frameworks and languages.

Expert in Terraform infrastructure-as-code with cloud deployment patterns

Best practices for building, training, evaluating, and deploying neural networks with TensorFlow and Keras. Use when writing tf.data input pipelines, defining or training a Keras model, configuring callbacks for checkpointing and early stopping, evaluating a trained model, or exporting a model for serving.

Expert technical writing guidelines for creating clear, in-depth developer tutorials and documentation with practical, implementable knowledge

Tauri development guidelines for building cross-platform desktop applications with TypeScript, Rust, and modern web technologies

Best practices for TanStack Start, the full-stack React framework built on TanStack Router and Vite/Nitro. Use when building server functions with createServerFn, setting up SSR and streaming with defer()/Await, writing API routes, configuring app.config.ts, or deploying a TanStack Start app to Node, Vercel, Netlify, Bun, or Cloudflare.

Type-safe, file-based routing for React with TanStack Router. Use when defining routes with createFileRoute, validating search params with Zod, writing route loaders, setting up auth guards with beforeLoad, integrating TanStack Query into loaders, or configuring router context and preloading.

Best practices for TanStack Query v5 (React Query) server state management, including query key factories, the queryOptions helper, mutations, optimistic updates, infinite queries, and Suspense mode. Use when fetching or caching server data in React, writing custom query/mutation hooks, setting up a QueryClient, implementing optimistic updates, or migrating v4 patterns to v5.

Expert in TailwindCSS utility-first styling with responsive design patterns

SystemVerilog development guidelines for FPGA and ASIC design covering modular design, verification, and timing optimization.

Guidelines for using SWR (stale-while-revalidate) React Hooks for efficient data fetching, caching, and revalidation

Guidelines for building SwiftUI applications with MVVM/Clean Architecture, Swift 6 strict concurrency, and modern state management. Use when building SwiftUI views, structuring view models, managing state with @State/@Observable, handling async data flow, or optimizing SwiftUI view performance.

Expert in Swift and SwiftUI development for iOS, macOS, and Apple platforms

Expert guidance for SvelteKit development with TypeScript, Tailwind CSS, SSR/SSG, and performance optimization best practices

Modern Svelte 5 and SvelteKit development covering runes-based reactivity, snippets, SSR/SSG, and state management, including migration notes from legacy Svelte 4 syntax. Use when writing or reviewing Svelte components, deciding between runes and legacy reactive statements, building SvelteKit routes and load functions, or migrating a Svelte 4 codebase to Svelte 5.

Supabase development guidelines for database, authentication, real-time subscriptions, and Edge Functions.

Expert in Supabase backend development with authentication and database patterns

styled-components best practices for CSS-in-JS development in React applications

Stripe payment integration guidelines for TypeScript, React, Next.js with secure payment processing and subscription management

Best practices for building and documenting component libraries with Storybook

SQL development best practices for writing efficient, secure, and maintainable database queries

Expert guidance for Spring Framework and Spring Boot development with Java best practices, dependency injection, and RESTful API design

Expert guidance for Spring Boot application development with best practices for RESTful APIs, testing, security, and deployment

Best practices for secure, gas-efficient Solidity smart contract development and Web3 frontend integration. Use when writing or reviewing Solidity contracts, hardening against reentrancy and access-control bugs, optimizing gas usage, setting up Hardhat/Foundry testing and static analysis, or wiring a React frontend to wallets, providers, and on-chain transactions.

Expert guidelines for Solana program development with Rust, Anchor framework, and Web3.js integration

Best practices for Snowpark Python (DataFrames, UDFs, UDTFs, stored procedures) and dbt with the dbt-snowflake adapter. Use when writing server-side Snowpark pipelines, registering UDFs or stored procedures, choosing dbt materializations, configuring incremental models, or setting up sources and tests for a Snowflake-backed dbt project.

Best practices for Snowflake SQL, semi-structured data, and data pipelines built with Dynamic Tables, Streams, Tasks, and Snowpipe. Use when writing Snowflake SQL, designing ingestion or transformation pipelines, tuning warehouse performance and cost, or working with Time Travel, cloning, RBAC, or Iceberg tables on Snowflake.

Reference for Snowflake Cortex AI Functions (AI_COMPLETE, AI_CLASSIFY, AI_EXTRACT, AI_FILTER, etc.) and Cortex Search for building RAG applications entirely inside Snowflake. Use when writing SQL that calls an LLM, classifying or extracting structured data from text, building a natural-language WHERE filter, or setting up hybrid vector+keyword search for retrieval-augmented generation.

Expert Shopify theme development with Liquid, Online Store 2.0, and performance best practices

Expert Shopify theme development guidelines for Liquid, Online Store 2.0, CSS, JavaScript, and UX best practices

Serverless and microservices development guidelines covering FastAPI, cloud-native patterns, API gateways, and best practices for scalable serverless architectures.

Guidelines for developing with Sequelize, a promise-based Node.js ORM supporting PostgreSQL, MySQL, MariaDB, SQLite, and SQL Server

Apply SEO best practices for web applications including metadata, performance optimization, and search engine optimization techniques.

Expert guidance for browser automation and web testing using Selenium WebDriver with best practices for element location, waits, and test organization.

DevSecOps, secure software development lifecycle (SSDLC), and application security (AppSec) practices covering secret handling, input validation, dependency hygiene, authentication/authorization, and CI/CD security tooling (SAST, SCA, DAST, secret scanning, IaC scanning). Use when writing code that handles credentials, user input, database queries, or authentication, when setting up a CI/CD pipeline, or when reviewing code or infrastructure for security issues.

Security best practices for backend development, microservices, and secure coding patterns with emphasis on input validation and authentication

SCSS/Sassy CSS best practices and coding guidelines for maintainable, scalable stylesheets

Expert guidance for building web scrapers and crawlers using the Scrapy Python framework with best practices for spider development, data extraction, and pipeline management.

Best practices for SciPy scientific computing, optimization, signal processing, and statistical analysis in Python

Best practices for scikit-learn machine learning, model development, evaluation, and deployment in Python

Sass (indented syntax) best practices and coding guidelines for clean, maintainable stylesheets

Sanity CMS development guidelines for schema creation, GROQ queries, TypeScript integration, and project organization

Expert guidance for Salesforce DX development with modern tooling, source-driven development, and CI/CD best practices

Expert guidance for Salesforce development including Apex, Lightning Web Components, and metadata best practices

Expert in Rust development with focus on safety, performance, and async programming

Conventions and best practices for building web applications with Ruby on Rails. Use when scaffolding Rails apps or generators, designing ActiveRecord models and migrations, wiring up Hotwire/Turbo/Stimulus interactivity, setting up background jobs or caching, or writing RSpec/Minitest coverage for Rails code.

Ruby development guidelines covering idiomatic code style, Ruby 3.x features, testing with RSpec, and best practices for building maintainable Ruby applications.

Right-to-left (RTL) layout and bidirectional text support for Hebrew, Arabic, Persian, and Urdu interfaces. Use when building UI that must support RTL languages, converting physical CSS/Tailwind properties to logical ones, handling mixed-direction (bidi) text, mirroring directional icons, or testing an app with dir="rtl".

RSpec testing best practices for Ruby and Rails applications, covering test organization, data management, and isolation patterns.

Best practices for ROS 2 robotics development, covering package structure, nodes, topics/services/actions, launch files, QoS, tf2 transforms, and testing. Use when creating ROS 2 packages, writing nodes in rclpy or rclcpp, defining custom messages/services/actions, writing launch files, configuring QoS profiles, working with tf2 transforms, or building and testing a colcon workspace.

Best practices and guidelines for Rollup.js module bundler configuration, ES modules, and library bundling

Guidelines for building RoboCorp RPA automation with Python, emphasizing functional programming, Pydantic validation, and async operations.

Comprehensive guidelines for Django REST API development covering project structure, views, models, serializers, authentication, performance, and error handling.

Comprehensive guidelines for responsive web design including mobile-first approach, flexible layouts, media queries, and cross-device optimization

Expert guidance for Remix development with TypeScript, loaders/actions, nested routes, and full-stack web application best practices

Comprehensive Redux Toolkit best practices for React and Next.js applications with TypeScript.

Redis development best practices for caching, data structures, and high-performance key-value operations

Structure, tone, and content conventions for writing effective project README files, covering hooks, quick starts, feature presentation, badges, and common documentation sections. Use when writing a new README, rewriting an existing one, or reviewing README quality for a repository, library, or CLI tool.

React Router v7 framework mode conventions for route modules, data loaders, actions, and progressive enhancement. Use when building file-based routes with loaders/actions, handling form submissions with Form/useFetcher/useSubmit, adding route ErrorBoundary components, revalidating data after mutations, or migrating Remix-style route modules to React Router v7.

Guidelines for using React Query for data fetching, caching, and server state synchronization in React applications

Expert guidance for React Three Fiber development with React, Vite, Tailwind CSS, and three.js

React Native development best practices for TypeScript, functional components, performance optimization, and styling guidelines.

Expert in React development with modern patterns, hooks, and performance optimization

Best practices and guidelines for RabbitMQ message queue development with AMQP protocol

Expert guidance for Quarkus framework development with Jakarta EE, MicroProfile, GraalVM native builds, and reactive programming patterns

PyTorch deep learning development with transformers, diffusion models, and GPU optimization.

Guidelines for Python dependency management using uv, the fast Python package installer and resolver.

Expert in Python testing with pytest and test-driven development

Guidelines for Python and Odoo enterprise application development with ORM, XML views, and module architecture best practices.

Guidelines for building Python cybersecurity tools with secure coding practices, async scanning, and structured security testing.

Expert in Python development with best practices across web, data science, and automation

Best practices for building performant, testable PySpark ETL pipelines with Spark SQL and Apache Iceberg. Use when writing or reviewing PySpark jobs, designing joins and window functions, working with map/array higher-order functions, or building idempotent cumulative/snapshot table merges.

Progressive Web App development guidelines covering service workers, caching strategies, offline functionality, and installability

Expert guidance for browser automation using Puppeteer with best practices for web scraping, testing, screenshot capture, and JavaScript execution in headless Chrome.

Comprehensive Prisma ORM development guidelines with TypeScript, schema design, migrations, and best practices.

Expert in Prisma ORM with type-safe database operations and schema design

Focused pull request review practices with severity-ranked, file-and-line-cited findings across four angles: security, performance, tests, and architecture. Use when asked to review a pull request, review a diff or set of changes, review "this PR," or provide a code review before merge.

PostgreSQL development best practices for schema design, query optimization, and database administration

PostCSS best practices and configuration guidelines for modern CSS processing and optimization

Best practices for pnpm package manager, workspace management, and monorepo configuration

Expert guidance for Playwright end-to-end testing with TypeScript and JavaScript best practices

Playwright end-to-end testing best practices for web applications, covering test design, locator strategies, and assertion patterns.

Expert guidance for Pixi.js game development with TypeScript, focusing on high-performance web and mobile games

Expert guidance for PHP 8+ development with SOLID principles, PSR standards, and modern best practices

Phoenix framework development guidelines covering LiveView, Ecto, real-time features, and best practices for building scalable web applications with Elixir.

Performance optimization guidelines for web development including server-side rendering, CSS best practices, and JavaScript optimization

Best practices and guidelines for Parcel, the zero-configuration web application bundler

Best practices for Pandas data manipulation, analysis, and DataFrame operations in Python

Optimized Next.js TypeScript best practices with modern UI/UX, focusing on performance, security, and clean architecture

Expert guidance for OpenAI API development including GPT models, Assistants API, function calling, embeddings, and best practices for production applications.

Expert guidance for building onchain applications with OnchainKit SDK components and utilities

Expert guidance for Odoo ERP development including Python ORM, XML views, and module architecture

Observability guidelines for distributed systems using OpenTelemetry, tracing, metrics, and structured logging

Guidelines for implementing OAuth 2.0 and OAuth 2.1 authentication flows with security best practices and PKCE

Best practices for Nx monorepo development, project configuration, and code generation

Best practices for building Nuxt 3 and Vue 3 applications with TypeScript, the Composition API, and Tailwind CSS. Use when structuring Nuxt/Vue projects, writing composables, typing components and props, wiring up server routes and plugins, or optimizing Nuxt builds and Web Vitals.

Best practices for NumPy array programming, numerical computing, and performance optimization in Python

Node.js development guidelines covering Payload CMS, Vue.js with TypeScript, and general TypeScript best practices

Expert guidance for natural language processing development using transformers, spaCy, NLTK, and modern NLP techniques.

Full-stack Next.js 14 development with TypeScript, TailwindCSS, and Supabase for building production-ready web applications.

Expert in TypeScript, Node.js, Next.js App Router, React, Shadcn UI, Radix UI and Tailwind

Comprehensive Next.js, React, Redux, and TypeScript development guidelines covering SOLID principles, component architecture, and best practices.

Guidelines for implementing NextAuth.js (Auth.js v5) authentication in Next.js applications with session management and security best practices

Systematic, safety-first diagnosis of developer network failures such as connection refused, DNS resolution errors, TLS certificate problems, proxy failures, and package registry timeouts. Use when a command fails with a network-shaped error (curl, npm, pip, git, docker), when a service is unreachable, or when the user asks to debug connectivity, DNS, TLS, or proxy issues.

Best practices for building and deploying Netlify sites, covering serverless and edge functions, Netlify Blobs storage, the Image CDN, and build configuration. Use when writing Netlify Functions or Edge Functions, configuring netlify.toml or redirects/headers, managing environment variables across deploy contexts, working with Netlify Blobs, or setting up local development and deploy previews.

Clean NestJS API development with TypeScript following SOLID principles, modular architecture, and comprehensive testing practices.

MySQL development best practices for schema design, query optimization, and database administration

Best practices and guidelines for MQTT messaging in IoT and real-time communication systems

Expert guidelines for building performant animations with Motion (formerly Motion One) vanilla JavaScript animation library

Monorepo development guidelines using Tamagui, Turbo, Next.js, Expo, Supabase, and cross-platform best practices.

Best practices for monorepo development with TypeScript, React, Next.js, Expo, Turbo, and related technologies

Monitoring guidelines for applications and infrastructure including metrics collection, alerting strategies, and SLO-based monitoring

MongoDB development guidelines with Payload CMS, Mongoose, aggregation pipelines, and TypeScript best practices.

Modern web development best practices for TypeScript, Next.js 14, React Server Components, Supabase, GraphQL, and Tailwind CSS.

Guidelines for building production-grade microservices with FastAPI/Python and Go, covering serverless patterns, clean architecture, observability, and resilience.

Expert guidance for Micronaut framework development with compile-time dependency injection, GraalVM native builds, and cloud-native microservices

Meta-prompting framework for critiquing responses, analyzing solution trajectories, and evaluating AI-generated content quality

Best practices for building commerce applications with Medusa v2, the headless e-commerce framework. Use when defining Medusa data models, writing workflows and steps with the Workflow SDK, creating API routes or subscribers, building module services that extend MedusaService, throwing MedusaError, or customizing the Medusa admin dashboard.

Best practices for Matplotlib data visualization, plotting, and creating publication-quality figures in Python

Machine learning development with JAX, functional programming patterns, and high-performance computing.

Lua development guidelines covering tables, metatables, error handling, game development, and performance optimization.

Expert guidelines for implementing performant Lottie animations on the web

Logging best practices for applications and services including structured logging, log levels, and log management strategies

Implement localization (l10n) best practices to adapt applications for specific regions, languages, and cultural preferences.

Large Language Model development, training, fine-tuning, and deployment best practices.

Expert guidance for LlamaIndex development including RAG applications, vector stores, document processing, query engines, and building production AI applications.

Less CSS best practices and coding guidelines for maintainable, modular stylesheets

Best practices for Lerna monorepo management, versioning, and publishing

Expert guidance for Laravel PHP development following best practices, SOLID principles, and Laravel conventions

Expert in Laravel PHP development with best practices and modern patterns

Expert guidance for LangChain and LangGraph development with Python, covering chain composition, agents, memory, and RAG implementations.

Guidelines for developing with Kysely, a type-safe TypeScript SQL query builder with autocompletion support

Expert in Kubernetes and DevOps with infrastructure-as-code and cloud-native patterns

Kotlin development guidelines with best practices for clean code, naming conventions, function design, and data handling

Guidelines for building modern APIs with Koa.js and TypeScript, featuring the onion middleware model and async/await patterns

Best practices for Apache Kafka event streaming and distributed messaging. Use when building event-driven architectures, implementing producer/consumer patterns, designing topic partitioning strategies, setting up Kafka Streams, configuring schema registries, or integrating change data capture pipelines.

Guidelines for implementing JWT authentication with security best practices for token creation, validation, and storage

Julia development guidelines covering multiple dispatch, type system, performance optimization, and scientific computing best practices.

Jest testing best practices for JavaScript and TypeScript applications, covering test structure, mocking, and assertion patterns.

Expert in JAX for high-performance numerical computing and machine learning

Java Spring Boot development guidelines with best practices for building robust, secure, and maintainable enterprise applications

Java Quarkus development guidelines for building cloud-native applications with fast startup, minimal memory footprint, and GraalVM native builds

Expert in Java development with Spring Boot and enterprise patterns

Ionic development guidelines for building cross-platform mobile applications with Angular, Cordova, and Firebase integration.

Implement internationalization (i18n) best practices for web and mobile applications to support multiple languages and locales.

HTMX development guidelines for building dynamic web applications with minimal JavaScript using HTML attributes.

Guidelines for semantic HTML markup, document structure, forms, accessibility attributes, and modern HTML best practices

Guidelines for building edge-first, high-performance APIs with Hono and TypeScript for Cloudflare Workers, Deno, Bun, and Node.js

Best practices for HarmonyOS application development with ArkTS and ArkUI, covering components, state management, resources, layout, lifecycle, and accessibility. Use when writing .ets component files, using ArkUI decorators like @Component/@State/@Prop/@Link, building layouts with Column/Row/Stack/List, managing HarmonyOS app resources with $r(), or handling component lifecycle and accessibility on HarmonyOS.

Expert guidelines for building high-performance animations with GSAP (GreenSock Animation Platform)

Best practices for building high-performance services with gRPC and Protocol Buffers. Use when designing RPC services, defining protobuf schemas, implementing streaming APIs, setting up gRPC interceptors, or building cross-language service communication.

GraphQL development guidelines with type-safe clients, schema design, and integration with React and Next.js.

Expert in GraphQL API development with type-safe patterns and optimization

Expert guidance for GraalVM native image development with Java frameworks, build optimization, and high-performance application deployment

Best practices for building AI agents with Google's Agent Development Kit (ADK) in Python, covering agent design, tools, sessions, memory, artifacts, evaluation, and deployment. Use when building LLM agents or multi-agent systems with ADK, defining ADK tools, wiring up sessions/state/memory, working with ADK artifacts, writing agent evals, or deploying ADK agents to Vertex AI Agent Engine or Cloud Run.

Go backend development best practices for microservices with clean architecture, observability, and production-ready patterns

Go API development guidelines using the standard library (1.22+) with best practices for RESTful API design, error handling, and security

Expert in Go/Golang development with focus on APIs, microservices, and clean architecture

GitLab best practices for merge requests, CI/CD pipelines, issue tracking, and DevOps workflows

GitHub best practices for pull requests, code reviews, issues, Actions workflows, and repository management

Branching, merging, versioning, and release conventions for the Gitflow workflow, covering main/develop branches, feature/release/hotfix branches, semantic versioning, and pull request rules. Use when creating a branch, naming a branch, planning a release or hotfix, writing a commit message, or setting up branch protection for a repository that follows Gitflow.

Git conventions and workflow guidelines using Conventional Commits, branching strategies, and best practices for version control

Ghost CMS theme development with Handlebars templating, Alpine.js, Tailwind CSS, and performance optimization

General software development best practices covering code quality, testing, security, performance, and maintainability across technology stacks

Google Cloud Platform (GCP) development best practices for Cloud Functions, Cloud Run, Firestore, BigQuery, and Infrastructure as Code.

Best practices for GameMaker Language (GML) development, covering scripts, object events, rooms, data structures, and performance-minded game code. Use when writing GML scripts or object event code in GameMaker Studio, structuring create/step/draw events, managing rooms and instances, building state machines for gameplay, or optimizing GML for performance.

Expert guidance for game development with C#/Unity, Lua scripting, and best practices for scalable game architecture

Senior Front-End Developer expertise in ReactJS, NextJS, JavaScript, TypeScript, HTML, CSS, and modern UI/UX frameworks

Expert guidelines for building performant animations with Framer Motion/Motion library in React applications

FPGA development guidelines covering Vivado, SystemVerilog, timing closure, AXI interfaces, and hardware optimization.

Best practices for modern Fortran (2003/2008+) scientific and numerical computing, covering modules, explicit interfaces, kind parameters, memory safety, and testing. Use when writing or reviewing Fortran source (.f90/.f95/.f03/.f08), defining modules and derived types, choosing numeric kind parameters, working with allocatable arrays, setting up a Fortran build with CMake or fpm, or writing unit tests for numerical code.

Expert in Flutter and Dart development with clean architecture and state management

Guidelines for Flask Python development with best practices for blueprints, RESTful APIs, and application factories.

Firebase development guidelines for Firestore, Authentication, Functions, and Storage with TypeScript and Angular.

Guidelines for integrating Figma designs with development workflows using MCP servers and best practices

Guidelines for building high-performance APIs with Fastify and TypeScript, covering validation, Prisma integration, and testing best practices

Expert in FastAPI Python development with best practices for APIs and async operations

Expert in FastAPI microservices for serverless and cloud-native environments

Guidelines for building robust APIs with Express.js and TypeScript, covering middleware patterns, routing, and security best practices

Expert in Expo React Native TypeScript mobile development with best practices

Expo React Native JavaScript best practices for clean code, functional components, performance optimization, and Expo Router navigation.

Expert guidelines for Ethereum smart contract development with Solidity, OpenZeppelin, and Hardhat

Best practices and guidelines for esbuild, the ultra-fast JavaScript and TypeScript bundler and minifier

Best practices for embedded C/C++ development on STM32 microcontrollers using the HAL, covering peripherals, DMA, interrupts, memory constraints, and hardware-focused testing. Use when writing STM32 HAL code, configuring peripherals generated by STM32CubeMX, working with interrupts or DMA, debugging with SWD/JTAG, managing memory-constrained firmware, or writing hardware-in-the-loop or host-build tests for embedded C.

Expert in Elixir and Phoenix development with functional programming patterns

Electron development guidelines for building cross-platform desktop applications with JavaScript/TypeScript

Elasticsearch development best practices for indexing, querying, and search optimization

Expert guidance for Drupal 10 module development with PHP 8+, SOLID principles, and Drupal coding standards

Guidelines for developing with Drizzle ORM, a lightweight type-safe TypeScript ORM with SQL-like syntax

Guidelines for .NET backend development with C#, ASP.NET Core, and Entity Framework Core

Docker containerization best practices for building, securing, and deploying containers.

Comprehensive guidelines for building scalable Django REST APIs with proper architecture, authentication, and performance optimization.

Expert in Django Python web development with best practices

Comprehensive DevOps engineering practices for Kubernetes, CI/CD, Bash scripting, Ansible, and cloud infrastructure.

Comprehensive design system guidelines for building consistent, accessible, and scalable component libraries. Use when creating design tokens, building component libraries, implementing design systems, setting up theming architecture, or establishing UI governance processes.

Guidelines for developing with Deno and TypeScript using modern runtime features, security model, and native tooling

Expert guidance for deep learning, transformers, diffusion models, and LLM development with PyTorch, Transformers, Diffusers, and Gradio.

Guidelines for deep learning development with PyTorch, Transformers, Diffusers, and Gradio for LLM and diffusion model work.

Comprehensive deep learning guidelines for neural network development, training, and optimization.

Guidelines for data analysis and Jupyter Notebook development with pandas, matplotlib, seaborn, and numpy.

Data analysis best practices with pandas, numpy, matplotlib, seaborn, and Jupyter notebooks.

Expert guidance for data analysis, visualization, and Jupyter Notebook development with pandas, matplotlib, seaborn, and numpy.

Cypress end-to-end testing best practices for web applications, covering test structure, commands, and reliability patterns.

Best practices for CSS development including modern layout techniques, naming conventions, theming, and maintainable stylesheet architecture

Guidelines for modern C++ development with C++17/20 standards, memory safety, and performance optimization

Guidelines for developing with Convex backend-as-a-service platform, covering queries, mutations, actions, and real-time data patterns

Expert guidance for computer vision development using OpenCV, PyTorch, and modern deep learning techniques for image and video processing.

Cloudflare Workers, Pages, KV, D1, R2, and Durable Objects development best practices for edge computing applications.

Guidelines for implementing Clerk authentication in Next.js applications with middleware, hooks, and security best practices

Clean, maintainable, human-readable code principles combined with anti-over-engineering discipline: naming, single responsibility, DRY, and scoping changes to exactly what was requested. Use when writing new code, refactoring existing code, reviewing code for quality, or deciding how much abstraction a change actually needs.

Guidelines for implementing Clean Architecture patterns in Flutter and Go applications, with emphasis on separation of concerns, dependency rules, and testability.

CI/CD best practices for building automated pipelines, deployment strategies, testing, and DevOps workflows across platforms

Expert guidelines for Chrome extension development with Manifest V3, covering security, performance, and best practices. Use when building browser extensions, creating popup UIs, implementing content scripts, working with Chrome APIs, managing extension permissions, or publishing to Chrome Web Store.

Expert guidance for HTML/XML parsing using Cheerio in Node.js with best practices for DOM traversal, data extraction, and efficient scraping pipelines.

Guidelines for C# development including Blazor, Unity game development, and .NET backend best practices

Expert guidance for Microsoft Dynamics 365 Business Central development using AL language and extensions

Bootstrap development guidelines for responsive layouts, components, and utility-first styling.

Expert guidelines for blockchain development including CosmWasm, Cosmos, and cross-chain patterns

Best practices for writing Blender Python add-ons using the bpy API, covering operators, panels, properties, registration, and API-safe scripting. Use when creating a Blender add-on, defining bpy.types.Operator or Panel classes, registering PropertyGroup settings, writing register()/unregister() functions, working with bmesh, or debugging add-ons in Blender's Python console.

Guidelines for Blazor development including component lifecycle, state management, and performance optimization

Bitbucket best practices for pull requests, Pipelines CI/CD, Jira integration, and Atlassian ecosystem workflows

Expert guidance for HTML/XML parsing using BeautifulSoup in Python with best practices for DOM navigation, data extraction, and efficient scraping workflows.

Bash scripting guidelines covering security, portability, error handling, and automation best practices for DevOps.

Guidelines for backend development in C++ and Elixir/Phoenix, covering modern language features, best practices, and production-ready patterns.

Azure cloud development guidelines for ARM templates, Azure Pipelines, Kubernetes, and cloud-native services.

AWS development best practices for Lambda, SAM, CDK, DynamoDB, IAM, and serverless architecture using Infrastructure as Code.

Best practices for AutoML and hyperparameter search with Optuna, Ray Tune, and PyCaret, covering search-space design, validation splits, and leakage prevention. Use when tuning model hyperparameters, setting up a pruned or distributed hyperparameter search, designing a nested validation scheme, or evaluating whether an AutoML leaderboard result is production-ready.

Expert guidance for Microsoft AutoGen multi-agent framework development including agent creation, conversations, tool integration, and orchestration patterns.

Guidelines for implementing Auth0 authentication with best practices for security, rules, actions, and SDK integration

Expert in Astro framework with static generation and partial hydration patterns

Guidelines for ASP.NET Core web development covering API design, authentication, caching, and best practices

Guidelines for developing GraphQL APIs and React applications using Apollo Client for state management, data fetching, and caching

Guidelines for building clean, scalable APIs with Go standard library and NestJS TypeScript, covering security, validation, and modular architecture.

Expert guidance for Anthropic Claude API development including Messages API, tool use, prompt engineering, and building production applications with Claude models.

Expert guidelines for building performant animations with Anime.js animation library

Expert guidance for Angular and TypeScript development focused on scalable, high-performance web applications

Expert in Angular TypeScript development with scalable, high-performance patterns

Android development guidelines for Kotlin with clean architecture, MVI pattern, Material Design, and best practices for building robust mobile applications

Best practices for analytics, data analysis, and visualization using Python, pandas, matplotlib, seaborn, and Jupyter notebooks. Use when performing exploratory data analysis, building data pipelines, creating statistical visualizations, writing Jupyter notebooks, cleaning and transforming datasets, or implementing analytics dashboards.

Alpine.js development guidelines for lightweight reactive interactions with Tailwind CSS and various backend frameworks.

Implement web accessibility (a11y) best practices following WCAG guidelines to create inclusive, accessible user interfaces.