bobmatnyc/claude-mpm-skills▌

Hono was originally built for Cloudflare Workers and provides first-class support for the entire Cloudflare ecosystem including KV, D1, R2, Durable Objects, Queues, and more.

Phoenix builds on Elixir and the BEAM VM to deliver fault-tolerant, real-time web applications with minimal JavaScript. LiveView keeps UI state on the server while streaming HTML diffs over WebSockets. The BEAM provides lightweight processes, supervision trees, hot code upgrades, and soft-realtime scheduling.

Python SQL toolkit and ORM with modern query builder, relationship mapping, and async support. \n \n Supports SQLAlchemy 2.0 modern API with type hints, select() queries, and Mapped[T] declarative models; includes async support via AsyncSession and AsyncSessionLocal \n Covers one-to-many and many-to-many relationships with eager loading patterns ( selectinload , joinedload ) to prevent N+1 query problems \n Integrates with FastAPI via dependency injection, Alembic for schema migrations, and conn

TypeScript backend development with Express/Fastify, routing, middleware, and database integration. \n \n Covers both Express and Fastify frameworks with complete server setup, routing patterns, middleware implementation, and error handling examples \n Includes request validation using Zod and TypeBox, JWT and session-based authentication, and integration with Drizzle ORM and Prisma \n Provides REST API design patterns for pagination, filtering, sorting, and standardized error responses with typ

Systematic workflow for auditing, updating, and cleaning up project dependencies. Covers security vulnerability scanning, outdated package detection, unused dependency removal, and migration from deprecated libraries.

Type-safe SQL ORM for TypeScript with zero runtime overhead and edge-runtime optimization. \n \n Supports PostgreSQL, MySQL, and SQLite with compile-time type inference from schema definitions; no code generation required \n Includes relational queries, transactions, filtering, joins, pagination, and aggregation with SQL-like syntax \n Drizzle Kit provides schema migrations, introspection, and a built-in database GUI (Drizzle Studio) \n Significantly smaller bundle size (~35KB vs ~230KB) and fas

Modern Go applications require comprehensive observability through the three pillars: traces, metrics, and logs. OpenTelemetry provides vendor-neutral instrumentation for distributed tracing, Prometheus offers powerful metrics collection, and Go's slog package (1.21+) delivers structured logging with minimal overhead.

Modern TypeScript testing with Vite-native speed, ESM-first design, and instant HMR feedback. \n \n Vite-powered test execution delivers 10-100x faster performance than Jest through HMR-based test running and native ES module support \n Built-in TypeScript support requires zero configuration; includes Jest-compatible API for straightforward migration from existing test suites \n Supports React and Vue component testing via Testing Library and Vue Test Utils, with jsdom/happy-dom environment opti

Tailwind CSS component library with 50+ semantic components, 30+ themes, and built-in dark mode. \n \n Provides semantic class names ( btn , card , modal ) instead of utility-only Tailwind, reducing markup verbosity and improving maintainability \n Includes 30+ pre-built themes plus custom theme support, with automatic dark mode detection and localStorage persistence \n Framework-agnostic: works with React, Vue, Svelte, or vanilla HTML without additional dependencies \n Covers navigation, forms,

Basic event emission:

Version: 1.0.0 Target: WordPress 6.7+ | PHP 8.3+ Skill Level: Intermediate to Advanced

Modern TypeScript development patterns for type safety, runtime validation, and optimal configuration.

Optimize web performance through Core Web Vitals, modern browser APIs (View Transitions, Speculation Rules), and framework-specific techniques.

Cross-browser end-to-end testing with auto-wait, parallel execution, and built-in debugging tools. \n \n Supports Chromium, Firefox, and WebKit across desktop and mobile devices with automatic element waiting and network control \n Includes role-based locators, page object model patterns, and storage-state authentication for maintainable test suites \n Offers visual regression testing via screenshot comparison, video recording, and trace viewer for debugging failed tests \n Built-in test runner

mypy is the standard static type checker for Python, enabling gradual typing with type hints (PEP 484) and comprehensive type safety. It catches type errors before runtime, improves code documentation, and enhances IDE support while maintaining Python's dynamic nature through incremental adoption.

Transform rough ideas into fully-formed designs through structured questioning and alternative exploration.

Master advanced WordPress development patterns including REST API endpoints, WP-CLI commands, performance optimization, and caching strategies for scalable WordPress applications.

Go provides a robust built-in testing framework (testing package) that emphasizes simplicity and developer productivity. Combined with community tools like testify and gomock, Go testing enables comprehensive test coverage with minimal boilerplate.

Hono is a small, simple, and ultrafast web framework built on Web Standards. It runs on Cloudflare Workers, Deno, Bun, Node.js, and more with the same codebase. The name means "flame" in Japanese.

Create effective skills that extend Claude's capabilities through specialized knowledge, workflows, and tools. Skills are modular packages that transform Claude from a general-purpose agent into a specialized agent with procedural knowledge for specific domains.

