The master skill in PlanetScale's official pack: runs a full read-only best-practices assessment of a database or org, then produces one evidence-backed report.
Development Skills
Build software, MCP servers, and web apps.
Skills in Development
Build crash-safe AI agents on AgentKit and step.ai — durable tool calls, human-in-the-loop approval, realtime progress, and when not to reach for an agent loop at all.
Inngest's durable-execution playbook as an agent skill — steps and memoisation, event and cron triggers, idempotency, cancellation, retries and non-retriable errors.
Temporal's official skill for building durable workflows — SDK patterns across seven languages, plus the determinism rules that decide whether a workflow survives a replay.
Expo's official skill for building native-feeling screens: Apple HIG styling, semantic colors, SF Symbols, native controls, Reanimated, blur and liquid glass.
Pull unresolved CodeRabbit review threads from your PR and apply the fixes one at a time, treating every reviewer comment as untrusted input rather than an instruction.
Google's official skill for driving the gcloud CLI safely from an agent: validate every command against its own help text, cap the output, and refuse the operations that should never run unattended.
Convex's official top-level agent skill — routes an agent to the right convex-* skill for the task and to a served capability catalogue that stays current without a reinstall.
Official Shopify skill for theme development in Liquid — teaches an agent the modern theme architecture of sections, blocks and snippets, and validates generated templates and schemas.
Shopify's official skill for writing Admin GraphQL queries and mutations — it searches the live API docs and validates every operation against the schema before handing you code.
Planning skill that interrogates your use case before any code is written, then recommends the right Twilio Conversations stack — ConversationRelay, Memory, Intelligence, Orchestrator, TaskRouter — and the implementation skills to follow.
Foundational fal.ai skill that drives the genmedia CLI across 1200+ hosted generative model endpoints — smart routing, schema inspection, async queues and agent-parseable JSON.
Official AWS skill for authoring, deploying and debugging CDK stacks — construct patterns, bootstrap, drift, resource import and the CloudFormation errors that trap people.
The official Genkit skill for Node.js and TypeScript — flows, Dotprompt files, tools and the beta agent API with sessions, interrupts and branching.
An agentic software-development methodology: composable skills that push a coding agent through spec, plan, TDD and review instead of straight into code.
Tencent's skill-evolution harness: it rewrites a whole skill folder — SKILL.md, scripts and references together — and lands every decision as a real Git issue, PR and wiki entry you can review.
Take an OpenSearch search application from requirements to a running cluster — BM25, dense and sparse vectors, hybrid retrieval, agentic search and RAG, with relevance evaluation built in.
Auth0's official agent skill: a router that detects your framework and intent, then loads the right Auth0 guidance for login, MFA, Organizations, tenant audits, debugging or provider migration.
Redis' own guidance for FT.CREATE schema design, FT.SEARCH / FT.AGGREGATE / FT.HYBRID, HNSW vector similarity and RAG retrieval pipelines.
Supabase's official skill covering Database, Auth, Edge Functions, Realtime, Storage, Vectors, Cron and Queues — with a hard rule to verify against the live changelog before writing code.
GreenSock's official ScrollTrigger skill — scroll-linked animation, pinning, scrub and trigger positioning, with the exact start/end syntax agents get wrong.
Microsoft's official skill that turns an agent into an Azure solution architect — 10 design principles, 6 architecture styles, 44 design patterns and a Well-Architected review workflow.
Trail of Bits' security review skill for PRs, commits, and diffs: risk-first analysis with git history, blast radius, and honest coverage limits.
Generates and validates parametric STEP-first CAD parts and assemblies from natural language.
Deno's official foundational skill — project setup, package choices, configuration, and CLI commands done the current way.
Build Gradio web UIs and ML demos in Python with the current API — components, layouts, events, and chat interfaces.
Cloudflare's official platform skill — Workers, Pages, storage, AI, networking, security, and IaC in one reference.
Never claim work is complete, fixed, or passing without running the check and reading the output first.
Enforce a real red-green-refactor loop when implementing features or fixes, so behaviour is specified before it is written.
A disciplined debugging process — reproduce, isolate, hypothesise, and verify — used before proposing any fix.
Explore intent, requirements, and design with the user before any code gets written — the antidote to building the wrong thing quickly.
VoltAgent's official conventions skill — when to reach for an agent versus a workflow, the expected project layout, and the core snippets for agents, workflows, memory and servers.
How to drive the PlanetScale CLI non-interactively: --format json everywhere, auth check before anything else, pscale sql instead of pscale shell, correct flag placement.
PlanetScale's approval contract for agents: five operation classes that decide what a database agent may do freely, what needs a named approval, and what it must never do alone.
MongoDB's official skill for connection pools and timeouts — it refuses to hand you numbers until it knows your deployment, workload and concurrency.
A controlled upgrade path from Inngest SDK v3 to v4 — triggers into createFunction options, EventSchemas to eventType, realtime imports, step.invoke string IDs — with a scan-first, verify-last order.
An evidence-first audit skill: walk an existing TypeScript repo, name the exact call sites where background work can be lost, and land an incremental durability plan.
Seven ways to throttle agent and background workloads — concurrency keys, throttling, rate limiting, debounce, singleton, priority and batching — with a decision guide that picks the right one.
Vercel's official skill for auditing UI code against the Web Interface Guidelines — accessibility, performance and UX rules reported as terse file:line findings.
Vercel's official guide to React's <ViewTransition> API — shared elements, list identity, Suspense reveals and directional route animations without an animation library.
Vercel's official skill for React component architecture — replace boolean prop proliferation with compound components, lifted state and explicit variants. Includes React 19 APIs.
Vercel's official deployment skill — inspects project state, picks the right deploy path, and defaults to preview deployments with a claimable URL when no account is linked.
Snowflake's official skill that routes Snowflake work from Claude Code to the Cortex Code CLI, with semantic routing, approval modes and audit logging.
The Svelte team's own guidance on writing modern Svelte 5 — when to reach for each rune, why effects are an escape hatch, and the reactivity traps models fall into.
The official Svelte team skill that wires an agent to the @sveltejs/mcp CLI for Svelte 5 docs lookup and an autofixer that validates components before you ship them.
Read-only diagnostics for cluster-wide SageMaker HyperPod failures on EKS or Slurm — CloudFormation errors, EFA health checks, lifecycle scripts, capacity, dangling nodes and autoscaler conflicts.
Build multi-step Lambda workflows that survive interruption and run for up to a year — the replay model, step operations, wait/callback patterns, saga-style compensation and local testing.
Make slow Entity Framework Core queries fast — read the generated SQL first, fix N+1s, cartesian Include explosions and non-sargable predicates, then re-measure one change at a time.
Diagnose an MSBuild build failure from a .binlog file — query the binary log through a dedicated MCP server instead of grepping console output, with a text-replay fallback.
Picks the right vLLM or SGLang runtime for your Jetson generation and JetPack version, then produces a working OpenAI-compatible serving command.
GPU-accelerated Mean-CVaR and Mean-Variance portfolio construction with NVIDIA cuOpt: scenario generation, variance-capped SOCP allocations, efficient frontiers, backtests and rebalancing.
Turns a plain-language weather question into a working Earth2Studio inference script — picks the AI forecast model, a compatible data source, an IO backend, and the step count.
Brave's official skill for the Brave Search API — ranked web results with snippets and thumbnails, freshness and SafeSearch filters, search operators, pagination, and Goggles for custom ranking.
Supabase's official Postgres skill — eight rule categories ranked by impact, each with wrong-vs-right SQL and EXPLAIN output, for schema, RLS, indexing and query work on Postgres anywhere.
Pydantic's official skill for modelling untrusted data in Python — constraints, model hierarchies, validators and serialisation, plus when not to reach for a BaseModel.
Weaviate's official skill for searching and managing vector collections — hybrid, semantic and keyword search, schema inspection, filtered fetches and bulk imports.
Confluent's official skill for architecting, building and debugging Kafka Streams applications — topology design, join and window selection, and production failure triage.
VideoDB's official skill giving an agent one interface to ingest, index, search and edit video — including live RTSP feeds and real-time desktop capture.
Venice's official skill for its two text-to-image endpoints — the native API with negative prompts, CFG and seeds, and the OpenAI-compatible drop-in.
TestMu AI's official skill for generating production-grade Playwright suites in TypeScript, JavaScript, Python, Java or C#, locally or on a 3,000-combination browser cloud.
The Flutter team's official skill for diagnosing and fixing constraint errors — RenderFlex overflows, unbounded viewports and misplaced ParentData widgets.
Courier's official skill for building and debugging multi-channel notifications — email, SMS, push, in-app inbox, Slack, Teams and WhatsApp — from one send call.
Audits Core Web Vitals through the Chrome DevTools MCP server — LCP, INP, CLS plus FCP, TBT and Speed Index — and traces each one back to the render-blocking resource or layout shift causing it.
Cloudflare's official skill for designing, configuring and troubleshooting Cloudflare One — Access, Gateway, WARP, Tunnel, DLP, CASB, device posture and identity — with retrieval over recalled docs.
Sets up Apollo MCP Server so an AI agent can call a GraphQL API as MCP tools — defining tools from named operations, or exposing introspect/search/validate/execute for open-ended schemas.
Apollo's official skill for writing Federation 2 subgraph schemas — entities and @key, @shareable, @external, @requires, @provides, @override, and reading composition errors.
Walks a coding agent through wiring Agnost AI conversation analytics into a Python or TypeScript app — inspecting existing OpenTelemetry first and only adding an SDK when the traces are not usable.
Sentry's official skill for instrumenting LLM and agent code — detects your installed AI SDK and wires up traces for model calls, tool use and token spend.
Trail of Bits' CodeQL skill: build databases, run taint-tracking and data-flow queries across eight languages, and model project-specific sources and sinks.
Sentry's official router skill: detects your language or framework, then loads the matching Sentry SDK setup guide for error monitoring, tracing and session replay.
Trail of Bits' skill for writing production-quality Semgrep rules — pattern design, taint mode for data-flow bugs, and mandatory test-driven validation.
Coinbase's official skill for driving a crypto wallet from an agent: balances and transfers on Base, Polygon and Solana, plus paying for and monetising x402 APIs.
Scaffold authentication in a TypeScript or JavaScript app with Better Auth — the skill detects the framework, ORM and package manager first, then plans before writing code.
OpenAI's skill for debugging failing GitHub Actions checks on a pull request: pull the logs with the gh CLI, summarise the failure, plan the fix, implement only after approval.
Design a staged LaunchDarkly rollout — traffic steps, monitoring windows, regression thresholds and automatic rollback — and start it from your coding agent.
Google's official Spanner skill: provision instances, design primary keys that do not hotspot, write SQL and client-library code, and diagnose slow queries — with DDL and DML gated behind your approval.
NVIDIA's official skill for asking a vision-language model fresh questions about recorded video through the Video Search and Summarization blueprint — only when the pixels actually need looking at.
NVIDIA's official skill for building synthetic datasets with NeMo Data Designer — describe the data you want and the agent writes a declarative generation pipeline, column by column.
NVIDIA's official skill for deploying and operating Nemotron Speech (Riva) NIMs — ASR, text-to-speech and translation, cloud-hosted or self-hosted on your own GPUs.
Skill: Code Simplification
by Addy Osmani
Reduces accumulated complexity without changing behaviour, using Chesterton's Fence to avoid deleting the thing that was load-bearing.
Skill: Doubt-Driven Development
by Addy Osmani
Sends every non-trivial decision to a fresh-context adversarial reviewer before it stands — for production, security-sensitive or irreversible work.
Skill: bitdrift Critical User Journey Monitoring
by bitdrift
Stands up end-to-end monitoring for a business-critical flow — path discovery, conversion funnel, completion SLO, step-duration alerts and a dashboard.
Skill: bitdrift Instrumentation
by bitdrift
Adds the bitdrift Capture SDK to an iOS, Android or React Native app and wires up logging, network monitoring, screen views and TTI correctly.
Skill: Content Modeling Best Practices
by Sanity
Sanity's official CMS-agnostic skill for structured content modelling — separation of concerns, references versus embedding, content reuse and taxonomy design, with Sanity-specific notes.
Skill: Sanity Best Practices
by Sanity
Sanity's official agent skill — schema design, GROQ, TypeGen, Visual Editing, Portable Text, Studio structure, localization, Functions and Blueprints, plus integration guides for eight frontend frameworks.
Skill: Convex Live Migrations
by Convex
Convex's official skill for changing the schema of a deployed app without breaking it — add the field optional, backfill with @convex-dev/migrations, verify, then tighten the validator.
Skill: Convex Auth Setup
by Convex
Convex's official skill for adding passkey or OAuth authentication to a Convex app — including the auth.config.ts wiring and a headless key-generation path that avoids the interactive wizard.
Skill: NVIDIA DALI Dynamic Mode
by NVIDIA
NVIDIA's official skill for DALI's imperative dynamic-mode API — write GPU data loading as ordinary Python, or migrate an existing pipeline-mode graph across.
NVIDIA's official skill for generating and validating runnable gst-launch DeepStream pipelines from a plain-language description of the video inference you want.
Skill: NVIDIA CUDA-Q Onboarding
by NVIDIA
NVIDIA's official onboarding skill for CUDA-Q — installs the platform, writes your first quantum kernel, picks a GPU simulator and routes you to real QPU hardware.
Skill: Shopify Checkout UI Extensions
by Shopify
Official Shopify skill for building checkout and thank-you page UI extensions — it carries the full extension-target list and validates components against the current UI framework version.
Official Shopify skill for modelling custom data — it pushes metafield and metaobject definitions into shopify.app.toml instead of runtime GraphQL, and gets $app namespacing right.
Skill: Shopify Functions
by Shopify
Official Shopify skill for writing Shopify Functions — the sandboxed backend logic behind discounts, cart transforms, delivery and payment customisation, validation and order routing.
Skill: Dynamo Router Starter
by NVIDIA
NVIDIA's official skill for bringing up Dynamo inference routing — pick a router mode, enable KV-aware routing, and smoke-test the frontend endpoint before claiming anything works.
Google's official Well-Architected Framework skill for the security pillar — turns an architecture review into a structured interview, gap analysis and prioritised recommendations.
Skill: Firebase Basics
by Google
Google's official Firebase entry-point skill — CLI login, project creation and selection, and programmatic retrieval of google-services.json and GoogleService-Info.plist.
Skill: Cloud SQL Basics
by Google
Google's official Cloud SQL skill — create and connect MySQL, PostgreSQL and SQL Server instances with the right gcloud commands, Auth Proxy setup, HA and backup model.
Skill: AlloyDB Basics
by Google
Google's official AlloyDB for PostgreSQL skill — cluster and instance lifecycle from gcloud, plus hard rules on private connectivity, IAM database auth and backup behaviour.
Skill: Twilio Security Hardening
by Twilio
Harden a Twilio integration against credential leaks and fraud — API keys instead of auth tokens, webhook signature validation, geo-permissions, SMS pumping prevention and zero-downtime credential rotation.
The rules that apply to live Twilio traffic — TCPA consent tiers, quiet hours and DNC, GDPR deletion rights, PCI DSS call recording, HIPAA, FDCPA, CAN-SPAM, WhatsApp policy and SHAKEN/STIR — with a consent-management pattern to implement.
Skill: Twilio Verify OTP Delivery
by Twilio
Add phone or email verification with Twilio Verify — send and check one-time passcodes over SMS, voice, email or WhatsApp, with built-in expiry, rate limiting and Fraud Guard rather than hand-rolled OTP plumbing.
Build real-time AI voice agents on Twilio ConversationRelay — TwiML setup, the WebSocket message types, streaming LLM responses back for playback, and the voice-provider configuration that goes with them.

