skills

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

Expert in Astro framework with static generation and partial hydration patterns

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

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

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

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.

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

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

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

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

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

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

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

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.

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

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

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

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

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

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.

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

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

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 Clerk authentication in Next.js applications with middleware, hooks, and security best practices

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

Expert in Django Python web development with best practices

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

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

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

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

Expert in Elixir and Phoenix development with functional programming patterns

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.

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

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

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

Expert in Expo React Native TypeScript mobile development with best practices

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

Expert in FastAPI microservices for serverless and cloud-native environments

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

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

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

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

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

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

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.

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

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

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

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

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.

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

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

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

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

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.

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

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

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

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

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

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.

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

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

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

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.

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

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.

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

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

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

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

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

Expert in Java development with Spring Boot and enterprise patterns

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

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

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

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

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

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

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 building modern APIs with Koa.js and TypeScript, featuring the onion middleware model and async/await patterns

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

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

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

Expert in Laravel PHP development with best practices and modern patterns

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

Best practices for Lerna monorepo management, versioning, and publishing

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

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

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

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

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

Expert guidelines for implementing performant Lottie animations on the web

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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.

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.

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

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

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

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

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

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

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

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 Nx monorepo development, project configuration, and code generation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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.

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

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

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

Expert in Python testing with pytest and test-driven development

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

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

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

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

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

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

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

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

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

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.

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.

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

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

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

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

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

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

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

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.

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

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".

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

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.

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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.

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.

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.

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

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 guidance for Spring Boot application development with best practices for RESTful APIs, testing, security, and deployment

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

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

Best practices for building and documenting component libraries with Storybook

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

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

Expert in Supabase backend development with authentication and database patterns

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

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.

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

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

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.

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

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

Expert in TailwindCSS utility-first styling with responsive design patterns

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 guidance for Vite development with modern build tooling, HMR, framework integrations, and performance optimization

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

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

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

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 in Terraform infrastructure-as-code with cloud deployment patterns

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

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

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

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

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

Best practices for Turborepo monorepo build system configuration and optimization

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

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

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

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

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

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

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

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 in Vue.js TypeScript development with Vite, Pinia, and modern UI frameworks

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

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

Expert in web scraping and data extraction with Python tools

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

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

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

Expert in WordPress and WooCommerce development with PHP best practices

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

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.