Skills from jezweb/claude-skills

This skill provides comprehensive TanStack Query v5 documentation, code templates, and migration guides for React. It includes runnable shell commands (e.g., `npm install`, `npx @tanstack/react-query-codemod ...`) and example network calls to `https://jsonplaceholder.typicode.com` and `https://tanstack.com/query/latest`.

Set up Tailwind v4 with shadcn/ui using @theme inline pattern and CSS variable architecture. Four-step pattern: CSS variables, Tailwind mapping, base styles, automatic dark mode. Prevents 8 documented errors. Use when initializing React projects with Tailwind v4, or fixing colors not working, tw-animate-css errors, @theme inline dark mode conflicts, @apply breaking, v3 migration issues.

Provides production-ready Zustand patterns, TypeScript templates, and Next.js SSR hydration guidance for React. Contains example code that performs network requests to `https://api.example.com` and uses browser storage APIs like `localStorage`/`sessionStorage`.

Provides production-ready Tailwind CSS component patterns, templates, and examples for layouts, cards, navigation, forms, buttons, and dark mode. Includes an example that posts form data with `fetch('/api/contact', { method: 'POST', body: JSON.stringify(data) })`, which issues a network request.

This skill provides Next.js 16 migration guides, templates, and helper scripts. It contains runnable shell commands (`npx`, `npm`, `./scripts/check-versions.sh`), uses env vars (`SECRET_KEY`, `NEXT_PUBLIC_APP_URL`, `NODE_ENV`), and makes external network calls (e.g., `https://api.example.com`, `https://nextjs.org`).

This skill provides comprehensive React Hook Form + Zod examples, templates, and docs for building validated forms. It includes explicit network calls such as `fetch('/api/register')` and a shell script `scripts/check-versions.sh` that runs `npm` commands.

Provides documentation, templates, and setup scripts for the Motion (Framer Motion) React animation library. Includes shell scripts that run `pnpm add motion` / `npm install motion` and create files like `src/components/motion-client.tsx`, performing package installs (network calls) and filesystem writes.

This skill provides migration and build guidance for React Native/Expo (0.76–0.82+/SDK 52+), including project setup, build and submission workflows. It includes explicit shell commands (`npx`/`npm`/`pod install`), network calls (`fetch`, `npx eas-cli build`) and sets env vars like `ENV['HERMES_ENABLED']`, enabling local execution and external network activity.

Provides templates and step-by-step workflows to set up Drizzle ORM with Cloudflare D1, including schema, migrations, batch patterns, and Worker integration. The skill instructs running shell commands like `npx drizzle-kit generate` and `npx wrangler d1 migrations apply`, uses env vars `CLOUDFLARE_D1_TOKEN`/`CLOUDFLARE_ACCOUNT_ID`, and performs networked CLI operations such as `http://local.drizzle.studio`.

Provides comprehensive Hono routing, middleware, validation, RPC and template code for building APIs. Includes explicit shell commands (`npm install`, `scripts/check-versions.sh`), network call examples (`http://localhost:8787`, `https://api.example.com/data`), and environment secret usage (`API_KEY`, `DATABASE_URL`).

Generates planning docs and phase templates for web apps (e.g., `IMPLEMENTATION_PHASES.md`, `ENV_VARIABLES.md`). Contains explicit shell commands (e.g., `pnpm dlx shadcn@latest`, `npx wrangler deploy`), instructs storing/using secrets like `CLERK_SECRET_KEY`/`OPENAI_API_KEY`, and calls external APIs such as `https://api.search.brave.com/res/v1/web/search`.

This skill provides templates, examples, and guidance to build secure WordPress plugins (Simple, OOP, PSR-4) including REST endpoints and auto-update integration. It includes explicit shell commands and scripts (`composer install`, `scripts/scaffold-plugin.sh`, `git submodule add`), network calls to `https://github.com/...` and `https://example.com/api/validate-license`, and use of tokens like `YOUR_PLUGIN_GITHUB_TOKEN`.

Generate complete SEO meta tags for every page. Covers title patterns, meta descriptions, Open Graph, Twitter Cards, and JSON-LD structured data (LocalBusiness, Service, FAQ, BreadcrumbList). Use when: building pages, adding social sharing, implementing structured data, optimizing for search engines.