Skill: Packer AWS AMI Builder
by HashiCorp
HashiCorp's official Packer skill for building Amazon Machine Images with the amazon-ebs builder, covering template structure, plugin pinning and the cost and timing caveats.
Skill: Terraform to Pulumi Migration
by Pulumi
Pulumi's official migration skill for moving Terraform or OpenTofu projects to Pulumi — translating HCL and importing tfstate without recreating live infrastructure.
Skill: Databricks Core
by Databricks
Databricks' official entry-point agent skill: CLI authentication, profile and workspace selection, asset bundles, and routing to the right product skill for the task.
Skill: .NET Crash Dump Collection
by .NET Foundation
The .NET team's official skill for capturing crash dumps from CoreCLR and NativeAOT apps on Linux, macOS, Windows and inside containers — collection only, no analysis.
Skill: GKE Basics & Critical Gotchas
by Google
Google's official GKE skill — when Autopilot beats Standard, Workload Identity instead of JSON keys, Autopilot's 250m CPU rounding, and private-cluster flags.
Skill: Cloud Run Basics
by Google
Google's official Cloud Run skill — deploy services, jobs and worker pools correctly, with the IAM roles, port contract and gotchas that break first deployments.
Skill: BigQuery Basics
by Google
Google's official BigQuery skill — datasets, tables, jobs and SQL from the bq CLI, plus the reference set for IAM, Terraform, change history and continuous queries.
Skill: Elastic LLM and Agentic Observability
by Elastic
Elastic's official skill for monitoring LLM and agent workloads — token cost, latency, response quality and workflow orchestration, queried with ES|QL.
Skill: MongoDB Schema Design
by MongoDB
MongoDB's official data-modelling skill — embed-vs-reference decisions, relationship patterns and the anti-patterns that quietly wreck performance and cost.
Skill: NVIDIA RAG Blueprint
by NVIDIA
Deploy, configure and troubleshoot the NVIDIA RAG Blueprint from your agent — Docker Compose, Helm or library, with feature toggles for VLM, guardrails and agentic RAG.
Skill: NVIDIA cuDF Accelerated Computing
by NVIDIA
NVIDIA's own guidance for moving pandas workloads onto GPU DataFrames with cuDF and dask-cuDF — when it pays off, and how to keep results identical.
Skill: Design Harness
by tigerless-labs
A decision board for contested calls: feed your agent papers and half-formed ideas, and it files them into a traceable sources → ideas → output structure you can defend, with a visual canvas over the markdown.
Skill: Awesome Gamedev Agent Skills
by gamedev-skills
67 game-development skills across ten engines — Godot, Unity, Unreal, Bevy, Phaser, PixiJS, three.js, LÖVE, pygame, Roblox — behind a router that detects your engine and loads only what fits.
Skill: Self-Learning
by kulaxyz
A meta-skill that spots the moment your agent has just earned a hard-won golden path and writes it down as a reusable skill, so the next session starts already knowing the route.
Skill: Aiven for OpenSearch Deployment
by OpenSearch Project
Provision and deploy to Aiven for OpenSearch from an agent — managed clusters on AWS, GCP, Azure, DigitalOcean or UpCloud, with the Aiven-generated password read back after provisioning.
Skill: OpenSearch Trace Analytics
by OpenSearch Project
Investigate OpenTelemetry traces stored in OpenSearch — slow and error spans, reconstructed trace trees, service maps, plus agent invocation and token-usage analysis.
Skill: OpenSearch Log Analytics
by OpenSearch Project
Query and analyse logs held in OpenSearch using PPL and Query DSL — error-pattern discovery, error-rate tracking and anomaly detection, driven from natural language.
Skill: Datadog Audit Trail
by Datadog
Answer "who changed what" from Datadog Audit Trail — configuration-change forensics, API key compromise, cost-spike root cause, SOC 2/PCI evidence and AI activity audits.
Skill: Datadog APM
by Datadog
Install, instrument and analyse Datadog APM from an agent — Kubernetes and Linux Single-Step Instrumentation, service remapping, trace search and service maps.
Skill: Datadog Logs
by Datadog
Search Datadog logs from an agent and keep the bill under control — query syntax, exclusion filters, log-based metrics, archives and PII scrubbing.
Skill: Datadog Monitors
by Datadog
Create and audit Datadog monitors from an agent via the pup CLI — with alerting rules that stop the usual flapping, unscoped and unowned monitors.
Skill: ClickHouse Best Practices
by ClickHouse Inc
ClickHouse's official agent skill: 31 rules for primary keys, data types, JOINs, batching and partitioning that an agent must check and cite before advising on a schema or query.
Skill: Neon Postgres
by Neon
Neon's official agent skill for serverless Postgres — connection strings and drivers, pooled vs direct connections, branching, autoscaling, scale-to-zero, read replicas and logical replication.
Skill: Netlify Deploy
by Netlify
Netlify's official deploy skill: netlify.toml deploy contexts and their precedence, CLI and drag-and-drop deploys, Deploy Previews, build hooks, skew protection, and secrets-scanning build failures.
Skill: Stripe Best Practices
by Stripe
Stripe's official agent skill for choosing the right payments primitive — Checkout vs PaymentIntents, Connect, Billing, Tax — and for handling API keys and webhooks safely.
Skill: Upstash Workflow (TypeScript)
by Upstash
Upstash's official skill for the Workflow TypeScript SDK - define serverless workflow endpoints, run durable steps, and trigger and manage runs from the client.

