Skills
99,448 packaged capabilities and playbooks for agents. Install any of them with one command.
Development
Create, edit, push, or version a Coder template. Use for requests like "scaffold a Docker template", "build a Kubernetes template", "add a coder_parameter for the Git repo URL", "push my template to this Coder deployment", "update the existing aws-linux template to add JetBrains", or "deprecate this template version". Do not use for installing or upgrading Coder itself (use the setup skill), adding a single module to a template that already builds (use the modules skill), or authoring custom Terraform providers unrelated to Coder.
Build coupled precipitation and affected surfaces in Three.js. Use for falling snow, snow accumulation, model snow caps, wet asphalt puddles, procedural ripple normals, splash flipbooks, rain streaks, shared weather envelopes, and surface wetness or coverage transitions.
Build coherent procedural scalar and vector fields for Three.js materials and geometry. Use for terrain, planets, wear, biomes, clouds, water masks, displacement, roughness, normals, domain warping, and any visual where several channels must derive from shared causes.
Build large procedural oceans and coast transitions in Three.js. Use for WebGPU/TSL FFT oceans, multi-cascade wavelength bands, coastal breakers, finite-volume shallow-water beach waves, signed-distance coastlines, shallow-water swash films, wet-sand transitions, rock-impact spray, stylized above/below surface optics, permanently submerged Snell-window views, total internal reflection, forward-refracted structures through an interface, pixel-footprint spectral LOD, aquatic perspective, caustic god rays, choppy displacement, spectral derivatives, Jacobian whitecaps, windrow and temporal foam, analytic sky reflection, underwater absorption, crest scatter, and GPU validation.
Run and manage long-lived background commands using tmux sessions instead of background processes. Use when starting backend/API servers, Expo/React Native dev servers, job workers, watchers, or any task that should keep running while other commands are executed.
Use whenever writing, editing, refactoring, or reviewing TypeScript or TSX code. This skill defines how TypeScript should be modeled, how boundaries and shared helpers should be handled, how intent should be expressed without code comments, and how to keep code clear, DRY, and free of defensive AI slop. For review workflows, read references/review-and-fix-changes.md.
Use when building, porting, or refactoring a Vue 3 feature that spans multiple components and layers: a page/view plus presentational components, composables, data access, a router route and shared utilities. Covers the view-orchestrates / components-present split, feature folders with a barrel (index.ts), data loading in composables, resetting shared state, router wiring and the build sequence. Triggers on building a new screen/view/feature, splitting a large `.vue` into smaller components, adding a data model/service, and wiring a router route. Single component's internals: `code-style`; Flux UI library: `flux-ui`.
A focused development workflow engine for AI coding agents, invoked as `/absolute <command> [target]`. One skill, eleven commands. One sets it up: `init` (interview how you want absolute to behave + detect the stack once, then write JSON config — `.absolute.config.json` per project and `~/.absolute/config.json` for user defaults and per-project overrides — that every other command reads instead of re-detecting; non-blocking, the others soft-recommend it). Five cover the build loop you run every day — think → spec → plan → build → polish → document: `work` (end-to-end, phase-gated SDLC: relentless design interview → reviewed spec → dependency-graphed task board → safe-wave TDD execution → verification), `spec` (lightweight standalone design spec: codebase scan → bounded clarify pass → write a reviewed design doc to docs/plans → scored reviewer subagent → stop, no build), `ui` (polished, intentional interface design with concrete CSS/Tailwind values — typography, color, layout, dark mode, accessibility, animations), `simplify` (autonomously simplify your working git changes — reduce complexity, remove redundancy, keep tests green), and `docs` (Diátaxis-driven documentation — tutorials, how-tos, reference, explanation, READMEs, ADRs, with stack detection and code-verified accuracy). Five more keep the codebase healthy — standing maintenance on green main, each a risk-ranked, gated, safe-wave scan-and-fix: `upgrade` (dependency upgrades — outdated/vulnerable deps bumped in semver waves, majors gated and changelog-read, tests green after each), `audit` (vulnerability & security scan — dependency CVEs plus risky code patterns, severity-triaged and remediated; defensive, on your own repo), `prune` (dead code & dependency cleanup — unused deps, exports, files removed with evidence, repo-wide), `debt` (lint & typecheck debt paydown — clear pre-existing warnings/errors and suppressions by rule, no cheating the checker), and `deflake` (flaky test fixes — diagnose and fix the root nondeterminism, never retry/skip/sleep). Triggers on "absolute init|work|spec|ui|simplify|docs|upgrade|audit|prune|debt|deflake", "set up absolute", "initialize absolute", "configure absolute", "build this end-to-end", "plan and build", "grill me on this", "write a spec", "draft a design doc", "design this UI", "make this less like AI slop", "simplify this", "clean up my changes", "write docs", "audit our docs", "upgrade our dependencies", "are we vulnerable", "security audit", "remove dead code", "fix our lint/type errors", "fix flaky tests", or any multi-step development, design, cleanup, documentation, or maintenance task.
Write, review, and maintain architecture decision records with clear context, alternatives, consequences, confirmation links, and lifecycle governance. Use when a consequential technical decision or its enforceable architectural constraint must remain understandable. Do not use for system-wide evolutionary architecture design, general observability, or operating a named test or CI tool.
Expert React specialist mastering React 18+ with modern patterns and ecosystem. Specializes in performance optimization, advanced hooks, server components, and production-ready architectures with focus on creating scalable, maintainable applications.
Use when authoring (or amending) a published, consumer-facing API reference — the docs an integrating client developer reads to call an API. Guides the producer through the METHOD, not the outline: deriving every endpoint, field, and error from the upstream api-spec contract (never fabricating one), grounding onboarding + examples in established public-API-docs practice, authoring prose-first yet adapting to OpenAPI-generated catalogs, documenting auth flows, errors, rate-limits, pagination + deprecation, and keeping the reference consistent with the contract — so a developer can authenticate and integrate every operation from the reference alone. Amends an existing reference as an upstream-driven re-sync when the contract changes, with a doc version + amend log. Composes with an api-reference template tool + deep-research. Assumes the upstream api-spec — never a blank page. Not the engineering wire contract (api-spec), not the end-user guide, not reviewing one.
Use when spawning `Camera3d` or `Camera2d`, choosing a `Projection`, rendering to an image with the `RenderTarget` component, adding `Hdr` / `Tonemapping::Linear` / `ScreenSpaceTransmission` to a camera, wiring `FreeCamera`, `PanCamera` or the new `PanOrbitCamera` from `bevy::camera_controller`, ordering views with `Camera::order`, or setting a per-camera `AmbientLight` in Bevy 0.20.
Generate camoufox configuration for the `browse` CLI by INTERVIEW, not hand-edited JSON — an AskUserQuestion-guided flow that turns a chosen preset (stealth, fast-scraping, Google-safe, or a fully custom walkthrough) into a valid `browse.json` camoufox section or a named `.browse/camoufox-profiles/<name>.json`, using camelCase keys, merging without clobbering existing fields, and writing proxy credentials to file only. Use to create or tune an anti-detection browse profile before stealth browsing.
Cavekit specification-driven development methodology — the Hunt lifecycle (Draft → Architect → Build → Inspect → Monitor) and how to apply it. Use when starting a Cavekit project, structuring an existing codebase as kits/plans, or routing between sub-skills.
Detects framework-specific anti-patterns, convention violations, and idiom misuse across PHP/Laravel, React/Next.js, and Python/Django/FastAPI codebases. Loads framework-specific reference guides and checks against framework conventions. Generates severity-scored findings with copy-pasteable fix prompts. Trigger phrases: "framework review", "framework check", "laravel best practices", "react best practices", "framework audit", "framework-specific review".
Audits code for SOLID principle violations — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. Identifies classes and methods that violate these principles and generates fix prompts. Trigger phrases: "SOLID check", "solid review", "SRP violation", "dependency inversion".
Production UI component code in React/TypeScript, SwiftUI, and modern CSS with full state matrices, ARIA attributes, keyboard handling, and design token consumption. Use when building or reviewing a button, modal, form, input, table, or any component that needs all of its states covered.
Build modern, composable, and accessible React UI components following the components.build specification. Use when creating, reviewing, or refactoring component libraries, design systems, or any reusable UI components. Triggers on tasks involving component APIs, composition patterns, accessibility, styling systems, or TypeScript props.
Build full-stack dashboard applications using React/Next.js + shadcn/ui + Tailwind CSS + Recharts + Express with customizable data sources. Use when creating data visualization dashboards, business intelligence interfaces, monitoring systems, KPI displays, analytics platforms, or any project requiring data visualization with modern UI components and dynamic effects.
Authoring, building, validating, and running PostgreSQL database migrations with the @schemavaults/dbh package. Use when a project depends on @schemavaults/dbh and you are creating or editing Kysely migration files, setting up a migrations/ directory, or when the user mentions migrations, up()/down(), schema changes, or the dbh CLI's migrate / build-db-migrations / validate-migration-directory commands.
Build, scaffold, maintain, or restyle DatoCMS plugins built with datocms-plugin-sdk and datocms-react-ui. Use when users ask to create a new DatoCMS plugin project, patch an existing plugin, add or adjust plugin hooks, field extensions, config screens, sidebars, pages, modals, asset sources, dropdown actions, lifecycle hooks, browser CMA flows, plugin permissions, package metadata, dark mode upgrades, testing local plugin changes without affecting the live installation, or UI changes that should match the DatoCMS dashboard. Route standalone CMA scripts to datocms-cma and frontend website integrations to datocms-frontend-integrations.
Use when the user wants to integrate a Kafka client into an existing application or scaffold a Java Kafka client project (Maven or Gradle based) for Confluent Cloud, local Docker, or WarpStream. Covers the Apache Kafka Java clients (KafkaProducer/KafkaConsumer/KafkaShareConsumer) with Avro, JSON Schema, or Protobuf serializers. Also use when the user wants to optimize Java Kafka client configuration for WarpStream. Do NOT trigger for Kafka Streams apps (use kafka-streams-programming), Flink, connectors, or Kafka Python client (use developing-kafka-python-client).
Look up CE.SDK Vanilla JavaScript reference docs, guides, and configuration pages. Use when the user needs CE.SDK docs for Vanilla JavaScript — configuration, UI customization, export options, feature guides, or getting-started instructions. Also triggered by "IMG.LY", "CreativeEditor", "CE.SDK", or "cesdk" when the user needs an existing Vanilla JavaScript doc page. Not for writing code (use build) or concept explanations (use explain). <example> Context: User asks about Vanilla JavaScript configuration user: "How do I configure the editor in Vanilla JavaScript?" assistant: "I'll use /imgly-sdk:docs-js to look up configuration options." </example> <example> Context: User needs vanilla JS setup user: "How do I use CE.SDK without a framework?" assistant: "Let me use /imgly-sdk:docs-js to find the relevant documentation." </example>
Write React-ECS scene UI that the Creator Hub's 2D UI editor (UI Designer) can fully read and edit — file layout, the state/props binding surface, useInteraction style layers, actions, platform variants, and the driver pattern for animation. Use when the user wants UI that is editable in the Creator Hub, wants to generate UI for the UI Designer, or wants to adapt an existing coded UI so it opens in the editor. For coded UI with no editor requirement, use build-ui.
Set up a full AI ensemble/mob programming team for any software project. Creates agent definition files (.claude/agents/), coordinator instructions (.team/coordinator-instructions.md), project owner constraints (PROJECT.md), team conventions (AGENTS.md), architectural decisions (docs/ARCHITECTURE.md), domain glossary, and supporting docs. Use when: (1) starting a new project and wanting a full expert agent team, (2) the user asks to "set up a team", "create a mob team", "set up ensemble programming", or "create agent profiles", (3) converting an existing project to the driver-reviewer mob model, (4) the user wants AI agents to work as a coordinated product team with retrospectives and consensus-based decisions.
Retrieves up-to-date documentation, API references, and code examples for any developer technology. Use this skill whenever the user asks about a specific library, framework, SDK, CLI tool, or cloud service — even for well-known ones like React, Next.js, Prisma, Express, Tailwind, Django, or Spring Boot. Your training data may not reflect recent API changes or version updates. Always use for: API syntax questions, configuration options, version migration issues, "how do I" questions mentioning a library name, debugging that involves library-specific behavior, setup instructions, and CLI tool usage. Use even when you think you know the answer — do not rely on training data for API details, signatures, or configuration options as they are frequently outdated. Always verify against current docs. Prefer this over web search for library documentation and API details.
A tool for managing GitHub Star projects, tracking recent activity and updates, discovering project opportunities in saved items that may be valuable for local skills, and generating evidence packs and daily candidate queues. Also supports automatic starring of content and a dashboard. Not for one-off deep research into an unfamiliar repository.
Use when the project follows hexagonal (ports & adapters) architecture. Prevents domain code from depending on Spring or JPA. Use when you see packages like domain/, application/, infrastructure/, or adapters/ in the project structure.
Takes an app from hardcoded strings to a localized, continuously translated one with i18next (Locize optional): stack detection, config, wrapping strings in t(), key extraction, Locize sync, and AI translation. Use when the user asks to add or set up i18n, internationalization, localization, translations, or multi-language support, including phrasings like "add i18n", "internationalize my app", "make my app multilingual", "make my app translatable", "localize my app", "find hardcoded strings", "wrap my strings", and library-specific ones like "set up i18next", "add react-i18next", "use next-i18next". Also use when the user names languages they want to support ("I want German and French", "support more languages"), when an app already has i18next but strings are still hardcoded, or when translations need to move to a managed backend. Do not use for translating or reviewing strings in a project whose i18n is already set up.
A collection of Java development manual conventions, based on the Alibaba Java Development Manual (Songshan edition). Covers 7 dimensions: programming conventions, exception logging, unit testing, security conventions, MySQL databases, engineering structure, and design conventions. Use this skill when users need to: (1) write or review Java code (2) check naming/code conventions (3) handle exceptions and logging (4) write unit tests (5) do secure coding (6) design databases (7) design engineering architecture. Trigger words: Java conventions, Alibaba conventions, code conventions, development manual, programming conventions, exception handling, unit testing, security, MySQL, engineering structure, design patterns.
Use when starting, executing, or finishing non-trivial implementation tasks where reusable constraints may matter. Recall relevant lessons before work, capture reusable corrections or discoveries during and after work, and keep project memory in `docs/lessons/`.
Use when creating, integrating, reviewing, or debugging a Make App's default Trace ID chain, traceparent and X-Log-Id propagation, safe correlated logs, or @qfei-design/make-app-observability error notices. Every new Make App includes this baseline even when the user does not mention observability. Covers direct-gateway and Service-fronted Apps and AI transports when present. Does not own authentication, Service route design, AI protocol, tracing backend/exporter deployment, runtime packaging, or page layout.
Convert Markdown files to HTML similar to `marked.js`, `pandoc`, `gomarkdown/markdown`, or similar tools; or write custom scripts to convert markdown to html and/or work on web template systems like `jekyll/jekyll`, `gohugoio/hugo`, or similar web templating systems that use markdown documents and convert them to html. Use when asked to "convert markdown to html", "transform md to html", "render markdown", "generate html from markdown", or when working with .md files and/or a web templating system that converts markdown to HTML output. Supports CLI and Node.js workflows with GFM, CommonMark, and standard Markdown flavors.
Use when setting up or repairing Meteor application declarations, TypeScript configuration, JavaScript IntelliSense, or local and CI type-checking. Triggers on meteor types, meteor/* imports resolving to any, missing declarations, duplicate Meteor identifiers, zodern:types, @types/meteor, .meteor/types, tsconfig.json, jsconfig.json, and tsc --noEmit in a Meteor app. Use this skill when choosing or migrating declaration providers without changing the app's runtime or bundler. For a Meteor 2-to-3 runtime migration use migrate-to-meteor-3 first; for SWC/Rspack compilation use meteor-modern-build-stack or migrate-to-rspack. General TypeScript language questions and Atmosphere declaration publishing are outside this app scope.
Integrate Module Federation into an existing project — add provider (exposes modules) or consumer (loads remote modules) configuration. Use when the user wants to add Module Federation to an existing Rsbuild / Rspack / Webpack / Modern.js / Next.js / Vite project, set up a remote, create a host app, or quickly consume the demo provider to see MF working. Default role is consumer.
Write modern, version-aware C# for .NET repositories while staying compatible with the repo's target framework and language-version policy. USE FOR: modern idiomatic C# code; language-version compatibility decisions; upgrading or reviewing C# feature usage across versions. DO NOT USE FOR: non-C# .NET languages such as F# or VB; analyzer-only or formatter-only setup with no language feature choice. INVOKES: inspect the repository context, edit targeted files, and run relevant build, test, lint, or validation commands when changes are made.
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.