@mindrally

beautifulsoup-parsing covers html/xml extraction with practical dom navigation, css selectors, safe data patterns, and a complete scraper class example. handles encoding and malformed markup but lacks explicit failure recovery beyond parser selection.

mysql-best-practices covers schema design, indexing strategies, query optimization, and operational maintenance. includes concrete sql examples for storage engines, data types, index patterns, and transaction handling.

nextauth-authentication covers Auth.js v5 implementation patterns for Next.js, including session strategies (jwt vs database), oauth and credentials providers, role-based access control, and security hardening with code examples throughout.

cheerio-parsing covers dom traversal, css selector patterns, and data extraction techniques for node.js web scraping, with worked examples for tables, lists, and pagination. includes performance optimization and safe extraction helpers but limited guidance on failure recovery.

motion covers performant vanilla javascript animations using gpu-accelerated transforms, timelines, scroll binding, and viewport triggers, with accessibility patterns for reduced motion.

clerk-authentication covers next.js integration via middleware, server/client hooks, and api route protection. includes role-based access, organization support, and explicit anti-patterns, though lacks concrete failure recovery mechanics.

less-best-practices establishes file organization patterns, variable naming conventions, mixin architecture, and nesting rules for maintainable less stylesheets. covers bem, loops, guards, and property ordering with concrete code examples throughout.

trpc covers end-to-end typesafe api development in next.js using trpc v11, with patterns for router organization, middleware, validation, and client integration via react query.

sass-best-practices covers file organization, variables, mixins, functions, and naming conventions for maintainable sass stylesheets using the indented syntax. includes responsive design patterns, accessibility utilities, and performance guidance.

postcss-best-practices covers modular css transformation, plugin configuration patterns for webpack/vite/next.js, and modern css features like nesting, custom properties, and container queries. includes production optimization strategies and file organization.

scss-best-practices covers file organization, variable naming, mixins, bem conventions, and nesting limits for maintainable stylesheet architecture. provides concrete examples of the 7-1 pattern, responsive breakpoints, and utility generation via loops.

fastify-typescript provides structural patterns for building typed apis with fastify, covering route organization, prisma integration, schema validation via typebox, and jest testing. lacks concrete trigger scenarios and minimal edge case guidance.

vercel-development covers next.js app router patterns, server components, edge functions, ai sdk integration, and performance optimization via code examples. lacks explicit decision trees and failure recovery paths.

convex covers backend patterns for queries, mutations, actions, and real-time sync using typescript. includes schema design, file handling, webhooks, and scheduled jobs with validation best practices.

pnpm covers package manager fundamentals, workspace setup with glob patterns, monorepo filtering, peer dependency handling, and docker optimization. lacks explicit decision trees and failure recovery paths.

rollup-bundler covers es module optimization, configuration patterns for libraries, plugin selection, and output format decisions. practical examples show multi-format bundling and tree-shaking setup.

auth0-authentication covers implementation patterns for auth0 flows including spa and server-side apps, token management, actions, mfa, and security hardening, with code examples but limited trigger clarity for cross-vendor skill graph integration.

stripe covers payment intent creation, subscription lifecycle, webhook event handling, and customer management for next.js applications with code examples. lacks explicit failure recovery paths and rate limit guidance.

bash-scripting covers portable shell automation with emphasis on security, error handling, and devops patterns. provides guidelines for naming, input validation, modularity, and cleanup practices.

kafka-development covers architectural principles, topic design, producer/consumer best practices, schema management, and distributed patterns like event sourcing and saga coordination. practical but lacks executable procedures.

styled-components-best-practices documents css-in-js patterns for react, covering theming, responsive design, animations, and performance optimization through code examples and structural guidance.

sanity covers schema design, groq query patterns, typescript integration, and project layout for headless cms work. lacks trigger phrases, decision trees, and failure recovery guidance.

aws-development covers serverless patterns, infrastructure-as-code templates, and security practices across lambda, cdk, dynamodb, and iam. provides code examples but lacks procedural depth for implementation workflows.

github-workflow covers pull request discipline, code review practices, github actions configuration, issue templating, and repository security controls. guides workflow structure and automation patterns.

git-workflow documents conventional commits, branch naming, and collaboration practices but reads as reference material rather than actionable skill procedures with clear decision logic and outcome signals.

