jeffallan/claude-skills
66 skills322k installs710k starsGitHub
Install
npx skills add https://github.com/jeffallan/claude-skillsSkills in this repo
1Laravel SpecialistSenior Laravel specialist providing deep expertise in Laravel 10+ and modern PHP 8.2+ development. Covers Eloquent ORM, RESTful API design with API resources, queue systems with Horizon, Livewire components, and comprehensive testing with >85% coverage targets. Use when creating Laravel models, setting up queue workers, implementing Sanctum authentication, or building Livewire components.19kinstalls2Golang ProGolang Pro provides production-grade expertise in Go 1.21+ for building concurrent systems and cloud-native microservices. It covers goroutine and channel patterns for safe concurrency, idiomatic interface design, generics, performance profiling with pprof, comprehensive testing with table-driven tests and race detection, and robust error handling with context propagation. Use this skill when implementing high-performance backend services, microservices with gRPC, or CLI tools. Each implementation includes proper module structure, linting with golangci-lint, and 80%+ test coverage requirements.16.3kinstalls3Php ProA skill for building PHP applications with PHP 8.3+, Laravel, and Symfony. Covers typed entities, value objects, services, repositories, REST APIs, and strict quality enforcement. Developers use it for enterprise PHP architecture, test-driven development, and secure API development.12.7kinstalls4Flutter ExpertFlutter Expert is a senior mobile engineering skill for building high-performance cross-platform applications with Flutter 3 and Dart. Developers use this skill when implementing state management, navigation, custom widgets, and performance optimization. The skill covers widget patterns, GoRouter navigation, Riverpod/Bloc providers, and Flutter DevTools profiling.12.6kinstalls5Kubernetes SpecialistKubernetes Specialist guides deployment and management of containerized workloads on Kubernetes clusters. Developers use it to author declarative YAML manifests for Deployments, StatefulSets, Services, and Ingress; configure RBAC, NetworkPolicies, and Pod Security Standards; set up persistent storage via PV/PVC; package applications with Helm; troubleshoot pod crashes and resource contention; and implement GitOps pipelines with ArgoCD or Flux. The skill enforces best practices: resource limits on all containers, liveness/readiness probes, least-privilege service accounts, secrets management, and network isolation policies. Validation uses kubectl rollout status, pod event streaming, and log inspection.11.7kinstalls6Devops EngineerThe devops-engineer skill implements CI/CD, containerization, infrastructure as code, and deployment automation from a senior DevOps perspective spanning build, deploy, and ops hats. Agents assess application and environment requirements, design pipeline and deployment strategy, implement IaC plus Docker and workflow configs, validate with terraform plan and config linting, deploy with smoke tests, and set observability with rollback readiness. Reference guides load for GitHub Actions, Docker patterns, Kubernetes, Terraform, deployment strategies, platform engineering, release automation, and incident response. Hard constraints require IaC over manual changes, health checks, secret managers, container scanning, documented rollbacks, and GitOps with ArgoCD or Flux while forbidding production deploys without approval, secrets in code, skipped staging, missing resource limits, latest tags, or Friday deploys without monitoring. Output templates include pipeline YAML, Dockerfiles, K8s manifests, verification steps, and kubectl rollback examples. Use for pipelines, Docker, Kubernetes, Terraform, GitHub Actions, platform engineering, or incident response tasks.7.7kinstalls7Wordpress ProDevelops custom WordPress themes and plugins creates and registers Gutenberg blocks and block patterns configures WooCommerce stores implements WordPress REST API endpoints applies security hardening nonces sanitization escaping capability checks and optimizes performance through caching and query tuning Use when building WordPress themes writing plugins customizing Gutenberg blocks name wordpress-pro description Develops custom WordPress themes and plugins creates and registers Gutenberg blocks and block patterns configures WooCommerce stores implements WordPress REST API endpoints applies security hardening nonces sanitization escaping capability checks and optimizes performance through caching and query tuning Use when building WordPress themes writing plugins customizing Gutenberg blocks extending WooCommerce working with ACF using the WordPress REST API applying hooks and filters or improving WordPress performance and security license MIT metadata author https github com Jeffallan version 1 1 0 domain platform triggers WordPress WooCommerce Gutenberg WordPress theme WordPress plugin custom blocks ACF WordPress REST API hooks filters WordPress performance WordPress security ro.7.2kinstalls8Spring Boot EngineerThis skill generates production-grade Spring Boot 3.x code following modern patterns: constructor injection, layered architecture (entity/repository/service/controller), and type-safe configuration. Developers invoke it when building REST APIs, securing endpoints with Spring Security 6 and OAuth2, designing Spring Data JPA repositories with projections and transactions, or creating reactive WebFlux services. The workflow starts with requirement analysis, proceeds through architecture design and layered implementation, adds security and validation, runs full test suites (unit, integration, slice tests with Testcontainers), and finishes with health-check deployment via Actuator. It enforces strict rules: constructor injection over field injection, validation on all mutating endpoints, externalizing secrets, and avoiding deprecated Spring Boot 2.x patterns. Quick-start templates provide copy-paste entities, repositories, services, controllers, DTOs, exception handlers, and test slices.7.1kinstalls9Typescript ProTypeScript Pro implements advanced type systems including generics, conditional types, mapped types, discriminated unions, and branded types for domain modeling. Developers use it when building applications requiring strict type safety across full-stack boundaries, monorepo setups, or tRPC-based APIs. Core workflows cover type architecture analysis, type-first API design, type guard implementation, build optimization via project references and incremental compilation, and validation with type-coverage tools. Enforces strict compiler flags, declaration file generation, and exhaustive type checking while forbidding unsafe casts and enum use. --- name: typescript-pro description: Implements advanced TypeScript type systems, creates custom type guards, utility types, and branded types, and configures tRPC for end-to-end type safety. Use when building TypeScript applications requiring advanced generics, conditional or mapped types, discriminated unions, monorepo setup, or full-stack type safety with tRPC. license: MIT metadata: author: https://github.com/Jeffallan version: "1.1.0" domain: language triggers: TypeScript, generics, type safety, conditional types, mapped types, tRPC, tscon.6.7kinstalls10Python ProPython Pro is a Jeff Allan language specialist skill for Python 3.11+ applications that need type safety, async I/O, and production-grade error handling. Invoke when writing fully annotated modules, configuring mypy strict mode, building pytest suites with fixtures and mocking, or validating with black and ruff before merge. The documented workflow analyzes structure and type coverage, designs protocols and dataclasses, implements Pythonic code with Google docstrings, tests toward ninety percent coverage, then validates until mypy, black, and ruff pass clean. Reference guides cover typing, asyncio task groups, standard library patterns, Poetry packaging, and testing tactics. Hard constraints forbid bare except clauses, mutable defaults, skipped public annotations, and deprecated os.path usage while requiring async for I/O, dataclasses over manual init, and pathlib for file work. Pairs with fastapi-expert for API layers and devops-engineer for deployment. Delivers typed modules, matching test files, and strict-check confirmation for each feature.5.9kinstalls11Postgres ProPostgreSQL Pro is a specialist skill for senior database administration and performance optimization It guides developers through EXPLAIN ANALYZE workflows to identify bottlenecks design targeted indexes B-tree GIN GiST BRIN optimize slow queries and set up streaming or logical replication The skill covers JSONB storage strategies autovacuum tuning bloat monitoring via pg_stat views and replication lag tracking Key workflows include analyzing slow queries with pg_stat_statements creating concurrent indexes without locks verifying index usage before production deployment refreshing statistics after bulk changes and monitoring database health continuously Includes reference guides for performance JSONB extensions PostGIS pgvector pg_trgm replication and maintenance name postgres-pro description Use when optimizing PostgreSQL queries configuring replication or implementing advanced database features Invoke for EXPLAIN analysis JSONB operations extension usage VACUUM tuning performance monitoring license MIT metadata author https github com Jeffallan version 1 1 0 domain infrastructure triggers PostgreSQL Postgres EXPLAIN ANALYZE pg_stat JSONB streaming replication logical replication.5.8kinstalls12Architecture DesignerThe architecture-designer skill guides principal-level system design for new platforms, architecture reviews, and technology selection with documented trade-offs. Its five-step workflow gathers functional and non-functional requirements, maps constraints to patterns such as monolith, microservices, or event-driven designs, produces architecture diagrams, writes Architecture Decision Records for every significant choice, and validates outcomes with stakeholders before implementation. Outputs include requirements summaries, Mermaid diagrams, ADR-formatted decisions with alternatives and consequences, technology recommendations with rationale, and risk mitigation strategies. Constraints require explicit NFR consideration, failure-mode planning, operational complexity review, and refusal to over-engineer for hypothetical scale without evidence. Reference guides cover architecture patterns, ADR templates, system design templates, database selection, and NFR checklists loaded on demand. Use when designing new systems, choosing between monolith and microservices, reviewing architecture, or documenting decisions before build work starts.5.6kinstalls13Websocket EngineerThis skill implements real-time communication with WebSockets or Socket.IO, covering bidirectional messaging, presence tracking, room management, and horizontal scaling. The workflow analyzes connection scale and latency, designs clustering with Redis pub/sub and failover, builds servers with JWT handshake authentication and room events, validates locally with wscat for auth rejection and message delivery, then scales using Redis adapters, sticky sessions, and load balancing. Reference guides load for protocol handshake, scaling, rooms and acknowledgments, security with rate limiting and CORS, and SSE alternatives. Code examples show Socket.IO with Redis adapter, presence via hSet, join-room handlers, and client reconnection with exponential backoff plus offline message queuing. Must-do rules require sticky sessions, heartbeat ping-pong, room scoping, disconnect cleanup, and load testing. Must-not rules forbid unclustered in-memory state, mixed HTTP and WebSocket ports without upgrade handling, and skipping connection cleanup before production.5.3kinstalls14Embedded SystemsThe embedded-systems skill guides senior firmware work for resource-constrained microcontrollers, RTOS applications, and hardware-software integration on STM32, ESP32, FreeRTOS, and bare-metal platforms. The documented workflow analyzes MCU specs, memory limits, timing requirements, and power budgets, then designs task structures, interrupts, peripherals, and memory layout before implementing HAL drivers and RTOS integration. Validation compiles with -Wall -Werror, runs static analysis such as cppcheck, and verifies register bit fields against datasheets. Optimization minimizes code size, RAM usage, and power consumption. Testing validates timing with logic analyzers or oscilloscopes, checks stack headroom via uxTaskGetStackHighWaterMark, measures ISR latency, and confirms deadlines under worst-case load. MUST rules enforce volatile hardware registers, short ISRs with deferred task work, watchdog timers, synchronization primitives, and documented flash, RAM, and power usage. MUST NOT rules block blocking ISR calls, unbounded dynamic allocation, missing critical sections, and floating-point without hardware support awareness. Reference guides load for RTOS patterns, microcontroller.5.1kinstalls15Sql ProThe sql-pro skill guides agents through schema analysis, set-based query design, execution plan review, and verified optimization for PostgreSQL, MySQL, SQL Server, and Oracle workloads. It loads targeted references for JOIN and CTE patterns, window functions, EXPLAIN interpretation, database design, and dialect differences when context demands. The core workflow reviews structure and indexes, designs queries with early filtering and window functions, analyzes plans to eliminate sequential scans on large tables, implements covering indexes, and verifies with EXPLAIN ANALYZE against a sub-100 millisecond target before documenting rationale and metrics. Mandatory practices include set-based operations over cursors, EXISTS over COUNT for existence checks, explicit NULL handling, production-scale testing, and dialect-specific tuning. Output templates deliver optimized SQL with inline comments, index recommendations, plan analysis, before-and-after benchmarks, and platform notes. Quick-reference examples cover ranked-order CTEs, running totals via window functions, correlated subquery rewrites, and covering index creation for aggregation joins.4.9kinstalls16Code ReviewerThe code-reviewer skill analyzes code diffs and files to identify bugs, security vulnerabilities (SQL injection, XSS, insecure deserialization), code smells, N+1 queries, naming issues, and architectural concerns, then produces a structured review report with prioritized, actionable feedback. Use when reviewing pull requests, conducting code quality audits, identifying refactoring opportunities, or checking for security issues. Invoke for PR reviews, code quality checks, refactoring suggestions, review code, code quality. Complements specialized skills (security-reviewer, test-master) by providing broad-scope review across correctness, performance, maintainability, and test coverage in a single pass.. Code Reviewer Senior engineer conducting thorough, constructive code reviews that improve quality and share knowledge. When to Use This Skill - Reviewing pull requests - Conducting code quality audits - Identifying refactoring opportunities - Checking for security vulnerabilities - Validating architectural decisions Core Workflow 1. Context - Read PR description, understand the problem being solved. Checkpoint: Summarize the PR's intent in one sentence before proceeding. If you can.4.7kinstalls17Api DesignerThe api-designer skill is a senior API architect workflow for REST and GraphQL APIs with comprehensive OpenAPI 3.1 specifications. The six-step core workflow analyzes domain requirements, models resources and relationships with an entity diagram, designs URI patterns and HTTP methods, writes the OpenAPI contract validated via npx @redocly/cli lint openapi.yaml, mocks with npx @stoplight/prism-cli mock openapi.yaml, and plans versioning with deprecation strategy. Must-do rules include resource-oriented REST, consistent snake_case or camelCase naming, RFC 7807 problem details, pagination on collections, documented auth, and rate limiting considerations. Must-not rules forbid verbs in URIs, inconsistent response shapes, missing error docs, and breaking changes without migration paths. Deliverables include resource models, endpoint specs, OpenAPI YAML, auth flows, error catalogs, pagination patterns, and lint-passing validation. Reference guides load for REST patterns, versioning, pagination, error handling, and OpenAPI details on demand.4.7kinstalls18Rust EngineerThe rust-engineer skill writes, reviews, and debugs idiomatic Rust code with memory safety and zero-cost abstractions. Implements ownership patterns, manages lifetimes, designs trait hierarchies, builds async applications with tokio, and structures error handling with Result/Option. Use when building Rust applications, solving ownership or borrowing issues, designing trait-based APIs, implementing async/await concurrency, creating FFI bindings, or optimizing for performance and memory safety. Invoke for Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming.. Rust Engineer Senior Rust engineer with deep expertise in Rust 2021 edition, systems programming, memory safety, and zero-cost abstractions. Specializes in building reliable, high-performance software leveraging Rust's ownership system. Analyze ownership - Design lifetime relationships and borrowing patterns; annotate lifetimes explicitly where inference is insufficient 2. Design traits - Create trait hierarchies with generics and associated types 3. Implement safely - Write idiomatic Rust with minimal unsafe code; document every unsafe block with its.4.7kinstalls19Fastapi ExpertThe fastapi-expert skill use when building high-performance async Python APIs with FastAPI and Pydantic V2. Invoke to create REST endpoints, define Pydantic models, implement authentication flows, set up async SQLAlchemy database operations, add JWT authentication, build WebSocket endpoints, or generate OpenAPI documentation. Trigger terms: FastAPI, Pydantic, async Python, Python API, REST API Python, SQLAlchemy async, JWT authentication, OpenAPI, Swagger Python.. FastAPI Expert Deep expertise in async Python, Pydantic V2, and production-grade API development with FastAPI. When to Use This Skill - Building REST APIs with FastAPI - Implementing Pydantic V2 validation schemas - Setting up async database operations - Implementing JWT authentication/authorization - Creating WebSocket endpoints - Optimizing API performance Core Workflow 1. Analyze requirements - Identify endpoints, data models, auth needs 2. Design schemas - Create Pydantic V2 models for validation 3. Implement - Write async endpoints with proper dependency injection 4. Secure - Add authentication, authorization, rate limiting 5.4.7kinstalls20Java ArchitectThe java-architect skill is an enterprise Java specialist for Spring Boot 3.x, microservices, and cloud-native development on Java 21 LTS. The six-step workflow covers architecture analysis, DDD domain design with boundary verification, Spring Boot implementation, JPA data layer optimization with ./mvnw verify query checks, Spring Security OAuth2 JWT configuration with filter chain tests, and quality assurance requiring 85 percent plus JaCoCo coverage before close. Must-do rules include Java 21 records and sealed classes, Flyway or Liquibase migrations, OpenAPI documentation, proper exception hierarchies, and externalized configuration. Must-not rules forbid deprecated Spring APIs, skipped validation, unencrypted sensitive data, blocking code in reactive apps, and ignored transaction boundaries. Reference guides load for spring-boot-setup, reactive-webflux, jpa-optimization, spring-security, and testing-patterns. Output templates ship WebFlux controllers, JOIN FETCH repositories, and OAuth2 resource server SecurityFilterChain examples with TestContainers guidance.4.6kinstalls21Javascript ProThe javascript-pro skill Writes, debugs, and refactors JavaScript code using modern ES2023+ features, async/await patterns, ESM module systems, and Node.js APIs. Use when building vanilla JavaScript applications, implementing Promise-based async flows, optimising browser or Node.js performance, working with Web Workers or Fetch API, or reviewing .js/.mjs/.cjs files for correctness and best practices.. JavaScript Pro When to Use This Skill - Building vanilla JavaScript applications - Implementing async/await patterns and Promise handling - Working with modern module systems (ESM/CJS) - Optimizing browser performance and memory usage - Developing Node.js backend services - Implementing Web Workers, Service Workers, or browser APIs Core Workflow 1. **Analyze requirements** — Review `package.json`, module system, Node version, browser targets; confirm `.js`/`.mjs`/`.cjs` conventions 2. **Design architecture** — Plan modules, async flows, and error handling strategies 3. **Implement** — Write ES2023+ code with proper patterns and optimisations 4. **Validate** —4.3kinstalls22Game DeveloperGame Developer is a specialist skill for implementing core game systems across Unity and Unreal Engine platforms. Developers invoke it to design and build ECS (Entity Component System) architectures, configure physics systems with colliders, implement multiplayer networking with lag compensation, and optimize frame rates to 60+ FPS targets. The skill provides code patterns for object pooling, component caching, and state machines - critical for avoiding performance bottlenecks in Update loops. Validation checkpoints include profiling with Unity Profiler or Unreal Insights to verify frame time ≤16 ms, stress-testing multiplayer systems, and cross-platform testing. MUST-DO constraints enforce async loading, LOD systems, ScriptableObject data separation, and delta-time movement; MUST-NOT rules prohibit Instantiate/Destroy in loops, string tag comparisons, and memory allocation during frame updates. ECS architecture design and entity-component-system patterns for scalable game logic Physics systems, collider configuration, and collision handling for gameplay mechanics Multiplayer networking with client-server models and lag compensation protocols Performance profiling and optimization.4.3kinstalls23Security ReviewerSecurity Reviewer is a specialist skill for identifying vulnerabilities across code, dependencies, and infrastructure. It combines automated SAST scanning (semgrep, bandit, gitleaks, trivy, npm audit) with mandatory manual review to catch context-dependent flaws in authentication, input handling, and cryptography. Developers invoke it during code reviews, penetration testing, DevSecOps pipelines, cloud security audits, and compliance checks. The workflow maps attack surface, runs tool suites, performs verification testing with proof-of-concept validation, and generates structured reports with CVSS severity ratings, specific file locations, and actionable remediation steps. Critical findings are escalated immediately; all findings documented with impact and remediation guidance. Runs SAST tools (semgrep, bandit, gitleaks, trivy, npm audit) with automated scanning and structured output Manual code review mandatory after tool runs to catch context-dependent vulnerabilities tools miss CVSS severity classification (Critical/High/Medium/Low/Info) with4.3kinstalls24Nestjs ExpertThe nestjs-expert skill Creates and configures NestJS modules, controllers, services, DTOs, guards, and interceptors for enterprise-grade TypeScript backend applications. Use when building NestJS REST APIs or GraphQL services, implementing dependency injection, scaffolding modular architecture, adding JWT/Passport authentication, integrating TypeORM or Prisma, or working with .module.ts, .controller.ts, and .service.ts files. Invoke for guards, interceptors, pipes, validation, Swagger documentation, and unit/E2E testing in NestJS projects.. NestJS Expert Senior NestJS specialist with deep expertise in enterprise-grade, scalable TypeScript backend applications. Core Workflow 1. **Analyze requirements** — Identify modules, endpoints, entities, and relationships 2. **Design structure** — Plan module organization and inter-module dependencies 3. **Implement** — Create modules, services, and controllers with proper DI wiring 4. **Secure** — Add guards, validation pipes, and authentication 5. **Verify** — Run `npm run lint`, `npm run test`, and confirm DI graph with `nest info` 6. **Test** — Write unit tests for services and E2E tests for controllers Reference Guide Load4.3kinstalls25Pandas ProThe pandas-pro skill Performs pandas DataFrame operations for data analysis, manipulation, and transformation. Use when working with pandas DataFrames, data cleaning, aggregation, merging, or time series analysis. Invoke for data manipulation tasks such as joining DataFrames on multiple keys, pivoting tables, resampling time series, handling NaN values with interpolation or forward-fill, groupby aggregations, type conversion, or performance optimization of large datasets.. Pandas Pro Expert pandas developer specializing in efficient data manipulation, analysis, and transformation workflows with production-grade performance patterns. Core Workflow 1. **Assess data structure** — Examine dtypes, memory usage, missing values, data quality: 2. **Design transformation** — Plan vectorized operations, avoid loops, identify indexing strategy 3. **Implement efficiently** — Use vectorized methods, method chaining, proper indexing 4. **Validate results** — Check dtypes, shapes, null counts, and row counts: 5. **Optimize** — Profile memory, apply categorical types, use chunking if needed Reference Guide Load detailed guidance based on context: | Topic4.3kinstalls26Database OptimizerDatabase Optimizer is a specialist skill for diagnosing and resolving database performance bottlenecks in PostgreSQL and MySQL. Developers invoke it when investigating slow queries, analyzing EXPLAIN ANALYZE output, designing covering indexes, or tuning configuration parameters like shared_buffers and work_mem. The core workflow captures baseline metrics, identifies inefficient query patterns and missing indexes, designs targeted optimizations (rewrites, partitioning, lock contention fixes), and validates improvements before production rollout. It enforces test-first discipline: always measure before and after each change, create indexes concurrently to avoid locks, and roll back if write performance or replication lag degrades. Output includes performance analysis, bottleneck root causes with EXPLAIN evidence, implementation SQL, and validation queries. Analyzes PostgreSQL and MySQL execution plans using EXPLAIN (ANALYZE, BUFFERS) to identify sequential scans, nested loops, and cache misses Designs covering indexes4.2kinstalls27Nextjs DeveloperNext.js Developer is a specialist skill for building modern Next.js 14+ applications using App Router and React Server Components. Developers invoke it to architect file-based routing with layouts, implement server-side data fetching with caching and ISR, create server actions for form handling and mutations, optimize images and fonts, add loading and error boundaries, and configure production deployments. Core workflows span route structure planning, streaming SSR setup, SEO metadata generation via generateMetadata, performance optimization using next/image and next/font, and Vercel deployment validation. The skill enforces best practices: prefer server components by default, use native fetch with explicit cache directives, avoid Pages Router, and always run next build before deployment. App Router file-based routing with layouts, templates, and route groups Server Components and Server Actions for full-stack mutations and revalidation Data fetching4.2kinstalls28Prompt EngineerThe prompt-engineer skill Writes, refactors, and evaluates prompts for LLMs generating optimized prompt templates, structured output schemas, evaluation rubrics, and test suites. Use when designing prompts for new LLM applications, refactoring existing prompts for better accuracy or token efficiency, implementing chain-of-thought or few-shot learning, creating system prompts with personas and guardrails, building JSON/function-calling schemas, or developing prompt evaluation frameworks to measure and improve model performance. Expert prompt engineer specializing in designing, optimizing, and evaluating prompts that maximize LLM performance across diverse use cases. - Designing prompts for new LLM applications - Optimizing existing prompts for better accuracy or efficiency - Implementing chain-of-thought or few-shot learning - Creating system prompts with personas and guardrails - Building structured output schemas (JSON mode, function calling) - Developing prompt evaluation and testing frameworks - Debugging inconsistent or poor-quality LLM outputs - Migrating prompts between different models or providers 1. Understand requirements Define task, success criteria, constraints, and e.4.1kinstalls29Code DocumenterThe code-documenter skill Generates, formats, and validates technical documentation including docstrings, OpenAPI/Swagger specs, JSDoc annotations, doc portals, and user guides. Use when adding docstrings to functions or classes, creating API documentation, building documentation sites, or writing tutorials and user guides. Invoke for OpenAPI/Swagger specs, JSDoc, doc portals, getting started guides. Documentation specialist for inline documentation, API specs, documentation sites, and developer guides. Applies to any task involving code documentation, API specs, or developer-facing guides. See the reference table below for specific sub-topics. 1. Discover - Ask for format preference and exclusions 2. Detect - Identify language and framework 3. Analyze - Find undocumented code 4. Document - Apply consistent format 5. Validate - Test all code examples compile/run: - Python: python -m doctest file.py for doctest blocks; pytest --doctest-modules for module-wide checks - TypeScript/JavaScript: tsc --noEmit to confirm typed examples compile - OpenAPI: validate spec with npx @redocly/cli lint openapi.yaml - If validation fails: fix examples and re-validate before proceeding to the Repor.4.1kinstalls30Fullstack GuardianFullstack Guardian is a security-focused skill for implementing complete web application features across frontend, backend, and database layers simultaneously. Developers invoke it when building authenticated REST API routes with corresponding UI, creating end-to-end CRUD flows, integrating frontend components to backend endpoints, or making architecture decisions about microservices and monorepo structures. The workflow follows a fixed sequence: gather requirements, design the solution from three perspectives (Frontend, Backend, Security), write a technical design doc in specs/, run a security checklist before any code is written, then build incrementally. Key constraints enforce parameterized queries to prevent SQL injection, server-side input validation, sanitized output to prevent XSS, explicit API response schemas to avoid data leakage, and logging of security-relevant events. On completion it hands off to Test Master for QA and DevOps for deployment.4kinstalls31Terraform EngineerThe terraform-engineer skill Use when implementing infrastructure as code with Terraform across AWS, Azure, or GCP. Invoke for module development (create reusable modules, manage module versioning), state management (migrate backends, import existing resources, resolve state conflicts), provider configuration, multi-environment workflows, and infrastructure testing. Senior Terraform engineer specializing in infrastructure as code across AWS, Azure, and GCP with expertise in modular design, state management, and production-grade patterns. 1. Analyze infrastructure Review requirements, existing code, cloud platforms 2. Design modules Create composable, validated modules with clear interfaces 3. Implement state Configure remote backends with locking and encryption 4. Secure infrastructure Apply security policies, least privilege, encryption 5. Validate Run terraform fmt and terraform validate, then tflint; if any errors are reported, fix them and re-run until all checks pass cleanly before proceeding 6. Plan and apply Run terraform plan -out=tfplan, review output carefully, then terraform apply tfplan; if the plan fails, see error recovery below Validation failures (step 5): Fix repo.4kinstalls32Shopify ExpertThe shopify-expert skill Builds and debugs Shopify themes (.liquid files, theme.json, sections), develops custom Shopify apps (shopify.app.toml, OAuth, webhooks), and implements Storefront API integrations for headless storefronts. Use when building or customizing Shopify themes, creating Hydrogen or custom React storefronts, developing Shopify apps, implementing checkout UI extensions or Shopify Functions, optimizing performance, or integrating third-party services. Invoke for Liquid templating, Storefront API, app development, checkout customization, Shopify Plus features, App Bridge, Polaris, or Shopify CLI workflows. Senior Shopify developer with expertise in theme development, headless commerce, app architecture, and custom checkout solutions. 1. Requirements analysis Identify if theme, app, or headless approach fits needs 2. Architecture setup Scaffold with shopify theme init or shopify app create; configure shopify.app.toml and theme schema 3. Implementation Build Liquid templates, write GraphQL queries, or develop app features (see examples below) 4. Validation Run shopify theme check for Liquid linting; if errors are found, fix them and re-run before proceeding. Run shopi.4kinstalls33Playwright ExpertPlaywright Expert is a specialist skill for writing, configuring, and debugging end-to-end browser tests using the Playwright framework. Developers invoke it when setting up test infrastructure, authoring Page Object Model classes, configuring playwright.config.ts, implementing API route mocking, or diagnosing flaky test failures. The core workflow moves from requirement analysis through test authoring, debugging via the trace viewer, and CI/CD pipeline integration. Key constraints enforce role-based selectors over brittle CSS classes, auto-waiting over arbitrary timeouts, and strict test isolation with no shared state. Output templates include Page Object classes, test spec files with assertions, fixture setup, and configuration recommendations for parallel execution with trace and screenshot capture on failure. Enforces Page Object Model pattern with typed Locator properties and reusable goto/action methods Mandates role-based selectors (getByRole, getByLabel) and bans CSS class selectors for resilience3.9kinstalls34React ExpertThe react-expert skill Use when building React 18 applications in jsx or tsx files Next js App Router projects or create-react-app setups Creates components implements custom hooks debugs rendering issues migrates class components to functional and implements state management Invoke for Server Components Suspense boundaries useActionState forms performance optimization or React 19 features React Expert Senior React specialist with deep expertise in React 19 Server Components and production-grade application architecture When to Use This Skill Building new React components or features Implementing state management local Context Redux Zustand Optimizing React performance Setting up React project architecture Working with React 19 Server Components Implementing forms with React 19 actions Data fetching patterns with TanStack Query or use Core Workflow 1 Analyze requirements Identify component hierarchy state needs data flow 2 Choose patterns Select appropriate state management data fetching approach 3 Implement Write TypeScript components with proper types 4 Validate Run tsc noEmit if it fails review reported errors fix all type issues and re-run until clean before proceeding 5 Optim.3.9kinstalls35Kotlin SpecialistKotlin Specialist is a senior-level implementation skill for Kotlin 1.9+ projects across Android, server, and multiplatform targets. Developers invoke it when building coroutine-based async pipelines, StateFlow/SharedFlow reactive streams, or Kotlin Multiplatform shared modules with expect/actual declarations. The core workflow moves through architecture analysis, sealed-class data modeling, idiomatic implementation with scope functions, static analysis via detekt and ktlint, inline-class optimization, and multiplatform testing with runTest and Turbine. It enforces structured concurrency rules - banning GlobalScope.launch and runBlocking in production - and mandates null-safety patterns throughout. Output always includes data models, implementation files, coroutine-aware test files, and KDoc for public APIs. Sealed class UiState pattern with Loading, Success, and Error branches enforced exhaustively by the compiler Structured concurrency enforcement: GlobalScope.launch and production runBlocking are explicitly prohibited Flow pipeline guidance covering flowOn(Dispatchers.IO), StateFlow, SharedFlow, and Turbine-based stream testing3.9kinstalls36Monitoring ExpertThe monitoring-expert skill Configures monitoring systems implements structured logging pipelines creates Prometheus Grafana dashboards defines alerting rules and instruments distributed tracing Implements Prometheus Grafana stacks conducts load testing performs application profiling and plans infrastructure capacity Use when setting up application monitoring adding observability to services debugging production issues with logs metrics traces running load tests with k6 or Artillery profiling CPU memory bottlenecks or forecasting capacity needs Monitoring Expert Observability and performance specialist implementing comprehensive monitoring alerting tracing and performance testing systems Core Workflow 1 Assess Identify what needs monitoring SLIs critical paths business metrics 2 Instrument Add logging metrics and traces to the application see examples below 3 Collect Configure aggregation and storage Prometheus scrape log shipper OTLP endpoint verify data arrives before proceeding 4 Visualize Build dashboards using RED Rate Errors Duration or USE Utilization Saturation Errors methods 5 Alert Define threshold and anomaly alerts on critical paths validate no false-positive flood bef.3.9kinstalls37Test MasterTest Master is a comprehensive testing specialist that generates test files, creates mocking strategies, analyzes code coverage, and designs test architectures across functional, performance, and security disciplines. Developers use it when writing unit tests with Jest or pytest, building integration tests with Supertest, designing E2E test strategies, performing load testing with k6 or Artillery, or executing security testing with OWASP methods. Key workflows include defining test scope, creating test strategies, implementing tests with proper assertions, executing tests while classifying failures and fixing flaky tests, and reporting findings with severity ratings and actionable recommendations. The skill enforces test isolation, meaningful descriptions, specific assertions, and coverage validation while preventing common anti-patterns like order-dependent tests or production data in tests. Generates unit, integration, E2E, performance, and security tests across Jest, pytest, and Supertest.3.9kinstalls38Cpp Procpp-pro is a specialist skill for senior C++ development using modern C++20/23 standards, template metaprogramming, and systems programming techniques. It guides developers through architecture analysis, type-safe interface design with concepts, zero-cost abstraction implementation, memory safety verification with sanitizers, and performance profiling with real workloads. Core workflows include RAII resource management, smart pointer ownership patterns, constexpr optimization, SIMD acceleration, and CMake build configuration. The skill enforces C++ Core Guidelines, concept-based templates, and const-correctness while prohibiting raw pointers, C-style casts, and undefined behavior. Load detailed references for modern features, template metaprogramming, memory optimization, concurrency primitives, and tooling configuration. C++20/23 concepts for type-safe, self-documenting template constraints. RAII wrappers and smart pointer patterns (unique_ptr, shared_ptr) eliminating manual resource cleanup. Sanitizer-driven verification: AddressSanitizer and UndefinedBehaviorSanitizer before optimization. Zero-overhead abstractions via constexpr, move semantics, and cache-aware layout.3.9kinstalls39React Native ExpertReact Native Expert guides developers through building production-ready cross-platform mobile applications with React Native and Expo. Covers core workflows: setup with Expo Router or React Navigation and TypeScript, feature-based project structure, component implementation with platform-specific code paths, performance optimization via FlatList memo + useCallback patterns and Flipper profiling, and testing on both iOS and Android real devices. Handles navigation hierarchies (tabs, stacks, drawers), native module integration, SafeAreaView notch handling, keyboard input management, and memory leak prevention. Includes error recovery strategies for Metro bundler, iOS/Android build failures, and native module resolution. Developers use this when building Expo or React Native apps, setting up navigation architectures, integrating native modules, or optimizing scroll performance. Setup with Expo Router or React Navigation plus TypeScript; verify with `npx expo doctor` before proceeding. Optimize FlatList rendering using memo + useCallback; profile with Flipper or React DevTools.3.7kinstalls40Debugging WizardThe debugging-wizard skill Parses error messages, traces execution flow through stack traces, correlates log entries to identify failure points, and applies systematic hypothesis-driven methodology to isolate and resolve bugs. Use when investigating errors, analyzing stack traces, finding root causes of unexpected behavior, troubleshooting crashes, or performing log analysis, error investigation, or root cause analysis. Expert debugger applying systematic methodology to isolate and resolve issues in any codebase. 1. Reproduce - Establish consistent reproduction steps 2. Isolate - Narrow down to smallest failing case 3. Hypothesize and test - Form testable theories, verify/disprove each one 4. Fix - Implement and verify solution 5. Prevent - Add tests/safeguards against regression <!-- Systematic Debugging row adapted from obra/superpowers by Jesse Vincent (@obra), MIT License -- Topic Reference Load When ------- ----------- ----------- Debugging Tools references/debugging-tools.md Setting up debuggers by language Common Patterns references/common-patterns.md Recognizing bug patterns Strategies references/strategies.md Binary search, git bisect, time travel Quick Fixes references/q.3.7kinstalls41Secure Code GuardianThe secure-code-guardian skill Use when implementing authentication/authorization, securing user input, or preventing OWASP Top 10 vulnerabilities including custom security implementations such as hashing passwords with bcrypt/argon2, sanitizing SQL queries with parameterized statements, configuring CORS/CSP headers, validating input with Zod, and setting up JWT tokens. Invoke for authentication, authorization, input validation, encryption, OWASP Top 10 prevention, secure session management, and security hardening. For pre-built OAuth/SSO integrations or standalone security audits, consider a more specialized skill. 1. Threat model Identify attack surface and threats 2. Design Plan security controls 3. Implement Write secure code with defense in depth; see code examples below 4. Validate Test security controls with explicit checkpoints (see below) 5. Document Record security decisions - Authentication: Test brute-force protection (lockout/rate limit triggers), session fixation resistance, token expiration, and invalid-credential error messages (must not leak user existence). - Authorization: Verify horizontal and vertical privilege escalation paths are blocked; test with tokens be.3.7kinstalls42Microservices ArchitectThe microservices-architect skill Designs distributed system architectures, decomposes monoliths into bounded-context services, recommends communication patterns, and produces service boundary diagrams and resilience strategies. Use when designing distributed systems, decomposing monoliths, or implementing microservices patterns including service boundaries, DDD, saga patterns, event sourcing, CQRS, service mesh, or distributed tracing. Senior distributed systems architect specializing in cloud-native microservices architectures, resilience patterns, and operational excellence. 1. Domain Analysis Apply DDD to identify bounded contexts and service boundaries. - Validation checkpoint: Each candidate service owns its data exclusively, has a clear public API contract, and can be deployed independently. 2. Communication Design Choose sync/async patterns and protocols (REST, gRPC, events). - Validation checkpoint: Long-running or cross-aggregate operations use async messaging; only query/command pairs with sub-100 ms SLA use synchronous calls. 3. Data Strategy Database per service, event sourcing, eventual consistency. - Validation checkpoint: No shared database schema exists between se.3.7kinstalls43Dotnet Core ExpertThe dotnet-core-expert skill Use when building .NET 8 applications with minimal APIs, clean architecture, or cloud-native microservices. Invoke for Entity Framework Core, CQRS with MediatR, JWT authentication, AOT compilation. 1. Analyze requirements Identify architecture pattern, data models, API design 2. Design solution Create clean architecture layers with proper separation 3. Implement Write high-performance code with modern C features; run dotnet build to verify compilation if build fails, review errors, fix issues, and rebuild before proceeding 4. Secure Add authentication, authorization, and security best practices 5. Test Write comprehensive tests with xUnit and integration testing; run dotnet test to confirm all tests pass if tests fail, diagnose failures, fix the implementation, and re-run before continuing; verify endpoints with curl or a REST client Topic Reference Load When ------- ----------- ----------- Minimal APIs references/minimal-apis.md Creating endpoints, routing, middleware Clean Architecture references/clean-architecture.m3.5kinstalls44Angular ArchitectThe angular-architect skill Generates Angular 17+ standalone components, configures advanced routing with lazy loading and guards, implements NgRx state management, applies RxJS patterns, and optimizes bundle performance. Use when building Angular 17+ applications with standalone components or signals, setting up NgRx stores, establishing RxJS reactive patterns, performance tuning, or writing Angular tests for enterprise apps. Senior Angular architect specializing in Angular 17+ with standalone components, signals, and enterprise-grade application development. 1. Analyze requirements - Identify components, state needs, routing architecture 2. Design architecture - Plan standalone components, signal usage, state flow 3. Implement features - Build components with OnPush strategy and reactive patterns 4. Manage state - Setup NgRx store, effects, selectors as needed; verify store hydration and action flow with Redux DevTools before proceeding 5. Optimize - Apply performance best practices and bundle optimization; run ng build --configuration production to verify bundle size and flag regressions 6. Test - Write unit and integration tests with TestBed; verify 85% coverage threshold is m.3.5kinstalls45Csharp DeveloperC# Developer is a specialist skill for building high-performance applications on .NET 8 and later across ASP.NET Core APIs, Entity Framework Core, and Blazor Server or WASM. The workflow starts by analyzing solution files, NuGet packages, and architecture, then designs domain models, DTOs, and validation before implementing endpoints, repositories, and services with dependency injection. It enforces nullable reference types, file-scoped namespaces, primary constructors, async I/O with forwarded CancellationToken, strongly typed IOptions configuration, XML documentation on public APIs, and a Result pattern for errors. Constraints forbid blocking async calls, exposing EF entities in API responses, string-based configuration keys, and skipping input validation. After implementation it runs xUnit tests with TestServer targeting 80 percent or higher coverage and pauses after EF migrations to review generated schema changes. Reference guides load for modern C#, ASP.NET Core, Entity Framework, Blazor, and performance topics including Span and Memory. Output templates include models, endpoints, services, and Program.cs configuration with brief architectural notes.3.5kinstalls46Rails ExpertThe rails-expert skill Rails 7+ specialist that optimizes Active Record queries with includes/eager_load, implements Turbo Frames and Turbo Streams for partial page updates, configures Action Cable for WebSocket connections, sets up Sidekiq workers for background job processing, and writes comprehensive RSpec test suites. Use when building Rails 7+ web applications with Hotwire, real-time features, or background job processing. Invoke for Active Record optimization, Turbo Frames/Streams, Action Cable, Sidekiq, RSpec Rails. 1. Analyze requirements Identify models, routes, real-time needs, background jobs 2. Scaffold resources rails generate model User name:string email:string, rails generate controller Users 3. Run migrations rails db:migrate and verify schema with rails db:schema:dump - If migration fails: inspect db/schema.rb for conflicts, rollback with rails db:rollback, fix and retry 4. Implement Write controllers, models, add Hotwire (see Reference Guide below) 5. Validate bundle exec rspec must pass; bundle exec rubocop for style - If specs fail: check error output, fix failing examples, re-run with --format documentation for detail - If N+1 queries3.5kinstalls47Cli Developercli-developer guides agents through building command-line tools with disciplined UX, framework selection, and cross-platform polish. The five-step core workflow analyzes user workflows and command hierarchy, designs subcommands flags and configuration, implements with the right framework for Node.js commander, Python click or typer, or Go cobra, adds completions help text and progress indicators, then tests on Windows macOS and Linux with a sub-50ms startup target. Reference guides load on demand for design patterns, per-language CLI notes, and UX patterns covering progress bars colors and help text. Constraints require clear error messages, --help and --version flags, consistent flag naming, graceful SIGINT handling, early input validation, interactive and non-interactive modes, and shell completions for bash zsh and fish. Must-not rules cover async I/O instead of blocking sync, stderr for diagnostics when piped, TTY detection before colors, no breaking command signature changes, non-interactive CI fallbacks, and portable paths via homedir helpers. Output templates deliver command structure, configuration handling, core implementation, completion scripts, and UX rationale.3.5kinstalls48Sre EngineerThe sre-engineer skill guides agents through site reliability engineering practices for production systems at scale. Developers use it when defining SLIs and SLOs, managing error budgets, building incident response procedures, designing capacity models, or producing monitoring configurations and automation scripts. The core workflow assesses reliability, defines quantitative SLOs with user-impact justification, verifies alignment, implements golden-signal dashboards and alerting, automates toil, and tests resilience with chaos experiments that meet RTO and RPO targets. Constraints require blameless postmortems, actionable runbooks for alerts, error budget tracking, and graceful degradation rather than manual recurring processes. Reference files cover SLO and SLI management, error budget policy, monitoring and alerting, automation and toil reduction, and incident plus chaos engineering guidance loaded on demand. Output templates include SLO definitions, Prometheus alerting rules, Python or Go automation scripts, and runbooks with remediation steps. Concrete examples document multiwindow burn-rate alerts, PromQL golden signal queries, and pod restart auto-remediation tied to Prometh.3.5kinstalls49Rag ArchitectRAG Architect guides developers through building production-grade retrieval-augmented generation systems. The skill covers requirements analysis, vector store design, document chunking strategies, hybrid search pipelines combining dense and sparse retrieval, reranking optimization, and comprehensive evaluation metrics. It provides reference guides for vector databases, embedding model selection, chunking strategies, retrieval optimization techniques, and RAG evaluation frameworks. Implementation examples demonstrate chunking with metadata preservation, embedding generation and indexing with deduplication, hybrid search using reciprocal rank fusion, result reranking with Cohere, and evaluation using RAGAS metrics including context precision and recall.3.5kinstalls50Cloud Architectcloud-architect is Jeffallan's infrastructure agent skill for designing systems across AWS, Azure, and GCP. It follows a six-step workflow: discovery, design, security, cost modeling, migration via the 6Rs framework, and ongoing operations with monitoring. The skill mandates high availability (99.9%+), zero-trust security, infrastructure as code with Terraform or CloudFormation, cost allocation tags, defined RTO/RPO disaster recovery, and multi-region coverage for critical workloads. Reference guides load per topic for AWS Well-Architected, Azure Cloud Adoption Framework, GCP services, multi-cloud portability, and FinOps cost practices. Validation checkpoints confirm VPC peering connectivity before migration cutover and verify ALB target health afterward. Included patterns cover least-privilege IAM with Terraform examples, VPC public/private subnets, auto-scaling groups with CPU target tracking, and CLI cost analysis across AWS and Azure. Output templates expect architecture diagrams, service rationale, security design, cost estimates, and rollback plans.3.4kinstalls51Vue Expertvue-expert is a Jeffallan frontend specialist skill at version 1.1.0 for Vue 3 Composition API, reactivity, and the modern Vue ecosystem. The core workflow analyzes requirements, designs composables and stores, implements script-setup components, validates with vue-tsc --noEmit until clean, optimizes re-renders and computed usage, and tests with Vue Test Utils plus Vitest. Reference files load on demand for composition API, components, Pinia state, Nuxt 3 SSR, TypeScript typing, Quasar and Capacitor mobile, PWA service workers, and Vite build tuning. Hard constraints require Composition API only, script setup, type-safe props, ref for primitives, reactive for objects, computed for derived state, Pinia over Vuex, and cleanup in composables. Developers reach for vue-expert when scaffolding Nuxt 3 apps, migrating Options API modules, building Quasar or Capacitor hybrids, or shipping reactive UIs with Vue Router 4, VueUse, and performance-minded patterns rather than generic JavaScript guidance.3.3kinstalls52Salesforce DeveloperSalesforce Developer is a specialist skill for building on the Salesforce platform with Apex classes, Lightning Web Components, SOQL and SOSL queries, triggers, batch jobs, platform events, and REST or SOAP integrations. The workflow analyzes business requirements and governor limits, designs declarative versus programmatic solutions, implements bulkified code, validates SOQL and DML counts plus heap and CPU limits, writes test classes targeting 90 percent or higher coverage including 200-record bulk scenarios, and deploys through Salesforce DX scratch orgs and CI/CD metadata pipelines. MUST rules require collecting IDs before loops, selective indexed SOQL, async processing for long work, Database.update with partial success, and proper error handling. MUST NOT rules forbid SOQL or DML inside loops, hard-coded IDs, recursive triggers without safeguards, skipping field-level security checks, or deprecated APIs. Reference guides load for Apex development, LWC framework, SOQL optimization, integration patterns, and deployment DevOps. Code patterns include bulkified trigger handlers, batch Apex with 200-record scopes, relationship queries, and LWC counter components with exposed metad.3.2kinstalls53Atlassian McpAtlassian MCP Expert guides integrating Jira and Confluence through MCP servers for issue tracking and documentation automation. The workflow selects official cloud, open-source, or self-hosted MCP server options, configures OAuth 2.1 or API token authentication from environment variables, designs JQL for Jira and CQL for Confluence queries with maxResults equals 1 validation probes before bulk execution, implements tool calls with pagination at 50 to 100 items per page and exponential backoff on rate limits, verifies read-only permission scopes before writes, and deploys IDE integration with audit logging. MUST rules require respecting workspace permissions, pagination for large sets, error recovery, read-only probes first, and confirmation before production writes. MUST NOT rules forbid hardcoded tokens, ignoring rate limit headers, creating issues without required field validation, skipping input sanitization, or exposing sensitive issue data in logs. Quick-start examples include sprint JQL filters, Confluence space search, and npx mcp-atlassian JSON configuration loading JIRA_API_TOKEN from secrets. Output templates deliver MCP server config, query examples, tool implementatio.3.2kinstalls54Swift Expertswift-expert guides iOS, macOS, watchOS, and tvOS development with Swift 5.9+, SwiftUI, async await concurrency, actors, protocol-oriented architecture, UIKit integration, Combine, and Vapor server-side Swift. The core workflow runs architecture analysis, protocol-first API design, type-safe implementation, Instruments profiling for thread safety, and XCTest coverage including async test patterns. Validation checkpoints require swift build after implementation, swift build -warnings-as-errors after optimization to surface actor isolation and Sendable warnings, and swift test confirming async tests pass. Reference guides load by topic for SwiftUI patterns, async concurrency, protocol-oriented design, memory and performance, and testing strategies. Code patterns contrast correct async await error handling versus wrapping legacy completion handlers, @Observable view models versus ObservableObject boilerplate, and protocol repositories with associated types versus class inheritance. Developers invoke it for SwiftUI state management, actor thread safety, protocol-oriented modules, and debugging Swift-specific compiler issues.3.1kinstalls55Feature Forgefeature-forge is an agent skill for structured feature specification through dual PM and Dev perspective workshops. The five-step workflow discovers goals and users with AskUserQuestions, interviews from both value and feasibility angles, documents functional requirements in EARS syntax, validates acceptance criteria with stakeholders, and plans an implementation checklist. Reference files cover EARS syntax, interview questions, specification templates, acceptance criteria in Given/When/Then form, and pre-discovery subagents for multi-domain features. Constraints require structured elicitation via AskUserQuestions, a full interview before writing specs, EARS format for every functional requirement, non-functional requirements for performance and security, testable acceptance criteria, and an implementation TODO checklist. Output templates include overview, functional and non-functional requirements, acceptance criteria, error handling table, and checklist saved to specs/{feature_name}.spec.md. Developers and product managers reach for it when defining new features, gathering requirements, or replacing vague scope with testable specifications.3.1kinstalls56Fine Tuning ExpertFine-Tuning Expert is a Jeffallan agent skill for production LLM adaptation using parameter-efficient fine-tuning with Hugging Face PEFT, TRL SFTTrainer, and optional 4-bit QLoRA. The five-step workflow runs dataset validation before training, method selection based on GPU memory, hyperparameter configuration with warmup and checkpointing, held-out evaluation with perplexity and task metrics, and adapter merge plus quantization for serving. A minimal working example loads Llama-3-8B, configures LoraConfig with rank 16 and target_modules q_proj and v_proj, formats Alpaca-style JSONL prompts, trains with cosine scheduler and eval_steps, and saves adapter weights separately before merge_and_unload deployment. Constraints require validating data quality first, using PEFT for models above 7B parameters, monitoring validation loss for overfitting, versioning datasets and checkpoints, and never deploying without held-out evaluation and latency benchmarks. Output templates include dataset preparation scripts, full TrainingArguments blocks, evaluation scripts, and design rationale for rank and learning rate choices.3.1kinstalls57Mcp Developermcp-developer is an agent skill for Model Context Protocol server and client implementation in TypeScript or Python. The workflow covers requirement analysis, project scaffolding with create-server or pip install mcp, protocol design for resource URIs and tool schemas, handler implementation, interactive testing with the MCP inspector, and deployment with auth and rate limiting. Reference files cover JSON-RPC 2.0 protocol rules, TypeScript and Python SDK usage, tool definitions, and resource providers. Minimal examples register Zod or Pydantic validated tools such as get_weather and config resources over stdio transport. Constraints require correct JSON-RPC 2.0 behavior, schema validation on every tool input, proper transport selection, structured error responses, authentication, logging, and rate limiting before production. Developers reach for it when scaffolding MCP integrations, debugging protocol compliance, or extending tool and resource handlers for AI clients.3kinstalls58Legacy ModernizerLegacy Modernizer is a Jeffallan agent skill for incremental legacy system modernization without big-bang rewrites. The five-step workflow assesses dependencies and risks with documented external integrations, plans phased migration with rollback triggers and owners, builds an 80 percent characterization test safety net that passes green on unmodified legacy code, migrates incrementally via strangler fig facades and feature flags with gradual traffic shifts at 5, 25, 50, and 100 percent, and validates monitoring before retiring legacy paths after one stable release cycle at full traffic. Code examples include OrderServiceFacade routing between legacy and new services, flag_enabled environment wrappers, and pytest golden-master characterization tests. Constraints forbid big-bang replacements, skipping legacy behavior tests, deploying without rollback, breaking integrations, or removing legacy code before new paths are proven. Output templates deliver assessment summaries, migration plans, facade and adapter code, test coverage, and monitoring setup. Reference files cover strangler fig pattern, branch by abstraction, migration strategies, legacy testing, and system assessment templa.3kinstalls59The Foolthe-fool is a workflow skill (version 1.0.0) that plays strategic devil's advocate on ideas, plans, decisions, and proposals using structured critical reasoning. Developers invoke the-fool with triggers like "stress test", "poke holes", "red team", or "pre-mortem" when a design or feature plan needs adversarial review before coding starts. The skill outputs a structured report that audits evidence, surfaces failure modes, and challenges unstated assumptions without blocking productive skepticism. the-fool pairs naturally with architecture-designer, code-reviewer, and feature-forge for multi-angle validation. Use it when a plan feels too smooth and you want structured pushback before sprint commitment.3kinstalls60Django Expertdjango-expert is a jeffallan/claude-skills guide for Django and Django REST Framework backend patterns with production-ready authentication and authorization. It documents SimpleJWT setup in settings.py and urls.py with 15-minute access tokens, 7-day refresh tokens, rotation, and blacklist-after-rotation enabled. REST_FRAMEWORK defaults to JWTAuthentication via rest_framework_simplejwt. The skill extends to custom JWT claims and object-level permissions so agents follow established DRF structure instead of inventing layouts. Developers reach for django-expert when building or securing Django APIs with token auth and fine-grained access control.3kinstalls61Spec Minerspec-miner is a repository analysis skill that walks a structured checklist across eight codebase areas—entry points, routes, models, auth, validation, error handling, external calls, and config—using concrete glob and grep patterns like `**/main.{ts,js,py}`, `**/routes/**/*`, and `**/auth/**/*`. Developers invoke spec-miner when joining a legacy service or auditing an unknown monorepo before refactoring or shipping features. The skill turns raw file trees into an actionable spec map that highlights controllers, DTOs, JWT guards, and test locations. spec-miner reduces blind edits by surfacing architecture boundaries first, so subsequent feature work targets the right modules.3kinstalls62Vue Expert Jsvue-expert-js is an agent skill for Vue 3 projects that use JavaScript and JSDoc instead of TypeScript. The core workflow designs component architecture, implements with script setup without lang ts, annotates public APIs using typedef param and returns comments, then tests with Vitest while enforcing JSDoc coverage through eslint-plugin-jsdoc. Reference guides cover JSDoc typing, composable patterns, component architecture, Pinia state management, and testing patterns, with shared Vue concepts deferred to vue-expert references for composition API, components, and stores. Documented patterns include JSDoc-typed defineProps and defineEmits in SFCs, composables such as useCounter exported from .mjs modules, and shared typedef objects in types/user.mjs imported across files. Constraints require Composition API script setup, JSDoc on every public function, .mjs for ES modules when needed, and forbid TypeScript syntax, .ts extensions, CommonJS require in Vue files, or mixing TS and JS in one component. Developers reach for it when building Vue 3 apps without TypeScript, migrating Options API projects to Composition API in JS, or prototyping quickly while keeping type hints via JSDoc.3kinstalls63Graphql ArchitectGraphQL Architect is a senior schema-design skill for distributed graph architectures covering Apollo Federation 2.5 plus, subscriptions, and performance optimization. The six-step workflow maps business domains to types, designs schema with federation directives, validates composition including key entity resolution, implements DataLoader-backed resolvers, secures with depth and complexity limits plus field-level auth, and tunes caching with persisted queries and monitoring. Constraints require schema-first design, nullable field patterns, DataLoader batching, documented types, camelCase naming, and example queries for every operation while forbidding N+1 queries, skipped depth limits, REST patterns in GraphQL, null on non-nullable fields, and hardcoded authorization. Federation examples show Product key fields across products and reviews subgraphs with external and shareable directives. Resolver examples instantiate per-request DataLoader maps in context to batch user lookups and preserve key order. Reference files load on demand for schema design, resolvers, federation, subscriptions, security, and REST migration topics. Related skills include api-designer, microservices-archit.2.9kinstalls64Chaos Engineerchaos-engineer is an agent skill for designing chaos experiments, failure injection frameworks, and game day exercises on distributed systems. The five-step workflow maps architecture and failure modes, designs hypotheses with steady state and blast radius caps, executes controlled experiments with monitoring, documents learnings, and automates chaos in CI/CD. Reference files cover experiment-design.md, infrastructure chaos, kubernetes chaos with Litmus and Chaos Mesh, chaos-tools.md, and game-days.md. Safety checklist mandates steady state verification first, smallest blast radius, automated rollback within thirty seconds, single-variable experiments, production safety nets, and written learning summaries with tracked improvements. Concrete Litmus ChaosEngine examples delete pods with TOTAL_CHAOS_DURATION sixty seconds and PODS_AFFECTED_PERC thirty-three percent caps. Network latency examples use toxiproxy to inject three hundred millisecond latency with ten percent jitter on a single downstream proxy. Output templates include experiment design documents, injection manifests, monitoring setup, rollback procedures, and improvement recommendations. SRE teams reach for it when valid.2.9kinstalls65Ml Pipelineml-pipeline is a Jeffallan/claude-skills expert skill for implementing production machine learning infrastructure and automated training workflows. Its six-step core workflow maps data flow architecture, validates schemas before training, builds feature engineering pipelines and Feast feature stores, orchestrates distributed training with hyperparameter tuning, logs experiments to MLflow or Weights and Biases, and enforces model evaluation gates before deployment. Reference guides load on demand for feature engineering, training pipelines, experiment tracking, Kubeflow or Airflow orchestration, and model validation with A/B or shadow deployment. Embedded templates include MLflow parameter and metric logging with sklearn model registration, Kubeflow v2 pipeline components with typed Dataset and Model outputs, and Great Expectations style validation checkpoints that halt on schema failures. Constraints require explicit versioning of data, code, and models via DVC or registry tags, pinned dependencies and random seeds, secrets in managers not code, and separation of training versus inference paths. Developers invoke it when building Kubeflow DAGs, Airflow workflows, MLflow tracking,.2.8kinstalls66Spark EngineerSpark Engineer is a senior Apache Spark agent skill for high-performance distributed data processing and production ETL pipelines. The core workflow analyzes requirements, designs DataFrame pipelines with partitioning and broadcast opportunities, implements optimized transformations with caching discipline, tunes shuffle partitions and skew, and validates results against Spark UI metrics. It mandates DataFrame API over RDD for structured data, explicit schemas in production, broadcast joins for small dimension tables under 200 MB, and salting strategies for skewed keys. Code examples cover PySpark quick-start pipelines, broadcast joins, skew salting, and correct cache-unpersist patterns. Constraints forbid collect on large datasets, schema inference in production, unnecessary UDFs, and ignoring shuffle spill warnings. Output templates include complete Spark code, configuration recommendations, partitioning strategy, performance analysis, and monitoring guidance. Developers invoke it when writing Spark jobs, debugging performance issues, configuring cluster settings, processing parquet files, or building structured streaming analytics.2.8kinstalls