Provides type-safe, file-based React routing with TanStack Router, including loaders, virtual routes, and Cloudflare Workers integration. Contains runtime examples that call `fetch('/api/posts')` and access `env.DB` in a Cloudflare Worker.

Provides documentation and examples to use the Firecrawl web-scraping API (`https://api.firecrawl.dev`, `/v2/scrape`, `/v2/crawl`) and Cloudflare Worker integration. Includes instructions to read/use `FIRECRAWL_API_KEY` and run CLI commands (`curl`, `pip install`, `npx wrangler`).

Provides React UI templates and guidance for Vercel AI SDK v6 with Next.js API route examples. It documents adding `.env.local` keys and reading `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, and `GOOGLE_GENERATIVE_AI_API_KEY` from `process.env` for authentication.

This skill provides WCAG 2.1 AA accessibility guidance and an `a11y-auditor` agent that inspects local code and runs command-line scans. It includes explicit shell commands (e.g., `grep -r "onclick" src/`) and external downloads/URLs (e.g., `https://www.nvaccess.org/download/`).

This skill provides local Playwright browser automation, stealth scraping templates, and scripts for authenticated scraping, screenshots/PDFs, and MCP integration. It instructs shell commands (`npx`, `scripts/install-browsers.sh`), external calls to `https://2captcha.com` and `https://bot.sannysoft.com/`, reads `process.env.TWOCAPTCHA_KEY`/`process.env.EMAIL`, and suggests `--cap-add=SYS_ADMIN`.