puppeteer-automation covers node.js browser automation patterns including page navigation, element interaction, screenshot/pdf generation, and network interception. lacks explicit intent statements and trigger phrases for agent integration.

redis-best-practices catalogs redis commands and patterns across data structures, caching, persistence, and clustering. lacks actionable decision trees and assumes reader can synthesize guidance into implementation strategy.

elasticsearch-best-practices covers index design, query optimization, bulk indexing, and cluster maintenance with configuration examples, but lacks executable procedures and decision frameworks for real-world troubleshooting scenarios.

koa-typescript covers middleware patterns, routing, error handling, validation, and authentication for building typed apis. strong on structure and examples, weak on actionable decision flows and failure recovery.

langchain-development provides structural guidance on organizing python llm applications using langchain and langgraph, with code examples for chains, agents, rag, and memory patterns.

go-backend-microservices covers clean architecture patterns, observability via opentelemetry, structured error handling, and concurrency safety for go microservices. lacks specific implementation procedures and concrete decision points.

chrome-extension-development provides manifest v3 guidelines covering service workers, content scripts, security patterns, and api integration. incomplete procedural content limits actionability.

hono-typescript covers framework setup, routing patterns, middleware composition, and request validation for edge-first apis across cloudflare workers, deno, bun, and node.js runtimes. lacks operational guidance on deployment, monitoring, and failure recovery.

internationalization-i18n covers translation setup, locale-aware formatting, and rtl support across react, vue, and react native using standard libraries like i18next and intl apis. provides code patterns and file organization guidance but lacks concrete decision workflows.

bitbucket-workflow covers pull request discipline, pipeline configuration templates, jira integration patterns, and gitflow branching. lacks actionable decision trees and failure recovery paths.

ci-cd-best-practices outlines pipeline architecture across build, test, security, and deployment stages with coverage of blue-green, canary, and rolling strategies. lacks concrete procedural steps and actionable trigger points.

matplotlib-best-practices collects matplotlib conventions, API patterns, and visual design guidance. covers plot types, accessibility, styling, and export workflows but lacks procedural depth for concrete visualization tasks.

gcp-development collects architectural patterns and code snippets across gcp services (cloud functions, cloud run, firestore, bigquery) but lacks actionable procedures for specific workflows. mostly reference material without decision trees or failure recovery.

sveltekit covers component development, routing, ssr/ssg, form actions, and state management with typescript examples. lacks explicit decision trees and failure recovery guidance.

nodejs-development covers payload cms setup, vue composition api patterns, pinia stores, and zod schema validation. practical examples but lacks operational context and failure handling depth.

java-quarkus-development outlines foundational patterns for quarkus cloud-native apps, covering configuration, di, rest apis, data access, testing, and native builds, but lacks concrete decision flows and failure recovery guidance.

css covers layout techniques, naming conventions, design tokens, and stylesheet architecture. emphasizes semantic html, flexbox and grid, bem methodology, responsive design, and modern features like custom properties and logical properties.

django-rest-api-development outlines architectural patterns and conventions for building django rest framework apis, covering project layout, serialization, authentication, and caching. lacks procedural depth and concrete failure handling.

turbopack-bundler covers configuration, project structure, code organization patterns, and performance practices for next.js incremental bundling. lacks actionable workflows and explicit failure recovery.

technical-writing provides style guidelines for developer-to-developer documentation that prioritizes direct explanation of implementation mechanics over marketing language, but lacks actionable procedural scaffolding.

turborepo covers monorepo structure, workspace configuration, task dependency management, and caching strategies. lacks operational depth on failure modes, remote cache setup specifics, and troubleshooting.

kotlin-development documents naming conventions, function design patterns, and data handling principles. covers code organization and testing patterns but lacks executable procedures and concrete recovery strategies.

postgresql-best-practices covers schema design with native types, indexing strategies, query optimization via explain analyze, connection pooling, and operational security. incomplete procedural depth and sparse failure-mode coverage limit utility.

storybook covers component library documentation patterns, file organization, story structure, and testing approaches. lacks concrete decision criteria and outcome signals for when practices are applied successfully.

expo-react-native-typescript documents coding standards and architectural preferences for mobile development with expo, react native, and typescript, covering component patterns, state management, and testing practices.

clean-architecture documents layering principles and project structure for flutter and go, covering domain separation, state management patterns, and testing strategy. lacks actionable procedures and concrete trigger scenarios.

