CaddyStats

Build agentic applications with GitHub Copilot SDK. Use when embedding AI agents in apps, creating custom tools, implementing streaming responses, managing sessions, connecting to MCP servers, or creating custom agents. Triggers on Copilot SDK, GitHub SDK, agentic app, embed Copilot, programmable agent, MCP server, custom agent.

Build and run evaluators for AI/LLM applications using Phoenix.

OpenInference semantic conventions and instrumentation for Phoenix AI observability. Use when implementing LLM tracing, creating custom spans, or deploying to production.

Scaffold a complete Power Apps Code App project with PAC CLI setup, SDK integration, and connector configuration

Provides exact patterns for diagnosing and fixing automatic batching regressions in React 18 class components. Use this skill whenever a class component has multiple setState calls in an async method, inside setTimeout, inside a Promise .then() or .catch(), or in a native event handler. Use it before writing any flushSync call - the decision tree here prevents unnecessary flushSync overuse. Also use this skill when fixing test failures caused by intermediate state assertions that break after React 18 upgrade.

Provides exact Enzyme → React Testing Library migration patterns for React 18 upgrades. Use this skill whenever Enzyme tests need to be rewritten - shallow, mount, wrapper.find(), wrapper.simulate(), wrapper.prop(), wrapper.state(), wrapper.instance(), Enzyme configure/Adapter calls, or any test file that imports from enzyme. This skill covers the full API mapping and the philosophy shift from implementation testing to behavior testing. Always read this skill before rewriting Enzyme tests - do not translate Enzyme APIs 1:1, that produces brittle RTL tests.

Provides the complete migration pattern for React legacy context API (contextTypes, childContextTypes, getChildContext) to the modern createContext API. Use this skill whenever migrating legacy context in class components - this is always a cross-file migration requiring the provider AND all consumers to be updated together. Use it before touching any contextTypes or childContextTypes code, because migrating only the provider without the consumers (or vice versa) will cause a runtime failure. Always read this skill before writing any context migration - the cross-file coordination steps here prevent the most common context migration bugs.

Provides exact before/after migration patterns for the three unsafe class component lifecycle methods - componentWillMount, componentWillReceiveProps, and componentWillUpdate - targeting React 18.3.1. Use this skill whenever a class component needs its lifecycle methods migrated, when deciding between getDerivedStateFromProps vs componentDidUpdate, when adding getSnapshotBeforeUpdate, or when fixing React 18 UNSAFE_ lifecycle warnings. Always use this skill before writing any lifecycle migration code - do not guess the pattern from memory, the decision trees here prevent the most common migration mistakes.

Preserve React 18 concurrent patterns and adopt React 19 APIs (useTransition, useDeferredValue, Suspense, use(), useOptimistic, Actions) during migration.

Writes CSS keyframe animations, transitions, and JavaScript-driven motion effects from natural language descriptions. Use this skill whenever a user says "animate this element", "write a CSS animation for...", "make this fade in", "add a slide transition", "create a loading spinner animation", "animate on scroll", "write a Framer Motion animation", or "how do I make this bounce/pulse/spin?". Also activate when someone describes a UI interaction that should feel smooth or delightful. Supports CSS animations, CSS transitions, Web Animations API, and Framer Motion. Do NOT use for complex 3D animations (Three.js/WebGL), game animations, or SVG path morphing.

Scaffolds API client code from an OpenAPI/Swagger spec, a list of endpoints, or a description of an API. Generates typed client functions, error handling, retry logic, and authentication setup. Use this skill whenever a user says "write an API client for this", "scaffold a client from this OpenAPI spec", "generate API wrapper functions", "help me integrate with this API", "write the fetch calls for these endpoints", "create an SDK wrapper", or "give me typed API functions for this service". Also activate when a user shares an API spec or endpoint list and needs code to call it. Supports Python, TypeScript, and JavaScript. Do NOT use for designing new APIs (use api-design-skill) or writing backend route handlers.

Designs and scaffolds background job, queue worker, and task scheduling patterns: job definitions, queue configuration, retry policies, dead-letter handling, and monitoring hooks. Use this skill whenever a user says "add a background job for...", "process this asynchronously", "schedule this task", "write a queue worker", "set up a job queue", "add retry logic for this operation", "process emails in the background", "implement a job system", or "how do I run this without blocking the request". Also activate when a user has a slow or unreliable operation that shouldn't block an API response. Supports BullMQ/Node, Celery/Python, and Go goroutine patterns. Do NOT use for real-time event streaming (use Kafka/event-sourcing patterns) or scheduled cron infrastructure setup.