Migration-first database development workflow using Drizzle ORM for TypeScript/JavaScript projects. \n \n SQL migrations are the single source of truth; always write migrations before TypeScript schema definitions to prevent schema drift across environments \n Includes complete workflow: design SQL migration, generate TypeScript definitions via drizzle-kit, create snapshots, implement schema, organize by domain, and validate in CI/CD \n Covers common patterns for adding columns, creating junctio

Vercel deployments and builds cover the full lifecycle from source changes to production releases with automated previews and rollback controls.

kubernetes

Visual verification workflow for UI changes to accelerate code review and catch responsive design issues early.

DigitalOcean management services provide monitoring, uptime checks, and resource organization to keep workloads healthy and visible.

Architectural patterns solve specific structural problems. This skill provides a decision framework for when to apply each pattern, not a catalog to memorize.

Comprehensive TDD patterns and practices for all programming languages. This skill eliminates ~500-800 lines of redundant testing guidance per agent.

Working effectively with JSON data structures.

Celery is a distributed task queue system for Python that enables asynchronous execution of background jobs across multiple workers. It supports scheduling, retries, task workflows, and integrates seamlessly with Django, Flask, and FastAPI.

Kysely is a type-safe TypeScript SQL query builder that provides end-to-end type safety from database schema to query results. Unlike ORMs, it generates plain SQL and gives you full control while maintaining perfect TypeScript inference.

Hono provides a lightweight built-in validator and integrates seamlessly with popular validation libraries like Zod, TypeBox, and Valibot. Validation happens as middleware, providing type-safe access to validated data in handlers.

Hono provides a simple testing approach: create a Request, pass it to your app, and validate the Response. The framework includes a typed test client for even better DX.

Vue 3 is a progressive framework for building user interfaces with emphasis on approachability, performance, and flexibility. It features the Composition API for better logic reuse, a powerful reactivity system, and single-file components (.vue files).

Go's database ecosystem provides multiple layers of abstraction for SQL database integration. From the standard library's database/sql to enhanced libraries like sqlx and PostgreSQL-optimized pgx, developers can choose the right tool for their performance and ergonomics needs.

Flask is a micro-framework for Python web development, designed for building microservices, REST APIs, and flexible web applications. Its minimalist core and extensive extension ecosystem make it ideal for projects requiring lightweight architecture, rapid development, and full control over components.

Go concurrency scales when goroutine lifetimes are explicit, cancellation is propagated with context.Context, and shared state is protected (channels or locks). Apply these patterns to build reliable services and avoid common failure modes: goroutine leaks, deadlocks, and data races.

SvelteKit is the official full-stack framework for Svelte, providing file-based routing, server-side rendering (SSR), static site generation (SSG), form handling with progressive enhancement, and deployment adapters for any platform.

Hono RPC enables sharing API specifications between server and client through TypeScript's type system. Export your server's type, and the client automatically knows all routes, request shapes, and response types - no code generation required.

Hono provides a powerful middleware system with an "onion" execution model. Middleware processes requests before handlers and responses after handlers, enabling cross-cutting concerns like authentication, logging, and CORS.

Axum is a Rust web framework built on Hyper and Tower. Use it for type-safe request handling with composable middleware, structured errors, and excellent testability.

Systematic workflow for verifying bug fixes to ensure quality and prevent regressions.

Rust has emerged as a premier language for building desktop applications that combine native performance with memory safety. The ecosystem offers two main approaches: Tauri for hybrid web UI + Rust backend apps (think Electron but 10x smaller and faster), and native GUI frameworks like egui, iced, and slint for pure Rust interfaces.

Get your API key from: https://console.anthropic.com/settings/keys

Express is a minimal and flexible Node.js web application framework providing a robust set of features for web and mobile applications. This skill covers production-ready Express development including middleware architecture, structured error handling, security hardening, comprehensive testing, and deployment strategies.

TanStack Query (formerly React Query) is a powerful asynchronous state management library for React that handles server-state fetching, caching, synchronization, and updates. It eliminates the need for manual data fetching boilerplate and provides built-in features like background refetching, optimistic updates, pagination, and intelligent cache management.

Design robust, scalable APIs using proven patterns for REST, GraphQL, and gRPC with proper versioning, authentication, and error handling.

Modern database toolkit for TypeScript with schema-first development, auto-generated type-safe client, and powerful migration system.

gRPC provides strongly-typed RPC APIs backed by Protocol Buffers, with first-class streaming support and excellent performance for service-to-service communication. This skill focuses on production defaults: versioned protos, deadlines, error codes, interceptors, health checks, TLS, and testability.

Essential Git patterns for effective version control. Eliminates ~120-150 lines of redundant Git guidance per agent.

Working with Excel files programmatically.

GitHub Actions is GitHub's native CI/CD platform for automating software workflows. Define workflows in YAML files to build, test, and deploy code directly from your repository with event-driven automation.

Fastify is a high-performance Node.js web framework built around JSON schema validation, encapsulated plugins, and great developer ergonomics. In TypeScript, pair Fastify with a type provider (Zod or TypeBox) to keep runtime validation and static types aligned.