Skill: Elasticsearch ES|QL
by Elastic
Elastic's official skill for writing and running ES|QL - the piped Elasticsearch query language - covering schema discovery, query patterns, error handling and result formats.
Skill: Browserbase Browser Automation
by Browserbase
Browserbase's official skill for driving a real browser from an agent via the browse CLI - navigate, snapshot, fill forms and click, locally or in a cloud session.
Skill: Clerk Next.js Patterns
by Clerk
Clerk's official skill for advanced Next.js auth: middleware strategy, protecting Server Actions, caching-safe auth() usage, session tokens and manual JWT verification.
Skill: Prisma 7 Upgrade Guide
by Prisma
Prisma's official skill for migrating an ORM project from v6 to v7 - the prisma-client generator, driver adapters, prisma.config.ts, ESM entrypoints and every removed API.
Skill: Web Interface Guidelines
by Vercel
Audit UI code against Vercel's Web Interface Guidelines — accessibility, interaction, performance and layout rules — reported as terse file:line findings.
Skill: Vercel React Best Practices
by Vercel
Vercel Engineering's React and Next.js performance playbook as an agent skill — 70 rules across 8 categories, ordered by impact, for writing and refactoring fast components.
Skill: Firecrawl Build: Scrape
by Firecrawl
Integrate Firecrawl's /scrape endpoint into product code — turn a known URL into markdown, HTML, links, metadata or screenshots, with sensible defaults baked in.
Skill: Django Performance Review
by Sentry
Sentry's Django performance review skill — hunts N+1 queries, unbounded querysets, missing indexes and write loops, and reports only findings it can prove.
Skill: Claude Code Settings Audit
by Sentry
Analyse a repository's tech stack and generate a recommended Claude Code settings.json permission allowlist for its read-only commands.
Skill: Cypress Author
by Cypress.io
Cypress' official skill for writing, updating and repairing E2E and component tests — and it triggers on "write tests" even when nobody says Cypress.
Skill: Angular Developer
by Angular (Google)
Angular's official skill for generating idiomatic modern Angular — signals, resource and httpResource, forms, DI, routing, SSR, ARIA and CLI scaffolding.
Skill: Resend Email API
by Resend
Resend's official skill for the whole email lifecycle — transactional sends, inbound webhooks, templates, broadcasts, domains and delivery events.
Skill: Qdrant Advisor
by Qdrant
Qdrant's meta-skill: instead of shipping static docs, it loads the current official Qdrant skill tree live from skills.qdrant.tech and diagnoses from that.
Skill: MongoDB Search & AI
by MongoDB
MongoDB's official skill for choosing between Atlas Search, Vector Search and Hybrid Search, then building the right indexes and queries for the use case.
Skill: Flutter Architecture Best Practices
by Flutter
The Flutter team's official skill for structuring an app in the recommended UI / Logic / Data layers, with MVVM view-models and the repository pattern.
Skill: Firebase Security Rules Auditor
by Firebase
Firebase's official red-team skill for auditing Firestore and Cloud Storage security rules — hunting privilege escalation, create/update bypasses and resource-exhaustion holes.
Skill: Apollo Connectors
by Apollo GraphQL
Apollo's official skill for wrapping REST APIs into a GraphQL supergraph with @source and @connect directives — no resolvers, with compose, run and test steps enforced.
Skill: Planning with Files
by OthmanAdi
File-based planning for long-running agent tasks — crash-proof markdown plans that survive /clear and compaction, with per-turn re-injection and a deterministic completion gate.
Skill: .NET Performance Analysis
by Microsoft
The .NET team's official skill for scanning C# against ~50 performance anti-patterns across async, memory, strings, collections, LINQ, regex and I/O.
Skill: Android R8 Keep-Rule Analyzer
by Google
Google's official Android skill for auditing R8 and ProGuard keep rules — finds redundant and overly broad rules that quietly inflate APK size.