Recommends and implements caching strategies for APIs, databases, and frontend assets: cache layers, TTLs, cache invalidation patterns, and Redis/in-memory implementation code. Use this skill whenever a user says "add caching to this", "my API is too slow — should I cache?", "implement Redis caching", "what's the right TTL for this?", "how do I cache this database query?", "add HTTP caching headers", "implement a cache-aside pattern", or "optimize performance with caching". Also activate when someone has a slow endpoint or repeated expensive query. Supports Redis, in-memory (Node, Python), and HTTP cache headers. Do NOT use for CDN configuration (infrastructure-level) or browser service worker caching (different skill scope).

Scaffolds command-line interface (CLI) tools with subcommands, flags, help text, input validation, and colored output. Use this skill whenever a user says "build a CLI for...", "create a command-line tool that...", "write a CLI with subcommands", "scaffold a Node CLI", "make a Python CLI with argparse or Click", "write a Go CLI tool", or "create a dev tool I can run from the terminal". Also activate when someone describes a workflow they run manually and wants it wrapped in a nice CLI. Supports Node.js (Commander.js / Yargs), Python (Click / argparse), and Go (cobra). Do NOT use for shell scripts (use python-script-generator instead) or full TUI (terminal UI) applications.

Creates CSS and Tailwind layout solutions for described UI patterns: grids, flex containers, sidebar layouts, card grids, sticky headers, centered content, and full-bleed sections. Use this skill whenever a user says "create a CSS layout for", "help me center this", "write CSS for a sidebar layout", "make a responsive grid", "how do I do a sticky header with scrollable content", "layout this page with CSS", "write Tailwind classes for this layout", or "fix my flexbox/grid layout". Also activate when someone shares a layout description or rough wireframe sketch. Supports plain CSS, CSS Grid, Flexbox, and Tailwind CSS v3/v4. Do NOT use for component-level styling (use react-component-generator) or animation (use animation-snippet-writer).

Adds dark mode and theme switching to existing UI codebases: defines dark-mode color tokens, writes CSS custom property overrides, implements a theme toggle component, and respects system preference. Use this skill whenever a user says "add dark mode to my app", "implement theme switching", "add a light/dark toggle", "make my app respect prefers-color-scheme", "write dark mode CSS", "implement a dark theme for this component", or "how do I add dark mode to my React app". Also activate when someone asks how to persist a user's theme preference. Works with plain CSS, Tailwind CSS, and React. Do NOT use for generating the color palette itself (use color-palette-generator first) or for generating full design system tokens.

Exports design system tokens (colors, spacing, typography, shadows, radii) to CSS custom properties, JavaScript/TypeScript constants, Figma tokens (W3C format), or Tailwind config extensions. Use this skill whenever a user says "export my design tokens", "convert these tokens to CSS variables", "generate a Tailwind config from my tokens", "create a JS tokens file", "write design tokens for my design system", "export tokens from Figma format", or "sync my design and code tokens". Also activate when someone wants to centralize colors, spacing, or typography across design and code. Do NOT use for generating the colors or spacing values themselves (use color-palette-generator first).

Writes consistent, production-ready error handling patterns for a given language and framework: custom error classes, try/catch blocks, centralized error middleware, and structured error responses. Use this skill whenever a user says "write error handling for this", "add try/catch here", "create a custom error class", "how should I handle errors in this API?", "write an error middleware", "standardize my error responses", or "add proper error handling to this function". Also activate when code is missing error handling or has inconsistent error patterns. Supports Node.js/Express, Python/FastAPI, Go, and Java/Spring. Do NOT use for logging infrastructure setup (separate concern) or writing retry logic (use background-job-designer).

Builds HTML and React forms with field validation, error states, loading states, and accessible markup. Use this skill whenever a user says "build a form for...", "create a contact form", "write a registration form", "add validation to this form", "build a multi-step form", "handle form submission", "add form error handling", or "write a form with React Hook Form". Also activate when someone describes a set of fields they need to collect from a user. Works with plain HTML, React + React Hook Form, and React + Zod validation. Do NOT use for backend form processing/storage (use rest-endpoint-generator) or payment forms (Stripe Elements are a different integration).

Set up complete GitHub Copilot configuration for a new project based on technology stack

Writes GraphQL schemas (SDL), resolvers, mutations, subscriptions, and input type definitions. Use this skill whenever a user says "write a GraphQL schema", "add a GraphQL mutation for...", "create a GraphQL type for...", "write a resolver for this query", "scaffold a GraphQL API", "add a subscription to this schema", "define GraphQL input types for...", or "convert my REST API to GraphQL". Also activate when someone describes a data model and wants it expressed as GraphQL types. Works with Apollo Server, graphql-js, and Pothos (code-first). Do NOT use for REST API endpoints (use rest-endpoint-generator) or full schema federation architecture (too complex for one skill).

