@mindrally

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.

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.

cypress covers test structure, element selection strategies, command chaining, custom command creation, async handling via intercept, and test isolation patterns. identifies anti-patterns to avoid.

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.

selenium-automation covers webdriver setup, page object model patterns, element location strategies, explicit waits, and test organization with practical code examples for cross-browser automation.

jest covers test structure, mocking strategies, assertion patterns, and async testing for javascript and typescript. includes concrete examples but lacks specific trigger phrases for invoking guidance.

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.

scikit-learn-best-practices covers workflow fundamentals like data splitting, feature scaling, pipelines, cross-validation, and model evaluation with working code examples. lacks operational guidance on failure modes, deployment specifics, and when to deviate from defaults.

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.

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.

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.

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.

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.

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.

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.

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.

prisma-development collects typescript and prisma orm conventions covering schema design, migrations, client usage, and error handling, but lacks executable procedures and concrete decision trees needed for cross-vendor skill orchestration.

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.

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

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.

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.

playwright covers test design fundamentals, fixture setup, and basic structuring patterns for typescript-based end-to-end testing. incomplete coverage of locators, assertions, and failure scenarios.

rest-api-django outlines django rest framework conventions, project layout, and best practices for building apis, but lacks concrete procedural steps and specific trigger scenarios needed for actionable skill execution.

ruby covers idioms, syntax conventions, testing patterns with rspec, and design principles for 3.x development. lacks procedural guidance for actual implementation tasks.

monitoring-guidelines catalogs observability best practices across metrics collection, alerting strategies, and slo-based monitoring, but lacks actionable procedures and vendor-specific implementation details.

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.

go covers backend development fundamentals (apis, microservices, clean architecture) but lacks concrete procedures. reads as principles-heavy ideology without actionable workflows or decision trees for common scenarios.

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.

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.

api-development covers go standard library patterns and nestjs typescript conventions, emphasizing modular architecture, validation, and security. lacks actionable procedures and concrete examples.

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.

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.

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

viewcomfy-api-rules documents integration patterns for the viewcomfy serverless fastapi service, covering workflow deployment, parameter extraction, credential configuration, and output handling with httpx. lacks concrete code examples and decision trees for implementation choices.

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

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

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.

laravel documents php development principles and architectural patterns without actionable procedures. it reads as a style guide rather than a skill that executes discrete tasks.

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.

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

tauri-development covers typescript and rust patterns for cross-platform desktop apps, including project structure, ipc integration, file operations, and security basics, but lacks concrete workflows and actionable decision trees.

ionic covers cross-platform mobile app development with angular, offering project structure patterns, component usage examples, and native plugin integration guidance without executable procedures or decision flows.

angular covers typescript development patterns, file organization conventions, and performance guidelines for building scalable web applications, but lacks actionable workflows and decision-making logic.

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.

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.

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.

rust covers foundational principles for systems programming, memory safety, and async patterns using tokio, but lacks concrete procedures and executable 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.

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.

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

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.

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.

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.

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.

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.

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

jwt-security — an installable skill for AI agents, published by mindrally/skills.

scss-best-practices — an installable skill for AI agents, published by mindrally/skills.

puppeteer-automation — an installable skill for AI agents, published by mindrally/skills.

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.

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

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

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

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.

Expert in Java development with Spring Boot and enterprise patterns

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

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

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

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

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

Expert in Python testing with pytest and test-driven development

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

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

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

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

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

Expert in Svelte and SvelteKit development with modern patterns and SSR

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

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

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

Expert in Astro framework with static generation and partial hydration patterns

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

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

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

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.

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

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

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

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

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

Expert in Elixir and Phoenix development with functional programming patterns

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

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

Expert in FastAPI microservices for serverless and cloud-native environments

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

Best practices and guidelines for Apache Kafka event streaming and distributed messaging

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

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

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

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

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

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

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

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

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

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

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

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

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

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

remix — 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

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

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

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

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

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

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

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

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.

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

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

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