electron-development provides security-focused guidance on structuring cross-platform desktop apps with proper process isolation and ipc patterns, but lacks actionable procedures and concrete failure recovery steps.

woocommerce documents php patterns, hooks, and security practices for wordpress plugin development, but reads as a style guide rather than actionable procedures with clear input-output contracts or failure recovery.

ghost covers handlebars templating patterns, tailwind integration, and alpine.js snippets for cms theme development, but lacks actionable workflows and failure handling.

serverless covers stateless service design, api gateway patterns, and event-driven architecture using fastapi and cloud platforms, but lacks concrete implementation workflows.

robocorp-cursor-rules documents python coding conventions and rpa patterns including functional style, pydantic validation, async operations, and error handling for robocorp automation. lacks concrete task examples and specific trigger scenarios.

nx covers monorepo structure, workspace configuration, code generation with Nx generators, module boundary enforcement, and caching strategies. lacks concrete recovery paths for common failure modes.

pandas-best-practices enumerates coding conventions and method choices for dataframe operations, covering i/o, selection, cleaning, and aggregation patterns. lacks executable workflows and concrete failure scenarios.

redux-toolkit covers state management patterns, slice architecture, and async data fetching for react and next.js. focuses on naming conventions, typescript integration, and performance optimization but lacks concrete decision trees or failure recovery.

nextjs-react-typescript covers typescript patterns, next.js app router architecture, server components, and ui library selection. guides on performance optimization and state management conventions but lacks executable procedures.

figma-integration provides guidelines for mapping design artifacts to code via mcp servers and manual extraction workflows, covering color, typography, layout, and asset handling without actionable decision logic or failure recovery.

drizzle-orm covers lightweight typescript orm development with type-safe schemas and sql-like syntax, but lacks operational guidance on migrations, testing, or production patterns.

grpc-development outlines protocol buffer and service design principles for building gRpc services, but lacks concrete procedures and deployment-ready guidance.

vite covers basic project setup and opinionated defaults for modern javascript tooling, but lacks procedural depth, specific trigger scenarios, and recovery patterns for common build failures.

terraform covers infrastructure-as-code patterns, state management, and cloud provider integration, but lacks concrete procedures and specific invocation triggers needed for skill execution.

performance-optimization covers web optimization principles including server-side rendering, javascript bundle reduction, and core web vitals measurement, but lacks actionable procedures and specific implementation guidance.

solana covers rust and anchor framework patterns for blockchain program development, emphasizing security controls and modular code structure without concrete procedures or deployment guidance.

business-central-development provides al language patterns and naming conventions for dynamics 365 extensibility, but lacks concrete workflows, decision logic, and failure recovery guidance needed for production scenarios.

testing covers unit testing patterns, mocking strategies, and test organization principles. lacks actionable procedures, concrete examples, and guidance on failure modes or recovery approaches.

nuxtjs-vue-typescript establishes conventions and patterns for vue 3 projects using typescript, composition api, and tailwind, but lacks executable procedures or decision logic.

web-scraping documents python tools and frameworks for extracting data from static and dynamic sites, but lacks concrete procedures, trigger phrases, and worked examples needed for execution.

lua covers idiomatic patterns, tables, metatables, error handling via pcall, and game development integration. lacks actionable procedures and concrete examples despite broad topical coverage.

guidelines for jupyter notebook workflows emphasizing pandas manipulation, matplotlib visualization, and numpy operations. covers style conventions and vectorization principles without prescriptive task sequences.

spring-boot provides guidance on java conventions, annotation usage, and basic architectural patterns. lacks concrete procedures, failure handling, and actionable workflows.

salesforce-development provides broad apex and lwc conventions covering soql optimization, trigger patterns, and naming standards, but lacks concrete scenarios and executable workflows.

react-native-r3f documents coding standards and component patterns for three.js scenes in react, but lacks concrete procedural workflows for actual development tasks.

shopify covers theme development fundamentals including liquid templating, online store 2.0 architecture, and performance optimization, but lacks actionable procedures and failure-mode guidance for real implementation scenarios.

nestjs-clean-typescript documents naming conventions and typescript typing rules for nestjs development, but lacks procedural depth, concrete examples, and actionable workflows for actual api implementation.

azure covers naming conventions, provisioning patterns, and operational guardrails for arm templates, bicep, pipelines, and aks. lacks procedural depth and specific trigger scenarios.