Scaffolds an SVG icon component system: a reusable Icon wrapper component, a typed icon name union, an icon sprite approach or inline SVG approach, and a usage guide. Use this skill whenever a user says "build an icon component", "create an icon system", "make my SVGs reusable as components", "scaffold an icon library in React", "convert these SVGs to components", "how do I manage icons in my design system?", or "create a typed icon set". Also activate when someone wants to standardize how icons are used across their app. Works with React + TypeScript, Vue 3, or plain Web Components. Do NOT use for creating or sourcing the actual SVG icon artwork (use an icon library like Lucide, Phosphor, or Heroicons as the source).

Implements rate limiting middleware with configurable rules, sliding window or token bucket algorithms, Redis-backed distributed limiting, and response headers. Use this skill whenever a user says "add rate limiting", "protect this endpoint from abuse", "implement a rate limiter", "limit API requests per user", "throttle this endpoint", "add rate limits to my API", "prevent brute force on login", or "implement per-IP and per-user rate limits". Also activate when someone's API is being hammered or abused. Supports Express/Node.js and FastAPI/Python with Redis (distributed) or in-memory (single-server). Do NOT use for CDN-level rate limiting (Cloudflare, AWS WAF — infrastructure scope) or queue throttling (use background-job-designer).

Generates React components with TypeScript props types, hooks, accessibility attributes, and basic test stubs. Use this skill whenever a user says "create a React component for...", "write a React component that...", "build a [name] component in React", "generate a reusable React component", "scaffold a React hook for...", or "add a component to my React app". Also activate when someone describes UI behavior and wants it as a React component. Produces modern functional components with hooks; does not generate class components. Works with React 18+, TypeScript, and either CSS Modules, Tailwind, or styled-components. Do NOT use for full-page layout scaffolding (use css-layout-helper) or state management architecture.

Plans and writes responsive CSS breakpoint strategies for layouts and components: defines breakpoint scales, writes media queries, and adapts components across screen sizes. Use this skill whenever a user says "make this responsive", "add breakpoints to this layout", "how should I handle mobile vs desktop?", "write responsive media queries", "what breakpoints should I use?", "my layout breaks on mobile", "adapt this for tablet", or "plan a mobile-first responsive strategy". Also activate when someone has a desktop layout and wants to adapt it for smaller screens. Covers plain CSS, Tailwind, and CSS-in-JS media queries. Do NOT use for full-page layout generation (use css-layout-helper) or viewport meta tags configuration.

Generates REST API endpoint handlers with input validation, authentication checks, error handling, and OpenAPI documentation stubs. Use this skill whenever a user says "write a REST endpoint for...", "create an API route for...", "generate a CRUD API", "scaffold a POST endpoint", "write a REST handler for this resource", "generate Express routes", "write a FastAPI endpoint", or "build the API layer for this feature". Also activate when someone describes a resource and needs API endpoints to manage it. Supports Express/Node.js, FastAPI/Python, and Go net/http. Do NOT use for GraphQL resolvers (use graphql-schema-writer) or frontend API client code (use api-client-scaffolder).

Generates realistic seed, fixture, and test data for databases and APIs: SQL INSERT statements, JSON fixtures, factory functions, and fake data scripts. Use this skill whenever a user says "generate seed data", "write database fixtures", "create test data for this schema", "fill my database with fake data", "write a data factory", "seed this table with realistic values", "generate fake users/orders/ products", or "create mock data for testing". Also activate when someone needs a populated development database or test fixtures for unit tests. Supports SQL (PostgreSQL, MySQL), JSON fixtures, and TypeScript/Python factory functions with Faker.js / Faker (Python). Do NOT use for production data migration (use data-pipeline-designer) or generating test assertions (use eval-set-builder).

Creates new AI skills, improves existing ones, and measures skill performance through eval-driven iteration. Use when a user wants to build a skill from scratch, rewrite or refine an existing SKILL.md, run test prompts to evaluate skill quality, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. Common phrasings: "create a skill for X", "improve this skill", "run evals on my skill", "why isn't my skill triggering?", "write a SKILL.md for Y", "help me test and iterate on this skill". Do NOT use for general coding tasks, answering questions, or creating non-skill documentation — this skill is specifically for authoring and iterating on SKILL.md files and their associated eval sets.

Create and extend reusable UI components in the DZIRE design system. Use when the user asks to build components like inputs, selects, tooltips, drawers, tabs, or any other primitive UI element.

Builds webhook receiver endpoints with signature verification, idempotency handling, event routing, and retry-safe processing. Use this skill whenever a user says "build a webhook handler", "receive webhooks from Stripe/GitHub/etc.", "write a webhook endpoint", "verify webhook signatures", "handle webhook retries", "process incoming webhooks", or "make my webhook endpoint reliable". Also activate when someone is integrating with a third-party service that sends webhooks and needs a secure receiver endpoint. Supports Node.js/Express, Python/FastAPI, and Go. Do NOT use for sending outbound webhooks to other services (use background-job-designer for outbound delivery with retries).