shadcn/ui is a collection of re-usable React components built with Radix UI primitives and styled with Tailwind CSS. Unlike traditional component libraries, shadcn/ui components are copied directly into your project, giving you full ownership and customization control. Components are accessible, customizable, and open source.

opentelemetry

Cypress runs browser automation with first-class network control, time-travel debugging, and a strong local dev workflow. Use it for critical path E2E tests and for component tests when browser-level rendering matters.

Compress long AI conversations to fit context windows while preserving critical information.

Fast, Rust-based linter and formatter replacing ESLint and Prettier with 100x speed improvement. \n \n Single tool combining linting, formatting, and import sorting with zero-config defaults and TypeScript-first design \n Supports three core commands: check (lint + format together), format (formatting only), and lint (linting only), all with --write for automatic fixes \n Includes VS Code extension with format-on-save, organized rule categories (correctness, style, suspicious, performance, secur

Open-source Firebase alternative built on:

Your localLLM repo provides a full local LLM toolchain on Apple Silicon: setup scripts, a rich CLI chat launcher, benchmarks, and diagnostics. The operational path is: install Ollama, ensure the service is running, initialize the venv, pull models, then launch chat or benchmarks.

Containerize applications with isolated, portable units ensuring consistency across development, testing, and production. \n \n Supports three core workflows: local development with hot-reload volumes, CI/CD image building and testing, and production deployment with health checks and resource limits \n Includes multi-stage builds to optimize image size, layer caching strategies, and .dockerignore patterns for faster builds \n Docker Compose enables multi-container applications with service depen

TypeScript-first schema validation with automatic static type inference from runtime schemas. \n \n Define schemas once and automatically infer TypeScript types for compile-time safety; supports primitives, objects, arrays, unions, and recursive types \n Validate data with parse() (throws) or safeParse() (returns result object); includes async validation for database lookups and external checks \n Transform and refine data during validation using transform() , refine() , and superRefine() for cu

Fast, scalable Python testing with fixtures, parametrization, and framework integration. \n \n Fixture system provides dependency injection and setup/teardown with function, class, module, and session scopes \n Parametrization enables data-driven tests; markers organize tests by category (unit, integration, slow, custom) \n Built-in support for FastAPI, Django, and Flask with async/await testing via pytest-asyncio \n Rich assertion introspection, mocking via pytest-mock, coverage reporting, and

End-to-end type-safe APIs for TypeScript with zero code generation. \n \n Shares TypeScript types between client and server automatically—no codegen required, with full type inference across queries, mutations, and subscriptions \n Integrates seamlessly with React Query for caching, optimistic updates, and infinite queries; supports Next.js App Router, Server Components, and WebSocket subscriptions \n Validates all inputs with Zod schemas; includes middleware for authentication, logging, and rat

Utility-first CSS framework for rapid UI development with responsive design and dark mode support. \n \n Provides single-purpose utility classes for layout, spacing, typography, colors, and effects without writing custom CSS \n Includes mobile-first responsive breakpoints (sm, md, lg, xl, 2xl) and built-in dark mode with class or media strategy \n Supports framework integration with React, Next.js, Vue, Svelte, and others; includes official plugins for forms, typography, and aspect ratios \n Off

Jest is the industry-standard testing framework with 70% market share, providing a mature, battle-tested ecosystem for TypeScript projects. It offers comprehensive testing capabilities with built-in snapshot testing, mocking, and coverage reporting.

High-performance Python data validation with type hints, Rust-powered core, and seamless FastAPI/Django integration. \n \n Validates data at runtime using Python type hints with automatic type coercion; strict mode available per-field or model-wide \n Supports nested models, recursive types, generics, and custom validators (field-level and model-level) for complex validation logic \n Includes built-in types for emails, URLs, file paths, secrets, and constrained integers/strings; extensible via c

OpenRouter provides a single API to access 200+ language models from OpenAI, Anthropic, Google, Meta, Mistral, and more. It offers intelligent routing, streaming, cost optimization, and standardized OpenAI-compatible interface.

Full Site Editing (FSE) is production-ready (since WP 6.2) and treats everything as blocks—headers, footers, templates, not just content. Block themes use HTML templates + theme.json instead of PHP files + style.css.

Zustand is a minimal, unopinionated state management library for React. No providers, no boilerplate—just a simple hook-based API that feels natural in React applications.

Go provides exceptional HTTP capabilities starting with the standard library's net/http package. Go 1.22+ introduced enhanced pattern routing in ServeMux, making stdlib viable for many applications. For more complex needs, frameworks like Chi, Gin, Echo, and Fiber offer additional features while maintaining Go's simplicity and performance.

Comprehensive security checklist for API endpoint development. Ensures proper authentication, authorization, input validation, output safety, and security logging are implemented before deployment.

Python's asyncio library enables writing concurrent code using async/await syntax. It's ideal for I/O-bound operations like HTTP requests, database queries, file operations, and WebSocket connections. asyncio provides non-blocking execution without the complexity of threading or multiprocessing.

Cobra and Viper are the industry-standard libraries for building production-quality CLIs in Go. Cobra provides command structure and argument parsing, while Viper manages configuration from multiple sources with clear precedence rules.