flask-python articulates coding conventions and stylistic preferences for flask applications, covering blueprint organization and functional patterns, but lacks procedural substance for building anything concrete.

android-development documents kotlin naming conventions, clean architecture layering, and mvi pattern for state management, but lacks executable procedures and concrete decision logic for real implementation scenarios.

htmx covers declarative html attributes for dynamic web interactions with minimal javascript, including request methods, dom targeting, error handling basics, and template organization patterns.

prisma covers orm fundamentals and schema conventions but lacks concrete procedural guidance, trigger examples, and failure mode handling needed for executable skill deployment.

pixi-js covers typescript game development patterns and project organization for web and mobile, but lacks concrete procedural guidance and specific use-case triggers.

ruby-rails documents rails conventions, architecture patterns, and best practices across testing, security, and performance but lacks procedural depth and actionable decision workflows.

deep-learning outlines neural network design principles, training strategies, and optimization techniques across architectures, multi-gpu setups, and memory management, but lacks executable procedures and concrete examples.

odoo-development documents python and xml patterns for building odoo modules, covering models, views, and security conventions. lacks procedural guidance for specific development tasks or agent workflows.

nlp-natural-language-processing provides guidelines for transformer-based text processing, tokenization, and model fine-tuning. lacks executable procedures and concrete workflows for specific nlp tasks.

deep-learning-pytorch provides guidance on transformer architectures, diffusion models, and llm fine-tuning with pytorch and related libraries, emphasizing gpu optimization and distributed training patterns.

systemverilog covers modular design, clock domain handling, and timing principles for fpga and asic work, but lacks concrete procedures and verification workflows.

deep-learning-python provides general guidance on pytorch, transformers, and diffusers development, covering architecture patterns and training principles without concrete procedures or execution workflows.

general-best-practices aggregates software development guidance across code quality, testing, security, and observability. it reads as a principles checklist rather than a skill with actionable procedures or clear decision logic.

expo-react-native-javascript-best-practices covers naming conventions, functional components, and code organization guidelines for clean expo projects, but lacks decision logic, concrete examples, and failure handling.

gsap covers setup and import patterns for animation library usage, but lacks complete procedural guidance, trigger specificity, and failure mode documentation needed for production skill implementation.

game-development provides broad guidance on c# unity patterns and architecture principles but lacks concrete procedures, specific trigger phrases, and actionable workflows for actual game development tasks.

c-sharp documents naming conventions, language features, and architectural patterns across .net, blazor, and unity contexts, but lacks procedural guidance for executing actual development tasks.

phoenix covers elixir web framework conventions and code style guidelines, but lacks actionable procedures for implementing specific features like liveview or ecto patterns.

salesforce-dx covers apex code standards and trigger patterns with emphasis on separation of concerns, soql optimization, and naming conventions, but lacks concrete procedures and ci-cd specifics despite headline claims.

kysely covers typescript sql query building with type safety and autocompletion, but the skill document lacks actionable workflows, triggering context, and failure-mode guidance needed for practical implementation.

react-native-cursor-rules documents typescript and component conventions for react native development, covering naming, structure, and styling principles without procedural instruction or integration guidance.

meta-prompt collects evaluation frameworks and prompt engineering patterns for analyzing ai responses, trajectories, and solution quality. lacks integration into actionable workflows.

design-systems documents foundational guidelines for color, typography, spacing, components, and tokens. lacks procedural depth on actual implementation workflows and concrete decision trees for applying these principles.

java-spring-development covers foundational spring boot patterns and architectural preferences, but lacks executable procedures and specific failure-mode handling required for skill-based guidance.

nextjs-typescript-tailwindcss-supabase documents architectural preferences and coding conventions for next.js 14 full-stack development, but lacks actionable procedures or concrete decision triggers.

ethereum covers solidity best practices, openZeppelin patterns, and hardhat tooling for smart contract development. prescriptive on code standards and security patterns but lacks procedural depth for executing specific tasks.

anime-js provides installation steps and modular import patterns but lacks actionable animation procedures, decision logic, failure handling, and concrete performance guidelines beyond installation.

shopify-theme-development-guidelines outlines liquid syntax rules and theme architecture patterns, but lacks actionable procedures and concrete examples for implementing production shopify themes.