Documents backend AI usage with Vercel AI SDK v5/v6 including providers, tools, MCP, streaming, and migration guidance. Contains instructions that run subprocesses (`command: 'npx'`), execute shell commands (`npm install`, `npx mcp-to-ai-sdk`), and use env vars (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`).

Provides Tiptap editor setup, templates, and image-upload patterns for React/Next.js projects. Contains explicit shell/CLI instructions (`minimal-tiptap-setup.sh`, `npm install`), external network endpoints (`https://raw.githubusercontent.com/...`, `/api/upload`, `ws://localhost:1234`), and uses the Cloudflare binding `IMAGES_BUCKET`.

Comprehensive integration guide and examples for Google Gemini using `@google/genai`, covering SDK/fetch usage, multimodal inputs, caching, code execution, grounding, and templates. It requires `GEMINI_API_KEY`, calls `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent`, and includes shell commands (purpose-aligned; no secret exfiltration found).

Generates complete, accessible color palettes (11-shade scales, semantic tokens, dark mode) and writes CSS output by default to `src/styles/colors.css`, with WCAG contrast checks. No security-relevant behaviors detected.

Build headless data tables with TanStack Table v8. Server-side pagination, filtering, sorting, and virtualization for Cloudflare Workers + D1. Prevents 12 documented errors. Use when building tables with large datasets, coordinating with TanStack Query, or fixing state management, performance, or React 19+ compatibility issues.

Provides Cloudflare R2 storage guidance and Worker templates for uploads, presigned URLs, multipart uploads, CORS, and retry patterns. Contains explicit CLI commands (`npx wrangler r2 bucket create my-bucket`, `wrangler secret put R2_ACCESS_KEY_ID`), network endpoints (`https://${bucketName}.${accountId}.r2.cloudflarestorage.com/${filename}`), and env vars (`R2_ACCESS_KEY_ID`, `R2_SECRET_ACCESS_KEY`).

This skill documents and provides runnable templates for integrating OpenAI stateless APIs (chat, embeddings, images, audio, moderation) and includes example code and install/test scripts. It requires an `OPENAI_API_KEY`, directs local shell commands such as `./scripts/install-skill.sh` and `cd /home/jez/Documents/claude-skills/skills/openai-api`, and makes network calls to `https://api.openai.com/v1/...`.

Build full-stack React apps with TanStack Start on Cloudflare Workers. Type-safe routing, server functions, SSR/streaming, D1/KV/R2 integration. Use when building full-stack React apps with SSR, migrating from Next.js, or from Vinxi to Vite (v1.121.0+). Prevents 9 documented errors including middleware bugs, file upload limitations, and deployment config issues.

This skill documents self-hosted `better-auth` setup for Cloudflare Workers + D1 using Drizzle/Kysely, with examples, scripts, and integration patterns. It includes explicit shell commands (e.g., `npx drizzle-kit generate`, `wrangler d1 migrations apply`), uses env vars like `BETTER_AUTH_SECRET`, and makes network calls such as `https://api.example.com`.

Select semantically appropriate icons for websites using Lucide, Heroicons, or Phosphor. Covers concept-to-icon mapping, React/HTML templates, and tree-shaking patterns. Use when: building feature sections, service grids, contact info, navigation, or any UI needing icons. Prevents emoji usage, ensures consistency.

Comprehensive guide for building Google Workspace integrations with OAuth, service accounts, and Cloudflare Workers. It instructs storing and using secrets (`GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET`, `GOOGLE_SERVICE_ACCOUNT`, `TOKENS`), running setup CLI commands (`echo ... | npx wrangler secret put GOOGLE_CLIENT_ID`, `npm install jose`), and calling Google endpoints (`https://oauth2.googleapis.com/token`).

This skill documents Firebase Firestore setup, CRUD, listeners, security rules, and deployment examples. It references environment secrets such as `FIREBASE_PRIVATE_KEY` and includes CLI commands like `firebase deploy --only firestore` and `gcloud firestore export gs://your-bucket/backups/$(date +%Y%m%d)`, which require shell execution and network access.

Build Python web apps with Flask using application factory pattern, Blueprints, and Flask-SQLAlchemy. Prevents 9 documented errors including stream_with_context teardown issues, async/gevent conflicts, and CSRF cache problems. Use when: creating Flask projects, organizing blueprints, or troubleshooting circular imports, context errors, registration, streaming, or authentication.

High-risk skill for document generation. It directs executing shell commands like `npm install` and `npx tsx`, reading templates from `~/.claude/skills/office/templates/` and `/tmp/generate-doc.ts`, fetching `https://example.com/image.png`, and using the environment binding `BROWSER`.

This skill documents the Claude Agent SDK and includes templates that execute shell commands (`npx`, `npm install -g @anthropic-ai/claude-code`), call external endpoints (`https://api.weather.com`, `https://api.example.com/mcp`), and instruct setting `ANTHROPIC_API_KEY` in the environment. It also exposes broad modes like `bypassPermissions` and an `allowedTools` default of all tools.

Build with D1 serverless SQLite database on Cloudflare's edge. Use when: creating databases, writing SQL migrations, querying D1 from Workers, handling relational data, or troubleshooting D1_ERROR, statement too long, migration failures, or query performance issues. Prevents 14 documented errors.

This skill provides templates, examples, and agents to build FastMCP MCP servers in Python/TypeScript and to deploy them. It includes explicit shell commands (`pip install fastmcp`, `npx wrangler deploy`), environment-secret usage (`API_KEY`, `GITHUB_CLIENT_SECRET`, `STORAGE_ENCRYPTION_KEY`), and network endpoints (`https://github.com/login/oauth/authorize`, `https://api.example.com`).

This skill scaffolds and configures Cloudflare Workers projects (Hono, Vite, Static Assets) and includes deploy/debug agents and templates. It contains explicit shell commands (`npm`, `git`, `npx wrangler deploy`, `curl`), network calls (`https://api.datadoghq.com/api/v1/logs`, `https://cloudflare-worker-base-test.webfonts.workers.dev`) and secret handling (`wrangler secret put`, `CLOUDFLARE_API_TOKEN`).

This skill documents sub-agent creation, configuration, orchestration, and delegation for Claude Code. It explicitly instructs executing shell commands (`git`, `npm`, `cat > file << 'EOF'`, `./scripts/run-linter.sh`), modifying agent configs (`.claude/agents/`, `settings.json`), and making external requests (`https://code.claude.com/docs/en/sub-agents`, `WebFetch`).

Generate custom favicons from logos, text, or brand colors - prevents launching with CMS defaults. Extract icons from logos, create monogram favicons from initials, or use branded shapes. Outputs all required formats: favicon.svg, favicon.ico, apple-touch-icon.png, and web app manifest. Use when: initializing new websites, replacing WordPress/CMS default favicons, converting logos to favicons, creating branded icons from text only, or troubleshooting favicon not displaying, iOS icon transparency, or missing manifest files.

The skill manages project session state by creating and updating `SESSION.md`, generating structured git checkpoints, and providing templates and a helper script. It includes an executable helper `./scripts/resume.sh` and shows git commands and optional pushes (e.g., `https://github.com/jezweb/claude-skills`).

This skill implements Firebase Authentication with client and admin examples, Next.js routes, and templates. It reads/stores credentials via env vars like `FIREBASE_PRIVATE_KEY` and lists CLI commands (`firebase init`, `firebase emulators:start`, `firebase auth:export`) that instruct shell execution.

This skill automates a full project lifecycle with slash commands to create planning docs, manage `SESSION.md`, and run pre-release checks. It instructs running shell commands (`git`, `gh`, `gitleaks`, `npm`), performing network actions to `https://github.com`, and writing to user agent files like `~/.claude/CLAUDE.md`, which are security-relevant.

This skill manages project documentation and can create or update `CLAUDE.md`, `README.md`, and `docs/` from project files. It includes instructions to read `package.json` and `.env`/`.env.example`, run shell commands like `git`/`pnpm`, and perform network checks such as `npm view <pkg> version`.

This skill provides setup and code patterns for Neon and Vercel serverless Postgres, including example scripts and templates (`db/schema.ts`, `assets/drizzle-schema.ts`). It instructs running shell commands (`npm install`, `neonctl`, `vercel deploy`), uses environment variables (`DATABASE_URL`, `POSTGRES_URL`, `NEON_API_KEY`), and calls remote domains (`https://neon.tech`, `ep-xyz-pooler.region.aws.neon.tech`).

Implement performant responsive images with srcset, sizes, lazy loading, and modern formats (WebP, AVIF). Covers aspect-ratio for CLS prevention, picture element for art direction, and fetchpriority for LCP optimization. Use when: adding images to pages, optimizing Core Web Vitals, preventing layout shift, implementing art direction, or converting to modern formats.

This skill documents building ElevenLabs voice agents with SDK examples, CLI scripts, templates, and MCP guidance. It includes instructions that read/use `ELEVENLABS_API_KEY`, execute shell/CLI commands like `elevenlabs agents push`, and call `https://api.elevenlabs.io/v1/convai`.

This skill provides SDK documentation, templates, and code samples for building OpenAI Agents. It sets/uses `OPENAI_API_KEY`, includes external requests (e.g., `https://api.example.com/search?q=${query}`), and contains shell/CLI commands such as `npm view @openai/agents version`.

This skill provides Cloudflare Workers KV documentation, templates, and example Workers for namespace management and KV operations. It includes instructions to run `npx wrangler kv ...` CLI commands and uses environment variables like `${KV_CACHE_ID}` and bindings such as `MY_KV`.

This skill guides creation and design of Claude Code skills and includes runnable shell commands such as `./scripts/install-skill.sh`, `./scripts/check-metadata.sh`, and the `/create-skill` command. No instructions to read secrets or call remote APIs are present in the content.

Zero-config animations for React, Vue, Solid, Svelte, Preact with @formkit/auto-animate (3.28kb). Prevents 15 documented errors including React 19 StrictMode bugs, SSR imports, conditional parents, viewport issues, drag & drop conflicts, and CSS transform bugs. Use when: animating lists/accordions/toasts, troubleshooting SSR animation errors, React 19 StrictMode issues, or need accessible drop-in transitions with auto prefers-reduced-motion.

This skill documents implementing OAuth 2.0 with GitHub and Microsoft Entra in Cloudflare Workers, including token exchange and JWT validation. It instructs network calls to `https://api.github.com`, `https://github.com/login/oauth`, and `https://graph.microsoft.com` and the use of `client_secret`/access tokens for authentication, which is purpose-aligned.

This skill documents designing Claude Code agents and prompt patterns. It instructs editing `~/.bashrc` and `.claude/settings.json`, granting `tools: Read, Write, Edit, Glob, Grep, Bash`, allowlisting `WebFetch(domain:*)`, and using `ANTHROPIC_API_KEY`, enabling shell execution and broad network access.

This skill audits Claude skills with a 9-phase review and automates checks and fixes. The skill explicitly runs shell scripts such as `./scripts/review-skill.sh` and performs external fetches via `WebFetch`/GitHub (e.g., `https://github.com/better-auth/better-auth`), enabling shell execution and external network access.

Provides a set of development workflow agents for code review, debugging, testing, documentation, and git operations. Contains explicit instructions to run shell commands like `rm -rf dist && npm run build`, make network requests to `https://api.example.com/endpoint`, and create environment files with `cp .env.example .env`.

This skill generates and edits website images using Gemini Native Image Generation. It includes code that reads `process.env.GEMINI_API_KEY`, calls `https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-image-generation:generateContent`, and shows shell commands such as `pnpm add @google/genai` and `curl ...`.

Provides integration patterns and templates for Cloudflare Turnstile (widget rendering, server-side validation, React/Hono examples). It performs network calls to `https://challenges.cloudflare.com/turnstile/v0/siteverify`, uses env var `TURNSTILE_SECRET_KEY`, and includes runnable scripts such as `scripts/check-csp.sh`.

High-risk skill: provides templates and documentation for integrating OpenAI Responses API and MCP tools. It explicitly uses env vars such as `process.env.OPENAI_API_KEY` and `process.env.STRIPE_OAUTH_TOKEN`, makes network calls to `https://api.openai.com/v1/responses` and MCP servers like `https://mcp.stripe.com`, and includes a shell script that runs `npm` commands.

Provides Cloudflare Browser Rendering guidance and templates for using Puppeteer/Playwright on Workers. The skill's examples and templates instruct running shell commands (`npx wrangler deploy`), performing network calls (`page.goto(url)`, `env.AI.run`) and configuring secrets/vars (`MYBROWSER`, `API_KEY`).

This skill documents Cloudflare Workflows and provides TypeScript templates, examples, and `wrangler` configuration for building durable workflows. It includes example external calls to `https://api.example.com` and CLI instructions such as `npm create cloudflare@latest` and `npx wrangler deploy`.

This skill documents Cloudflare Queues and provides code/templates for producers, consumers, DLQs, and `wrangler` commands. It includes examples that run `npx wrangler` commands, call external endpoints like `https://api.cloudflare.com` and `https://api.resend.com/emails` (including dynamic `data.url`), and references secrets such as `RESEND_API_KEY` and `SLACK_WEBHOOK_URL`.

This skill provides comprehensive guidance and templates for running Workers AI models on Cloudflare Workers (streaming, RAG, images, AI Gateway). It instructs running shell commands like `rm -rf ~/.wrangler`, using secrets such as `env.CLOUDFLARE_API_KEY`, and making network calls to `https://gateway.ai.cloudflare.com/v1/${accountId}/${gatewayId}/workers-ai/@cf/meta/llama-3.1-8b-instruct`.

This skill provides a multi-provider email gateway for `Resend`, `SendGrid`, `Mailgun`, and `SMTP2Go` with templates, webhooks, retries, and deployment examples. It includes use of secrets (`RESEND_API_KEY`, `SENDGRID_API_KEY`, `MAILGUN_API_KEY`, `SMTP2GO_API_KEY`), external API calls (`https://api.resend.com/emails`, `https://api.sendgrid.com/v3/mail/send`) and shell commands (`./test-provider.sh`, `npx wrangler`).

This skill provides production-ready guides and templates to generate Gemini embeddings and integrate with Cloudflare Vectorize. It requires and uses the `GEMINI_API_KEY`, runs CLI setup commands (`npm`, `npx wrangler`, `npx wrangler secret put GEMINI_API_KEY`) and makes network calls to `generativelanguage.googleapis.com`.

This skill documents how to build Cloudflare Durable Objects and includes templates, examples, and deployment guidance. It contains purpose-aligned shell commands such as `npm create cloudflare@latest my-durable-app -- --template=cloudflare/durable-objects-template --ts` and network calls like `https://fake-host/increment` in examples.

Provides TypeScript MCP server templates and Cloudflare Workers deployment guides. Contains explicit instructions to run shell commands (`npm install`, `./init-mcp-server.sh`), access secrets (`MCP_API_KEYS`, `JWT_SECRET`), modify `claude_desktop_config.json`, and call external APIs (`https://api.openweathermap.org`, `https://mcp.example.com`).

This skill integrates `@vercel/blob` into Next.js to manage uploads, presigned client tokens, multipart uploads, and file management. It instructs storing `BLOB_READ_WRITE_TOKEN` in ` .env.local` and includes example network calls to `/api/upload-token` and external callback URLs such as `https://example.com`.

This skill provides Microsoft Entra ID authentication patterns for React SPAs and Cloudflare Workers. It reads `VITE_AZURE_CLIENT_ID`/`VITE_AZURE_TENANT_ID` and performs network calls to `https://login.microsoftonline.com/…/.well-known/openid-configuration` for JWKS discovery; these env/network uses are purpose-aligned.

This skill provides Cloudflare Images integration: upload, transformations, Workers templates, variants, batch API, and signed-URL helpers. It includes network calls to `https://api.cloudflare.com`/`https://batch.imagedelivery.net`, uses secrets like `IMAGES_API_TOKEN`/`IMAGES_SIGNING_KEY`, and ships shell scripts such as `./scripts/check-versions.sh`.

This skill teaches building and deploying MCP servers on Cloudflare Workers and provides templates, CLI steps, and configuration examples. It instructs running commands like `npx wrangler deploy`, accessing env vars such as `GITHUB_CLIENT_SECRET`/`API_KEY`, and making network calls to endpoints like `https://oauth-provider.com/token`.

This skill documents building and deploying Snowflake Native Apps, Cortex AI usage, Snow CLI workflows, JWT key-pair auth, and Snowpark examples. It includes explicit execution steps and artifacts such as `openssl genrsa ... -out ~/.snowflake/rsa_key.p8`, `snow app run`, network calls to `https://{org-account}.snowflakecomputing.com/api/v2/statements`, and env vars like `SNOWFLAKE_PRIVATE_KEY`.

This skill documents the Cloudflare Agents SDK for Workers and Durable Objects with templates and examples for WebSockets, scheduling, RAG, and MCP servers. It includes usage of `OPENAI_API_KEY`/`ANTHROPIC_API_KEY`, shell commands like `npx wrangler deploy`, and network calls to `https://api.openai.com/v1/chat/completions`.

This skill provides templates and guides to integrate Cloudflare Vectorize V2 with Workers AI and OpenAI (e.g., `templates/basic-search.ts`, `templates/document-ingestion.ts`). It includes explicit CLI/shell commands (e.g., `npx wrangler vectorize create my-index`), network calls (e.g., `fetch(body.url)`, `https://api.cloudflare.com/...`), and use of `OPENAI_API_KEY`.

High-risk skill: provides Claude/Anthropic API integration examples and templates. Contains arbitrary code execution via `eval(input.expression)`, explicit network calls to `https://api.anthropic.com/v1/messages`, and uses the `ANTHROPIC_API_KEY` env var.

This skill provides setup and examples for Google Gemini File Search, including scripts and templates to create stores, upload documents, and query with grounding metadata. It requires the `GOOGLE_API_KEY`, reads local files such as `./docs/manual.pdf`, and makes network calls to `https://generativelanguage.googleapis.com`.

High-risk skill: contains explicit CLI commands that write credentials to `.env.local`, upload certificates with `npx wrangler cert upload`, and pass connection strings like `postgres://user:password@host:5432/database` to remote Cloudflare services. It documents `CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_HYPERDRIVE` and configuration `wrangler.jsonc`.

This skill provides templates and documentation to build and deploy Streamlit apps in Snowflake. It includes CI/CD examples that write `SNOWFLAKE_PRIVATE_KEY` to `/tmp/rsa_key.p8` and run `snow streamlit deploy`, requiring secret handling and executing CLI/network operations.

Dangerous skill: executes local shell commands via `execSync` and makes external API calls while loading sensitive env vars. It generates TypeScript SDKs and includes templates/commands for `npx wrangler`, `https://api.cloudflare.com`, and env vars like `SDK_API_TOKEN`.

This skill provides templates and documentation to build Python APIs on Cloudflare Workers using `pywrangler` and `WorkerEntrypoint`. It includes example shell commands like `uv run pywrangler deploy`, network calls to `https://api.example.com` and uses bindings/env names such as `MY_KV` and `DB`.

Provides guides and templates for building stateful chatbots with the OpenAI Assistants API v2, including code interpreter, file search, vector stores, and function-calling. Contains explicit instructions to run shell commands (`npm install`, `scripts/check-versions.sh`), performs external OpenAI API calls, and reads the `OPENAI_API_KEY` environment variable.

This skill provides templates and guidance for integrating Vercel KV (Redis-compatible) into Next.js apps for caching, sessions, and rate limiting. It instructs running `vercel env pull .env.local`, uses environment credentials like `KV_REST_API_URL` and `KV_REST_API_TOKEN`, and includes examples that contact remote KV endpoints.

This skill provides TypeScript CLI script templates, documentation, and rules for building MCP companion scripts. It includes local shell commands (e.g., `cp ~/.claude/skills/mcp-cli-scripts/templates/script-template.ts scripts/new-tool.ts`, `npx tsx scripts/new-tool.ts --help`) that instruct running commands on the host.

This skill implements Google Chat bots and webhooks with Cards v2 and Cloudflare Worker templates. It makes outbound requests to `https://chat.googleapis.com` and `https://www.googleapis.com/service_accounts/v1/jwk/chat@system.gserviceaccount.com`, and instructs running `wrangler secret put CHAT_BOT_TOKEN` to manage secrets.

This skill documents Clerk authentication integration and provides setup scripts, templates, and an agent for Next.js, React, and Cloudflare Workers. It instructs running shell commands (`npm install`, `node scripts/generate-session-token.js`), making network calls to `https://api.clerk.com/v1`, and using secrets like `CLERK_SECRET_KEY`.

This skill automates pre-PR checks, branch cleanup, and PR description generation for open-source contributions. It runs local shell commands (e.g., `./scripts/pre-pr-check.sh`, `./scripts/clean-branch.sh`, `git`, `npm`) and uses network hosts like `https://github.com/owner/repo.git`; no explicit secret exfiltration instructions were found.

This skill provides TinaCMS integration templates, configuration examples, and deployment guides for Next.js, Vite+React, and Astro. It includes executable shell commands (e.g., `npx @tinacms/cli@latest`, `pnpm install`, `npx wrangler deploy`) and instructs setting secrets such as `NEXT_PUBLIC_TINA_CLIENT_ID` and `TINA_TOKEN`.

Provides setup instructions, templates, and scripts to integrate `Sveltia CMS` into static sites. The skill instructs running shell commands (`git clone`, `npm install`, `npx wrangler deploy`), making network requests to `https://unpkg.com` and Workers URLs, and storing secrets like `GITHUB_CLIENT_SECRET` via `npx wrangler secret put`.

Posts project updates to Google Chat Spaces via webhook, reading config from `.claude/settings.json` and using templates in `templates/`. It requests/stores the webhook URL (`https://chat.googleapis.com/v1/spaces/SPACE_ID/messages?key=API_KEY&token=TOKEN`), runs local shell/git commands (`cat .claude/settings.json`, `git log`) and posts via `curl`.

This skill documents building ChatGPT Apps (MCP servers on Cloudflare Workers) with widget serving, tooling, and deployment examples. It includes explicit `npm`/`npx` commands (e.g., `npm install`, `npx wrangler deploy`), directs setting `COOKIE_ENCRYPTION_KEY` via `openssl rand -hex 32`, and references `https://my-app.workers.dev/mcp` and `https://chatgpt.com`.

This skill provides Firebase Cloud Storage integration with client and Admin SDK examples, security rules, CORS templates, and React upload components. It reads env vars like `NEXT_PUBLIC_FIREBASE_API_KEY` and `FIREBASE_PRIVATE_KEY`, and instructs running `firebase deploy --only storage` and `gsutil cors set cors.json gs://your-bucket-name.appspot.com`, enabling shell and network operations.

This skill provides OAuth authentication for MCP servers on Cloudflare Workers with Google OAuth and DCR support. It instructs storing/using secrets (`GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET`, `COOKIE_ENCRYPTION_KEY`, `AUTH_TOKEN`), running CLI deployment/secret commands (`npx wrangler deploy`, `npx wrangler secret put`), and calling Google endpoints (`https://oauth2.googleapis.com/token`, `https://accounts.google.com/o/oauth2/v2/auth`).

This skill documents deploying Django on App Engine with Cloud SQL and provides `app.yaml` and `settings.py` examples for Unix-socket and local development. It instructs running shell commands and downloads (e.g., `curl -o cloud-sql-proxy https://storage.googleapis.com/.../cloud-sql-proxy.linux.amd64`, `./cloud-sql-proxy PROJECT_ID:REGION:INSTANCE_NAME`) and handling secrets via `gcloud app deploy --set-env-vars="DB_PASSWORD=..."`.

Provides a secure Electron + Vite + React starter with typed IPC, OAuth protocol handlers, native-module guidance, and packaging templates. It stores authentication sessions in `electron-store` (`store.set('session', session);`) and makes network calls to `https://your-api.example.com` for auth.

This skill documents deploying Python apps to Google App Engine, covering `app.yaml`, Cloud SQL sockets, Cloud Storage, Secret Manager, and common deploy commands. It instructs running shell commands (`gcloud`, `docker`, `cloud-sql-proxy`), using secrets (`Secret Manager`, env vars like `DB_PASSWORD`), and copying rules to `.claude/rules/google-app-engine.md`.

Provides guidance for migrating jQuery 3.x to 4.0, including WordPress-specific instructions, breaking-change references, and migration patterns. Includes explicit remote resources such as `https://code.jquery.com/jquery-4.0.0.js` and shell/CLI commands like `npm install jquery@4.0.0` and `wp eval "echo wp_scripts()->registered['jquery-core']->ver;"`.

AI-agent readiness auditing for project documentation and workflows. Evaluates whether future Claude Code sessions can understand docs, execute workflows literally, and resume work effectively. Use when onboarding AI agents to a project or ensuring context continuity. Includes three specialized agents: context-auditor (AI-readability), workflow-validator (process executability), handoff-checker (session continuity). Use PROACTIVELY before handing off projects to other AI sessions or team members.

Test React components with Testing Library patterns. Covers queries (getBy/findBy/queryBy), user-event interactions, async testing (findBy vs waitFor), accessibility testing, and MSW integration for API mocking. Use when: testing React components, simulating user interactions, testing forms, mocking API calls with MSW, or writing accessible tests. Keywords: testing-library, react testing library, getByRole, user-event, waitFor, MSW, screen.

Multi-agent investigation for stubborn bugs. Use when: going in circles debugging, need to investigate browser/API interactions, complex bugs resisting normal debugging, or when symptoms don't match expectations. Launches parallel agents with different perspectives and uses Chrome tools for evidence gathering.

The skill provides agent-based, YAML-driven test generation and runners for MCP, API, CLI, and browser tests. It includes explicit instructions to run shell commands like `npm run test -- --coverage`, make network calls to `https://api.example.com/health` and `https://app.example.com/login`, and to omit `tools` to inherit `ALL tools`.

This skill audits JavaScript/TypeScript dependencies and produces prioritized fix recommendations. It instructs running commands like `npm audit --json` and `ls package-lock.json`, which run shell commands and perform network access (e.g., via package registries) and may read/write `package.json`.

Provides production-ready FastAPI templates with JWT auth, Pydantic v2 schemas, and async SQLAlchemy. Includes instructions to run shell commands like `uv run uvicorn src.main:app --host 0.0.0.0 --port 8000` and uses environment secrets such as `SECRET_KEY` via `.env`.