Skill: Remotion Video Creation
by Remotion
Remotion's official skill for scaffolding a programmatic video project in React and iterating on it in the Studio preview instead of re-rendering.
Skill: GSAP Core
by GreenSock
GreenSock's official skill for the GSAP core engine — tweens, eases, staggers, defaults and responsive/reduced-motion animation via matchMedia.
Skill: Microsoft Entra Agent ID
by Microsoft
Microsoft's official skill for giving AI agents real OAuth2 identities in Entra — blueprints, agent identities, sponsors, workload identity federation and the auth sidecar.

Skill: Gemini API in Agent Platform
by Google Cloud
Google's official skill for calling Gemini on Agent Platform (formerly Vertex AI) with the Gen AI SDK — Python, JS/TS, Go, Java and C#, plus tools, multimodal input and the Live API.

Skill: Authenticating to Google Cloud
by Google Cloud
Google's official skill for getting Google Cloud authentication right — human identities, service accounts, Application Default Credentials, and the failure modes agents usually hit.
Skill: PostHog Debugger
by PostHog
PostHog's official skill for auditing a live analytics implementation — scripts, network calls, and window state — read-only, via browser automation.
NVIDIA-verified skill that takes an agent from a problem described in prose to a correct LP, MILP, or QP formulation — concepts, not API calls.
Skill: Expo Router Navigation
by Expo
Official Expo skill for Expo Router: file-based routes, native stacks, NativeTabs, modals and form sheets, headers, toolbars, and search bars.
Skill: PromQL Query Patterns
by Grafana Labs
Grafana's official PromQL skill: write, validate, and optimise Prometheus queries, and hunt down the label that blew up your cardinality.
Skill: GitHub Actions Security Review
by Sentry
Audit GitHub Actions workflows for the exploitation patterns that leak secrets or allow code execution from a fork.
Skill: Code Simplifier
by Sentry
Clean up code for clarity, consistency, and maintainability without changing what it does.
Skill: Find Bugs in Branch Changes
by Sentry
Audit the changes on your current branch for bugs, security vulnerabilities, and quality problems before you push.
Skill: Engineering Code Review
by Sentry
Review pull requests against a real engineering practice — security, performance, testing, and design, in that order.
Skill: Deno Sandbox
by Deno
Run untrusted or model-generated code in an isolated environment using the @deno/sandbox SDK.
Skill: Deno Frontend with Fresh
by Deno
Build web UIs with Fresh and Preact on Deno — routes, handlers, islands, and Tailwind, using the current framework API.
Skill: Deno Deploy
by Deno
Deploy Deno applications to production on Deno Deploy — CLI workflows, environment config, KV, and custom domains.
Skill: Local Model Selection
by Hugging Face
Choose and run the right local model with llama.cpp and GGUF — quantisation, hardware fit, and local serving.
Skill: LLM Fine-Tuning with TRL
by Hugging Face
Fine-tune language and vision models with TRL or Unsloth — supervised, preference, and reinforcement training methods.
Skill: Transformers.js
by Hugging Face
Run machine learning models directly in the browser or Node with Transformers.js — no inference server required.
Skill: Hugging Face Spaces
by Hugging Face
Deploy and maintain applications on Hugging Face Spaces — SDK choice, GPU hardware, model loading, and debugging.
Skill: Hugging Face CLI
by Hugging Face
Hugging Face's official CLI skill — download, upload, and manage models, datasets, Spaces, and Jobs from the terminal.
Skill: Web Performance Auditing
by Cloudflare
Audit Core Web Vitals with real measurements via Chrome DevTools — then fix what the numbers actually point to.
Skill: Cloudflare Sandbox SDK
by Cloudflare
Build secure code-execution features on Cloudflare — sandboxes for AI-generated code, interpreters, and CI systems.
Skill: Wrangler CLI
by Cloudflare
Cloudflare's CLI reference skill — correct Wrangler commands for deploying and managing Workers and every binding.
Skill: Cloudflare Durable Objects
by Cloudflare
Create and review Cloudflare Durable Objects — single-instance coordination with SQLite storage, alarms, and WebSockets.
Skill: Cloudflare Agents SDK
by Cloudflare
Build stateful AI agents on Cloudflare Workers — durable state, scheduling, RPC, WebSockets, and MCP servers.
Skill: Writing Skills
by Jesse Vincent
Create, edit, and verify agent skills — including how to write a description that actually triggers at the right moment.
Skill: Dispatching Parallel Agents
by Jesse Vincent
Run two or more genuinely independent tasks concurrently, with the briefing and isolation that makes it safe.
Skill: Using Git Worktrees
by Jesse Vincent
Set up an isolated workspace with git worktrees before starting feature work or executing a plan.
Skill: Subagent-Driven Development
by Jesse Vincent
Execute an implementation plan by dispatching independent tasks to subagents, keeping the main context focused.
Skill: Receiving Code Review
by Jesse Vincent
Respond to code review feedback with technical rigour — verify each point instead of agreeing with everything.
Skill: Requesting Code Review
by Jesse Vincent
Prepare and request a code review that checks the work against its original requirements, not just its syntax.
Skill: Executing Implementation Plans
by Jesse Vincent
Work through a written implementation plan in a fresh session, with review checkpoints between steps.
Skill: Writing Implementation Plans
by Jesse Vincent
Convert a specification into a written implementation plan with discrete, verifiable steps, before touching code.
Skill: Vercel Optimize
by Vercel
Vercel's official optimization skill: collects real production metrics first, then returns ranked, citation-checked cost and performance fixes.
Skill: Data Visualization
by Anthropic
Anthropic's official data-visualization skill: pick the right chart for the data, then build it with ready-to-run matplotlib, seaborn, and plotly patterns.
Skill: MCP Builder
by Anthropic
Anthropic's guide for building high-quality MCP servers end to end — research, tool design, implementation in TypeScript or Python, testing, and a 10-question evaluation suite.