quarkus skill describes framework expertise and coding conventions but lacks executable procedures, decision logic, or concrete guidance on specific tasks like building native images or setting up reactive endpoints.

ui-design outlines visual and interaction principles for accessible interfaces, but lacks actionable procedures, decision logic, or success metrics tied to measurable outcomes.

alpine-js provides high-level principles for lightweight reactive ui development but lacks concrete procedural guidance, specific triggers, and actionable workflows for practical implementation.

python covers style conventions and general development principles across web, data science, and automation domains, but lacks actionable procedures or concrete skill triggers.

spring-framework provides code style guidance and annotation patterns for spring boot projects, but lacks procedural depth, concrete trigger scenarios, and failure mode discussion.

monorepo documents coding conventions and style preferences for typescript, react, and related tooling but lacks actionable procedures for common development workflows.

llm covers transformer architecture, tokenization, fine-tuning techniques, distributed training, and inference optimization. lacks actionable procedures and concrete trigger conditions for skill invocation.

data-analysis-jupyter provides coding principles and tool focus (pandas, matplotlib, seaborn, numpy) but lacks concrete procedures, actionable workflows, or recovery guidance for data analysis tasks in jupyter environments.

three-js establishes coding conventions for react three fiber projects but lacks actionable procedures, decision frameworks, or outcome signals needed to guide skill execution.

vue-typescript covers typescript and vue.js tooling preferences without defining actionable procedures, decision flows, or concrete skill outcomes. lacks triggering conditions and procedural depth.

accessibility-a11y outlines wcag principles and semantic html practices but lacks procedural depth, numbered steps, concrete implementation details, and recovery patterns for real-world accessibility work.

react documents code style conventions and component patterns for typescript-based ui development, but lacks actionable procedures, failure handling, and specific trigger contexts for skill invocation.

front-end-developer describes a senior react/nextjs developer persona with process guidelines (think before code, follow dry principle) but lacks concrete skill boundaries, decision logic, or failure handling. suitable as a chat prompt, not a structured skill.

ux-design covers foundational uiux principles across research, accessibility, and interaction patterns. lacks procedural specificity and actionable workflows for implementation in actual projects.

typescript documents naming conventions and code style preferences but lacks actionable procedures, decision logic, or output contracts. reads as style guide rather than executable skill.

web-development provides high-level bootstrap and django guidance but lacks procedural depth, specific triggers, and decision logic. the content reads as principle lists rather than actionable skill instructions.

machine-learning covers functional programming patterns and JAX fundamentals including array operations and automatic differentiation, but lacks concrete workflows or decision logic for real tasks.

devops collects style guides and principles across kubernetes, ci/cd, bash, ansible, and python but lacks executable procedures, decision trees, or failure recovery patterns.

django-python documents general web development guidelines and best practices, but lacks procedural specificity, trigger phrases, and actionable task workflows needed for skill execution.

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

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

typeorm — an installable skill for AI agents, published by mindrally/skills.

scrapy-web-scraping — an installable skill for AI agents, published by mindrally/skills.

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

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

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

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

Implement analytics, data analysis, and visualization best practices using Python, Jupyter, and modern data tools.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Best practices for Zustand state management in React and Next.js applications with TypeScript.

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

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

Best practices for Lerna monorepo management, versioning, and publishing

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

Expert guidelines for implementing performant Lottie animations on the web

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

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

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

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

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

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

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

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 using TanStack Query (React Query) for server state management, data fetching, caching, and synchronization

Netlify development best practices for serverless functions, edge functions, Blobs storage, build configuration, and deployment workflows.

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

Expert SwiftUI development guidelines with MVVM architecture and modern Swift best practices

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

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

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

graphql — an installable skill for AI agents, published by mindrally/skills.

backend-development — an installable skill for AI agents, published by mindrally/skills.

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

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

solidity — an installable skill for AI agents, published by mindrally/skills.

remix — an installable skill for AI agents, published by mindrally/skills.

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

cpp — an installable skill for AI agents, published by mindrally/skills.

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

pwa-development — an installable skill for AI agents, published by mindrally/skills.

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

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

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

Expert in WordPress and WooCommerce development with PHP best practices

laravel-development — an installable skill for AI agents, published by mindrally/skills.

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

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

Expert in Supabase backend development with authentication and database patterns

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

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

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

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

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

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

tailwindcss — an installable skill for AI agents, published by mindrally/skills.

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