All 464 skills

Build autonomous, scheduled agent automations with the Ledger + Conductor + Routine pattern. Each scheduled run ships ONE MILESTONE — a complete vertical slice with checks, implementation, one evidence-backed review, and a quality gate, all in a single run — against a durable JSON ledger, driven by any headless agent CLI (Claude Code, Codex, Gemini, opencode, Cursor, aider, and others). Use when the user wants a self-running pipeline, a fleet builder, or any cron-driven agent that must keep making real, verifiable progress unattended — resumable, serial, and never corrupting shared state. This is the core method; sibling skills provide a worked example, a SaaS product pipeline, and creators that generate a tailored automation from an interview.

Create a complete agent automation for ANY goal of the user's choice, on the 11ai-automation method (Ledger + Conductor + Routine). Runs a short interview about the goal, work item, milestones, depth bar, quality gate, platform, and agent CLI — then generates every file: a filled-in CONDUCTOR.md, ledger.json, the provider-agnostic runner script and config, and a first-tick walkthrough. Use when the user says "create/build/set up an agent automation for X", "I want an agent that keeps doing X on a schedule", or "turn this recurring work into an autonomous pipeline". For SaaS product fleets specifically, prefer 11ai-saas-fleet-automation-creator.

A complete, generic worked example of the 11ai-automation method (Ledger + Conductor + Routine): an autonomous agent that builds and maintains a library of tested how-to guides, one milestone per scheduled run. Contains a fully filled-in CONDUCTOR.md, a real ledger.json mid-flight, and a runner config — every blank in the conductor template made concrete. Use when the user wants to SEE the pattern instantiated before writing their own, wants a starting point to copy and adapt, or asks "show me an example agent automation". For a tailored automation, use 11ai-automation-creator.

Add a human idea to an existing agent automation's ledger so the autonomous agent picks it up and works on it in later scheduled runs. Reads the automation's CONDUCTOR.md and ledger.json, checks the idea fits the theme, dedupes it against existing items, writes a well-formed ledger entry carrying a `seed` (the idea, why, constraints), and commits it safely between ticks. Use when the user says "add this idea to the ledger/queue/backlog", "have the agent build X next", "seed the automation with these ideas", or pastes a list of ideas for the fleet. Works with any ledger built on the 11ai-automation method, including 11ai-saas-fleet-automation fleets (seed = a product idea) and 11ai-single-saas-automation products (seed = a feature/capability request).

Ready-made agent automation for building a fleet of real SaaS products, one milestone per scheduled run, on the 11ai-automation method (Ledger + Conductor + Routine). Includes the SaaS state machine (scoping → building per-milestone → hardening → shipping → done), a five-probe DEPTH BAR that blocks static brochure-ware from ever counting as done (real user input, real persistence round-trip, real interactivity, a live data path, honest copy), anti-theater hardening rules, and the payments boundary (pricing is real, checkout does not exist). Use when the user wants an autonomous, cron-driven agent that researches, builds, and ships MANY SaaS products/POCs/MVPs unattended. To tailor a new fleet to a specific niche via an interview, use 11ai-saas-fleet-automation-creator instead. To pour every tick into ONE product at production depth, use 11ai-single-saas-automation instead.

Create a complete SaaS product-fleet agent automation for a niche and goal of the user's choice, combining the 11ai-automation method with the 11ai-saas-fleet-automation lifecycle (milestone ticks + the five-probe depth bar that blocks brochure-ware + the payments boundary). Runs a short interview about the niche, target users, stack, and caps — then generates the conductor, ledger, runner, and per-product scaffolding conventions. Use when the user says "create an agent automation that builds SaaS products / POCs / MVPs for X", "set up an autonomous product factory", or wants a cron-driven agent shipping many products in a chosen market unattended. For ONE product deepened to production grade, use 11ai-single-saas-automation-creator instead.

Agent automation that builds and continuously deepens ONE SaaS product to production grade, on the 11ai-automation method (Ledger + Conductor + Routine). Where the fleet skill ships many demo-grade products, this one pours every tick into a single product: ledger items are CAPABILITIES of the product (auth, billing, the core feature, admin, notifications), each built milestone-by-milestone against a production depth bar — real accounts with tenant isolation, payments in provider test mode, schema migrations, error/empty/loading states, rate limiting, and a growing cross-capability "spine" e2e that must stay green forever. Use when the user wants an autonomous agent working on one real product ("keep building my app", "deepen this SaaS", "take this product to production quality"). For many small products instead, use 11ai-saas-fleet-automation. To set a new single-product automation up via interview, use 11ai-single-saas-automation-creator.

Create an agent automation that builds and continuously deepens ONE SaaS product to production grade, for a product of the user's choice — combining the 11ai-automation method with the 11ai-single-saas-automation lifecycle (capability items, the production depth bar with accounts/ tenancy/test-mode payments/migrations, the walking skeleton, the spine e2e). Runs an interview about the product's mission, users, monetization, stack, and initial capability backlog — then generates PRODUCT.md, the conductor, a pre-seeded ledger, and the runner. Use when the user says "set up an agent to build my product", "create an automation that takes this SaaS to production", or names one specific product to work on. For a fleet of many products, use 11ai-saas-fleet-automation-creator.

Auto-name a new chat session from the user's first message using a tiny one-shot LLM endpoint, called fire-and-forget from the client. Use when adding session titles to an AI chat.

Client-side wiring of @ai-sdk/react useChat — transport setup, per-session remounting, restoring history, persisting on stream completion, and the ref guards that prevent duplicate saves/titles/focus bugs. Use when building or debugging the React side of an AI chat.

Use GitHub Models as a free OpenAI-compatible inference provider for the Vercel AI SDK. Use when wiring an AI chat, title generator, or any LLM call that should run on the free GitHub Models endpoint instead of a paid API key.

Let users pick between multiple LLMs (across providers) in an AI chat — model registry, per-provider SDK instances over one gateway, per-message modelId routing, model picker UI, and per-session model persistence. Use when adding model selection or multi-provider support to an AI chat.

Manage multi-session AI chat state — session entity shape, a CRUD hook with reactive refresh, pinned-first sorting, and persistence via localStorage or a service API. Use when adding chat history, pin/rename/delete, or session switching to an AI chat.

End-to-end recipe for a grounded, tool-using AI chat in a Next.js App Router app — streaming route, tool sets, sessions, auto-titling, and client UI, using the Vercel AI SDK. Use when adding a complete AI chat surface to an app from scratch.

Design AI SDK tool sets that ground a chat assistant in a dataset — search/detail tool pairs, Zod schemas, output projection, and a token-lean "mini" tool-set variant. Use when adding or changing tools for an AI chat or agent endpoint.

The UX feature set and layout patterns for a polished AI chat surface — hint-chip empty state, message bubbles, thinking indicator, dismissible errors, sessions sidebar with pin/rename/delete, mobile fallback, scroll/focus behavior. Use when building or reviewing an AI chat UI.

Extend an AI chat into a Slack (or other messaging platform) chatbot using the Chat SDK — webhook route, mention/DM/thread handlers, streaming replies, slash-command model switching, and Redis-backed conversation state. Use when shipping the assistant as a Slack bot or adding a new messaging platform.

Fail-closed, read-only dependency security auditing across manifests, lockfiles, installed trees, registry version candidates, advisory databases, and live web sources. Enumerate every dependency and every version the configured resolver could install, then check each exact candidate for critical vulnerabilities, malware, compromised releases, install-time execution, and other host-computer risks. Use before installing or updating packages, when scanning a repository or proposed package/version, when comparing declared/locked/installed versions, or when producing an evidence-backed dependency security report.

Answer common Ant Design React questions with a compact component chooser, import patterns, API reminders, state-model guidance, and version-aware examples. Use when someone asks which component to use, how to wire a common prop or pattern, or wants a quick Ant Design reference.

Compose Ant Design data displays with Card, List, Descriptions, Statistic, Tag, Badge, Avatar, Empty, Skeleton, Result, and Progress. Use when building dashboards, detail panels, activity lists, status summaries, loading states, empty states, or error and partial-data views.

Build, review, and repair typed Ant Design forms with Form, Form.Item, validation rules, async submission, dependencies, dynamic Form.List fields, Upload normalization, and controlled values. Use when adding create or edit forms, fixing validation or initial-value behavior, or wiring submit, reset, loading, and error states.

Connect Ant Design to the surrounding React stack, covering routers, server-state and form libraries, date adapters, Tailwind or existing CSS, internationalization and locale, design tokens, icon bundling, and component testing. Use when Ant Design must cooperate with another library, when links or navigation inside components behave wrongly, when a date picker rejects the project's date type, or when styles from two systems collide.

Build and review responsive Ant Design page shells and layouts with Layout, Flex, Space, Grid, Row, and Col. Use when creating dashboards, sidebars, headers, content regions, responsive columns, or fixing overflow, height, spacing, and breakpoint behavior.

Discover, compatibility-check, install, update, or explain Ant Design's first-party agent skill for Ant Design 6. Use when asked about native Ant Design skills, agent setup, the Ant Design CLI skill, or whether an installed Ant Design skill matches this v6 operator.

Build and review Ant Design navigation with Menu, Dropdown, Breadcrumb, Tabs, Steps, and route-aware active state. Use when adding app navigation, settings sections, tabbed views, breadcrumbs, action menus, or fixing selected keys, deep links, keyboard behavior, and mobile navigation.

Implement Ant Design overlays and feedback with Modal, Drawer, Popconfirm, Alert, message, notification, Spin, and Result. Use when adding confirmations, task panels, toasts, inline errors, loading feedback, or repairing missing context, focus, close, and destructive-action behavior.

Configure and verify Ant Design in React applications, including package detection, provider placement, Next.js boundaries, styling, icons, and SSR-safe setup. Use when adding Ant Design to an app, fixing a broken installation, wiring ConfigProvider or App, or checking whether an existing setup matches the installed Ant Design version.

Build and repair typed Ant Design Tables with stable row keys, column renderers, sorting, filtering, pagination, selection, expandable rows, loading, empty states, and server-side data. Use when adding an admin or data-heavy table or fixing stale rows, incorrect pagination, filters, or selection behavior.

Configure and review Ant Design visual tokens, ConfigProvider themes, component overrides, dark or compact modes, typography, spacing, radius, and status colors. Use when establishing a design system, adding theme switching, fixing inconsistent component styling, or replacing brittle CSS overrides.

Diagnose Ant Design React failures involving missing styles, SSR or hydration, provider context, Form values, Table state, overlays, icons, dates, tokens, TypeScript, layout, and accessibility. Use when Ant Design renders incorrectly, logs warnings, loses state, or behaves differently across development, production, or themes.

Answer common AWS CLI questions with concise, safety-aware commands for identity, regions, S3, EC2, Lambda, ECS, ECR, CloudWatch, IAM, and CloudFormation. Use when the user wants a quick reference, flag explanation, or command translation.

Validate CloudFormation templates and inspect stacks, events, resources, drift, and change sets with replacement and rollback awareness. Use when a stack fails, a deployment needs preview, or infrastructure state must be explained.

Attribute account changes using CloudTrail, covering event history lookup by resource, user, or event name, the management and data event distinction, reading the identity behind an assumed role or federated session, querying a trail in Athena or CloudWatch Logs, event time windows and delivery lag, and separating a human action from an automated one. Use when someone must find who changed or deleted a resource, when an unexpected change must be attributed, or when an access question needs evidence.

Query AWS CloudWatch logs, metrics, alarms, dashboards, and time windows for operational evidence. Use when investigating failures, checking service health, finding recent errors, or validating an approved alerting change.

Report AWS spend and find what drove a change, covering Cost Explorer queries grouped by service, account, or tag, month-over-month and daily comparisons, unblended versus amortized cost, forecasts, budgets and alerts, untagged spend, and the usual sources of a sudden increase. Use when a bill must be explained, when spend has jumped, when a budget or alert must be created, or when cost must be attributed to a team or project.

Deploy a change to a running AWS service and roll it back, covering the immutable-artifact rule, deploying by digest or version, waiting for stability rather than assuming it, health checks and draining, verifying the user-visible objective, rollback by redeploying the previous identifier, and separating a code deploy from a configuration or schema change. Use when a change must reach a running service, when a deploy must be verified, or when a bad deploy must be reverted.

Inspect and operate EC2 instances, status checks, volumes, tags, and security groups with explicit target resolution and safety gates. Use when starting, stopping, rebooting, connecting to, diagnosing, or inventorying EC2 resources.

Inspect Amazon ECR repositories, image tags, digests, scan findings, and Docker authentication with reproducible, safety-aware workflows. Use when publishing, pulling, identifying, or troubleshooting container images in ECR.

Inspect Amazon ECS clusters, services, tasks, task definitions, deployments, and execution behavior with bounded targets and rollout verification. Use when an ECS service is unhealthy, a task will not start, or a deployment needs investigation.

Inspect AWS CLI profiles, credentials, identity, region, SSO, and execution context safely. Use when the AWS account, role, region, profile, or CLI setup is unknown or when a command might target the wrong environment.

Inspect AWS IAM users, roles, policies, permission boundaries, trust relationships, and simulated access without weakening security. Use when an action is denied, a role is unclear, or access needs evidence-based analysis.

Connect AWS to the systems around it, covering CI pipeline authentication with short-lived OpenID Connect roles, container image publishing to ECR, infrastructure-as-code state and drift, application runtime configuration from Secrets Manager and Parameter Store, and local development against cloud resources. Use when a pipeline needs AWS credentials, when a deploy must publish an image or update a service, when an application must read configuration at runtime, or when local development needs to reach a cloud resource.

Inspect, invoke, update, publish, and troubleshoot AWS Lambda functions with explicit aliases, versions, payloads, and logs. Use when a function fails, needs a controlled test, or requires a carefully scoped deployment change.

Discover, compatibility-check, install, update, or explain AWS's first-party Agent Toolkit skills for AWS CLI v2. Use when asked about AWS native skills, Agent Toolkit for AWS, aws agent-toolkit, or whether installed AWS skills match this AWS CLI v2 operator.

Inspect and operate RDS and Aurora databases, covering instance and cluster state, endpoints and parameter groups, snapshots and point-in-time restore, storage and connection metrics, maintenance and pending modifications, failover, and the difference between an immediate change and one deferred to a maintenance window. Use when a database must be inspected, snapshotted, restored, resized, or its maintenance state understood.

Inspect and change Route 53 DNS, covering hosted zones and delegation, record types and alias records, change batches and propagation, time-to-live choices, health checks and failover routing, private zones, and diagnosing a lookup that returns the wrong answer or nothing. Use when a DNS record must be read or changed, when a domain does not resolve, or when a cutover needs a safe time-to-live plan.

Operate AWS S3 buckets and objects with explicit paths, region checks, dry runs, and post-change verification. Use when listing, inspecting, copying, syncing, uploading, downloading, or troubleshooting S3 data and bucket access.

Read, create, and rotate values in AWS Secrets Manager and SSM Parameter Store without printing them, covering listing by name, retrieving a single field, versions and staging labels, rotation, encryption keys, resource policies, and choosing between the two stores. Use when an application needs a secret or parameter, when a value must be created or rotated, or when a secret has to be inspected without disclosing it.

Install the AWS CLI and configure profiles, IAM Identity Center single sign-on, static access keys, role assumption, default regions, output formats, and credential precedence, then verify the identity the CLI actually resolves. Use when the AWS CLI is missing or out of date, when a profile must be created or repaired, when single sign-on needs configuring, or when the user asks how to get credentials working on a new machine.

Reach EC2 instances and private services through AWS Systems Manager, covering Session Manager shells, Run Command across a target set, port forwarding to a private database, session logging, and the agent and instance-profile prerequisites. Use when an instance must be reached without a bastion or an inbound rule, when a command must run across several instances, or when a private endpoint must be forwarded to a local port.

Diagnose AWS CLI and service failures from reproducible evidence, covering credentials, account and region context, authorization, throttling, resource state, networking, logs, deployments, and eventual consistency. Use when an AWS command errors or a resource behaves unexpectedly.

Inspect AWS networking and prove reachability, covering VPCs and subnets, route tables and gateways, security groups and network ACLs, the stateful versus stateless distinction, Reachability Analyzer, flow logs, and endpoints for private service access. Use when traffic cannot reach a resource, when a security group or route must be understood or changed, or when a network path must be proven rather than guessed.

Answer quick Bash questions with a compact reference for strict mode, quoting, parameter expansion and defaults, test operators, conditionals and loops, arrays, functions, redirection, process substitution, exit status, and the common text and file commands. Use when someone asks for Bash syntax, how an expansion or test operator is written, or wants a fast lookup rather than a guided workflow.

Inspect which shell is running and which one a script will use, the Bash version and available features, enabled shell options, PATH and command resolution, exported variables, startup file order, and locale settings, without changing anything. Use before writing or running a script, when a command behaves differently in a script than in a terminal, when a Bash feature is unavailable, or when the user asks whether the shell is set up.

Find, inspect, copy, move, archive, and delete files from the shell with previewed and scoped commands, covering find predicates, safe deletion, permissions and ownership, symlinks, disk usage, atomic writes, and handling filenames with spaces or leading dashes. Use when files must be located or reorganized, when disk space must be traced, when permissions are wrong, or before running any command that removes or overwrites files.

Wire Bash scripts into the systems that run them, covering package scripts, continuous integration steps, Git hooks, cron and systemd timers, container entrypoints, argument and environment contracts, exit codes as gates, logging to a collector, and locking so two runs cannot overlap. Use when a script must run on a schedule, in a pipeline, on commit, or as a container entrypoint, or when a script works by hand but not where it is actually invoked.

Run, background, monitor, and stop processes from the shell, covering exit status and PIPESTATUS, job control, nohup and disown, signals and graceful termination, waiting on background work, timeouts, port and file holders, resource usage, and identifying a process precisely before killing it. Use when a command must run in the background or under a timeout, when a port is occupied, when a process must be stopped, or when a script hangs.

Write and repair Bash scripts with strict mode, correct quoting, argument parsing and validation, functions and local scope, arrays, cleanup traps, temporary files, clear exit codes, and messages on the right stream. Use when a script must be written or restructured, when a script fails silently or continues past an error, when word splitting breaks on filenames with spaces, or when temporary files are left behind.

Install a current Bash alongside the system shell, choose the right startup file for a setting, extend PATH without breaking it, add shellcheck and shfmt, and set up an executable script skeleton with a shebang that resolves to the intended interpreter. Use when Bash is too old for a needed feature, when a PATH or environment change must persist, when script tooling is missing, or when a new script must be scaffolded.

Lint and test Bash scripts, covering shellcheck severity and directives, shfmt formatting, syntax-only parsing, bats test structure with setup and teardown, stubbing external commands, asserting exit status and output, testing failure paths, and running the checks in a pipeline. Use when a script needs coverage or linting, when shellcheck reports warnings that must be understood or suppressed, or when a script's failure behaviour has never been exercised.

Filter, extract, and transform text at the shell with grep, sed, awk, cut, sort, uniq, tr, jq, and xargs, covering pattern choice, field handling, in-place editing, delimiter and locale pitfalls, streaming large files, and building pipelines that fail loudly. Use when text or log output must be searched, reshaped, counted, or converted, or when an existing pipeline returns the wrong fields or silently produces nothing.

Diagnose failing or misbehaving Bash scripts from reproducible evidence, covering syntax and interpreter mismatches, unbound variables, word splitting, silent pipeline failures, missing commands and PATH differences, permission and line-ending problems, hangs waiting on input, traps not firing, and exit codes. Use when a script fails, produces wrong output, works in a terminal but not in a script or cron job, or hangs without finishing.

Answer questions about the 11ai-benchmarks plugin: which reporting skill fits a job, how the analyzers discover and classify harness usage, how pricing, timing, and cost states are derived, what each report section and warning means, and how the skills are maintained. Routes every question to the plugin's own contracts, references, scripts, and tests and answers with a citation. Use when a user asks how the benchmark skills behave, why a report shows a value, which benchmarks skill to run, or what a report section means.

Inspect all readable Codex, Claude Code, Claude Cowork, Gemini CLI, Cline, Roo Code, and OpenCode usage stores across the machine, plus exported usage files or folders from unsupported harnesses included on request; detect unavailable remote Cowork sessions; classify harness surfaces and billing modes; normalize token counters; calculate attributable USD costs; measure wall and estimated active time; and write Markdown and standalone HTML reports. Use for global LLM spend, token usage, model and effort cost, thread timing, harness coverage, cross-project analysis, or machine-wide reports over exported usage.

Refresh and preserve the time-versioned token-pricing history used by the 11ai LLM cost reports from official AI-lab sources, synchronize the project, global, and single-thread copies, and validate their schemas, rate periods, resolver, and equality. Use when model prices, discounts, effective dates, aliases, providers, or pricing caveats have changed, when historical-rate backfill is requested, or when adding pricing support for another AI lab.

Inspect a repository plus its project-attributed Codex, Claude Code, Claude Cowork, Gemini CLI, Cline, Roo Code, and OpenCode records; detect unavailable remote Cowork sessions; classify harness surfaces and billing modes; normalize provider token counters; calculate attributable USD costs; measure wall and estimated active time; and write matching timestamped Markdown and HTML reports. Use for project LLM spend, token usage, model and effort cost, thread timing, harness coverage, or recursive cost analysis.

Inspect one project-attributed Codex, Claude Code, Claude Cowork, Gemini CLI, Cline, Roo Code, OpenCode, or exported usage thread plus recursively spawned Codex sub-agent threads; detect unavailable remote Cowork sessions; classify its surface and billing mode; normalize token counters; calculate attributable USD cost; measure wall and estimated active time; and write matching timestamped reports. Use for the cost, tokens, effort, timing, provenance, or harness coverage of one exact thread tree.

Add or retrofit white-label blog author features: author metadata and tags, multi-author post attribution, resolved author previews, post-page bylines, clickable author profile/detail pages, author post indexes, library Authors browse tabs, avatar or initials fallbacks, metadata/SEO, validation, and tests. Use when creating, recreating, repairing, or auditing author profiles, contributor pages, author filtering, bylines, author slugs, or many-to-many author/post relationships in a file-backed, CMS-backed, Markdown, MDX, rich-text, React, Next.js, or other web blog.

Orchestrate the complete 11ai blog-builder plugin to recreate a file-backed editorial blog with publications, posts, author profiles, library browsing, and responsive article table of contents. Use when a user asks to build, recreate, migrate, or audit an entire blog experience rather than only one subsystem. Treat 11ai-blog-ui as an optional standalone visual add-on only when requested.

Build or retrofit a white-label, file-backed blog CMS organized as publications with nested posts, including a single combined library that switches between Posts and Publications (default Posts), list/card display modes (default List), typed Markdown content, search, AND-tag filters, sorting, publication detail pages, and post readers. Use for multi-publication blogs, journals, editorial sites, author blogs, or Git-managed Next.js content systems without a database. Pair with 11ai-blog-authors when the library should also include an Authors content type.

Format, normalize, migrate, or audit generated/draft editorial content for an 11ai blog content model: publication/post metadata, author IDs, tags, excerpts, dates, slugs, and Markdown bodies with the expected leading H1, h2-h5 body headings, GFM tables/lists, fenced code, images, links, YouTube embeds, and renderer/TOC-safe structure. Use when converting raw prose, outlines, AI drafts, imported articles, or Markdown files into the exact format consumed by the 11ai blog builder.

Generate user-requested editorial blog content in the 11ai blog format: publication ideas, posts, series, author profiles, titles, excerpts, tags, slugs, Markdown bodies, code examples, tables, images/link placeholders, YouTube embeds, and metadata ready for the 11ai file-backed blog content model. Use when asked to draft, create, brainstorm, expand, rewrite, or seed blog content that should fit an 11ai blog.

Build or retrofit a polished blog Markdown renderer using react-markdown, remark-gfm, deterministic heading IDs, TOC-aligned heading extraction, fenced code blocks with language metadata, internal/external link handling, images, tables, task lists, YouTube embeds, a Markdown components demo page, and tests. Use when adding, recreating, repairing, or auditing Markdown/MDX-like blog prose rendering, rich Markdown components, GFM support, custom embeds, or renderer/TOC parity in React, Next.js, or another web blog.

Build or retrofit a white-label, responsive, accessible table of contents for Markdown, MDX, CMS, or rich-text blog articles, including deterministic heading IDs, duplicate handling, native hash deep links, sticky desktop and collapsible mobile navigation, scroll-aware active-section highlighting, fixed-header offsets, and tests. Use when adding, recreating, repairing, or auditing an article “On this page” index, scrollspy, heading anchors, or TOC in React, Next.js, or another web project.

Apply or recreate the 11ai-style polished editorial blog UI: dark/light tokenized theme, rounded hero card, collection browser controls, list/card result surfaces, publication headers, post reader layout, author cards, byline chips, responsive spacing, focus states, and accessible Tailwind/shadcn styling. Use after blog data/routes exist or when a user asks to make a blog visually match the 11ai editorial library.

Design and build a white-label marketing page that sells custom website and platform-building services, using an editorial hero, service positioning, deliverables, process, proof, outcomes, FAQ, and repeated conversion CTAs. Use when creating or improving a platform services page, web-development offer page, author/creator platform pitch, agency landing page, or contact-focused service CTA inside a Next.js or React site.

Build or retrofit a white-label, file-backed publications CMS with publications, nested chapters, typed metadata, Markdown reading pages, search, AND-tag filters, sorting, optional synopsis and author notes, previous/next navigation, and list/card display modes defaulting to list. Use for Next.js author libraries, serial publishing sites, publications-and-chapters catalogs, or requests to reproduce this exact Git-managed content workflow without a database.

Scan for abandoned AI agent threads across harnesses — Claude Code, OpenAI Codex CLI, Gemini CLI, Goose, OpenCode — covering old conversation transcripts and leftover per-session scratchpad directories, report them in a compact table, ask the user which to delete, then remove only what they picked. Use whenever the user wants to clean up agent sessions, threads, transcripts, or old conversations from any coding agent, complains about accumulated session junk or temp directories from agents, or asks how much space their agent history is taking — even if they only mention one session or one tool.

Scan a git repository for abandoned worktrees — the isolated working copies AI agents (Claude Code, Codex CLI, Gemini CLI, Cursor, Aider, or any other harness) create and leave behind — report each one's age, branch, and safety in a compact table, ask the user which to remove, then clean up only what they picked. Use whenever the user wants to clean up worktrees, mentions leftover / stale / agent-created worktrees or branches, notices `git worktree list` is full of junk, or complains about mystery sibling directories of their repo — even if they only mention one.

Create a new 11ai cleanup skill for any kind of idle, hanging, or abandoned resource — ports, node_modules folders, caches, agent sessions, Docker containers, stale branches, whatever the user names. Use whenever the user asks to create, make, or generate a cleanup skill for something, wants a scan-and-clean workflow for a resource, or wants to extend the 11ai cleanup skill family. The generated skill always follows the same pattern: scan → judge → report → ask → execute → verify, and never destroys anything the user didn't explicitly pick.

Scan for idle, hanging, or abandoned local ports (usually dev servers left behind by AI agents), report what's open in a compact table, ask the user which ones to clean up, then kill only the processes they picked. Use whenever the user wants to clean up ports or processes, asks "what's running on my ports", complains a port is already in use / EADDRINUSE, mentions leftover or zombie dev servers, or wants to free up a port — even if they only name a single port.

Scan for node_modules directories in stale or abandoned projects, report each one's size and age in a compact table, ask the user which to delete, then remove only what they picked. Use whenever the user wants to clean up node_modules, reclaim disk space from old JavaScript/Node projects, complains their disk is almost full, or mentions bloated / forgotten / duplicate node_modules folders — even if they only mention one project.

Wire and repair Clerk sign-in and sign-up flows, covering prebuilt components on catch-all routes versus hosted pages, custom flows with the sign-in and sign-up hooks, redirect configuration and returning a user to where they started, social connections, multi-factor and verification steps, email and password strategies, and an onboarding step after sign-up. Use when sign-in or sign-up must be added or customized, when a flow 404s partway through, or when redirects send users to the wrong place.

Answer quick Clerk questions with a compact reference for environment keys and their scope, prebuilt components, client and server hooks and helpers, middleware and route protection, the backend API for users and organizations, session claims and metadata, webhook verification, and the test versus live instance distinction. Use when someone asks which Clerk component, helper, or backend call to use, or wants a fast lookup rather than a guided workflow.

Inspect which Clerk instance an application targets, which keys it holds and whether any secret is reachable from client code, the middleware and provider wiring, configured sign-in and sign-up paths and redirect URLs, whether organizations are enabled, session token claims, and which webhook endpoints exist, without changing anything. Use before a Clerk operation, when sign-in or route protection misbehaves, when a user seems missing, or when the user asks whether Clerk is set up.

Connect Clerk to the systems around it, covering framework SDKs beyond Next.js, mirroring users and organizations into a local database, scoping every query by the session's organization, protecting an API or another service with a verified token, tying billing to an organization, third-party token templates for a backend that validates independently, and pipeline test and deploy steps. Use when Clerk identity must reach a local table, when another service must trust a Clerk session, or when tenant scoping or billing must be wired.

Discover, compatibility-check, install, update, or explain Clerk's first-party agent skills for Clerk Core 3. Use when asked about Clerk native skills, clerk/skills, agent setup, or whether installed Clerk skills match this Core 3 operator and the project's SDK.

Manage Clerk organizations and their members, covering enabling organizations for an instance, creating organizations and mapping them to a local tenant, memberships with roles and permissions, custom roles, invitations, the active organization on a session and switching it, scoping every query by orgId, and deleting an organization. Use when multi-tenancy must be added, when memberships or roles must change, when orgId is undefined, or when one tenant can see another's data.

Protect routes and read Clerk sessions on the server, covering middleware default-deny protection, auth and auth.protect in server components and route handlers, permission and role checks with has, session token claims and their size limit, verifying a bearer token at an API boundary, session lifetime and revocation, and why component-level gating is not access control. Use when routes must be protected, when auth throws, when a permission check must be added, or when another service must trust a Clerk session.

Set up Clerk in an application from zero, covering the publishable and secret keys and their scope, the provider at the root, middleware with default-deny route protection, sign-in and sign-up routes, redirect configuration, a first protected page, and keeping the development instance separate from production. Use when an application has no Clerk wiring, when middleware or the provider is missing, or when the user asks how to add Clerk.

Diagnose Clerk failures from reproducible evidence, covering wrong instance and mismatched key pairs, auth throwing because middleware is missing or its matcher excludes the route, sign-in redirect loops, flows that 404 partway through, undefined orgId, oversized session tokens, stale session claims, webhook signature failures and protected webhook routes, and authorization that exists only in components. Use when sign-in or protection misbehaves, when a user seems missing, when a flow breaks mid-step, or when events arrive but nothing happens.

Read and change Clerk user records from the server, covering user lookup and pagination, creating and updating users, the three metadata fields and which are user-writable, email and phone identifiers and verification, banning and locking versus deleting, session revocation as part of removing access, and mirroring users into a local table. Use when a user record must be inspected or corrected, when metadata must be set, when a user must be removed or suspended, or when local records must match Clerk.

Receive and handle Clerk webhook events safely, covering endpoint registration per instance, signature verification against the raw request body, keeping the route public in middleware, idempotency keyed on the event id, acknowledging before processing, handling user and organization and membership events, out-of-order delivery, retries, local delivery through a tunnel, and reconciling a mirror when events were missed. Use when a local database must track Clerk users or organizations, when events arrive but nothing happens, when verification fails, or when an event applied twice.

Set up and maintain semantic-release based release automation for repositories that need automated versioning, changelog generation, GitHub release creation, release commits, and release workflows on pushes to main, without publishing packages to npm or GitHub Packages. Use when Codex needs to add or update semantic-release, `.releaserc.js`, or GitHub Actions release workflows focused on changelogs and GitHub releases only.

Prepare, publish, and automate releases for npm packages, especially scoped packages that need package.json fixes, publish scripts, npm dry-run checks, `.env`-managed `NPM_TOKEN` handling, npm org token setup, GitHub Actions secrets, semantic-release workflows, npmjs.org publishing, GitHub Packages publishing, GitHub Releases, or release troubleshooting. Use when Codex needs to make a repo publish-ready, verify what npm will ship, configure automated publishing, or diagnose failures involving package contents, registry auth, 2FA, tokens, tags, changelogs, GitHub Actions, or semantic-release.

Add or maintain Playwright testing for web applications, including unit-style Playwright tests, browser E2E tests, separate Playwright configs, npm scripts, GitHub Actions CI wiring, browser installation, localhost web server setup, mock environment variables for auth-dependent apps, ignored test artifacts, and troubleshooting CI failures.

Add, configure, or verify Vercel Web Analytics in web applications using the official `@vercel/analytics` package. Use when Codex needs to enable page-view analytics, integrate the Analytics component into Next.js App Router or Pages Router projects, diagnose missing Vercel analytics traffic, or confirm an existing installation without adding a separate analytics provider.

Wrap any repository task in a branch-and-pull-request Git workflow: identify the task, create or reuse a well-named dedicated branch from a clean tree, perform and quality-check the work, open a pull request with full details and screenshots when applicable, run two independent review subagents that critique the PR in review comments, address their feedback, and re-verify. Merges or closes the pull request only when the user explicitly asks. Aborts, reverts session changes, and restores a clean tree if the worktree becomes unmanageable or Git troubleshooting starts to outweigh the task. Use when repository work should land through a branch and reviewed pull request rather than directly on main — pair it with any task skill that does the work itself.

Wrap any repository task in a safe main-branch Git transaction: verify a clean tree, fetch and pull the latest changes (fast-forwarding or cleanly merging incoming work), perform the requested task, quality-check it, and report everything done. Stages, commits, or pushes only when the user explicitly asks. Aborts, reverts session changes, and restores a clean tree if the worktree becomes unmanageable or Git troubleshooting starts to outweigh the task. Use when working directly on the main branch of a repository and the work needs clean synchronization, disciplined rollback, and a full session report — pair it with any task skill that does the work itself.

Compress markdown and text guidance files locally without external LLM or Claude CLI calls. Use when Codex needs to shorten SKILL.md, CLAUDE.md, prompts, runbooks, or other natural-language instruction files while preserving headings, fenced code, inline code, links, URLs, paths, and markdown structure.

Scaffold a version-focused 11ai operator plugin for a tool, CLI, service, or SDK so it matches the existing operator plugins exactly, covering version selection, identity naming, first-party native-skill discovery and compatibility, skill archetypes, safety, manifests, and catalog wiring. Use when asked to create or extend an operator plugin, add skills for a technology, or check that an operator plugin follows the house pattern and targets the requested or latest stable version.

Analyze an existing 11ai plugin and create or update its FAQ skill: a question router that maps user questions about skill behavior, usage, outputs, and troubleshooting to the plugin's own contracts, references, scripts, and tests, plus a comparison table and glossary the siblings do not carry. Use when asked to add a FAQ skill to a plugin, refresh a plugin FAQ after skills changed, or check that a FAQ still covers its plugin.

The house styleguide for generated, self-contained HTML reports: canonical design tokens with a dark default and a light toggle, embedded Inter and Geist Mono fonts with cross-platform fallback stacks, collapsed-disclosure section structure, and a table interaction contract covering descending-first sorting, multi-row click highlighting that survives sorting, and column resizing down to zero width, none of it persisting across reloads. Ships copyable tokens.css and fonts.css, a complete working report-template.html, the interaction spec with its known failure modes, and a regression checklist against previous generations. Use when building, styling, restyling, or reviewing a generated HTML or markdown report, or when asked to apply the house report style.

Reverse engineer a locally cloned repo — extract core logic, data flows, and key implementation pieces (sanitized of all branded/personal/company information), then produce a single markdown blueprint with instructions to rebuild it better using modern technologies and best practices. Use when the user wants to study, reverse engineer, modernize, or rebuild an existing repo.

Apply the house web design language to a Next.js application built with shadcn components and Tailwind CSS v4: oklch design tokens in light and dark modes, square corners with hairline borders, a single accent family with a five-step chart ramp, Inter and Geist Mono via next/font variables, next-themes with a system default and a d hotkey, and dual-theme code highlighting. Tokens and fonts are user-parameterized: whatever the user specifies is kept, missing tokens and fonts are generated as balanced equivalents, a single accent expands into a full palette, a one-mode palette derives its counterpart with contrast gates enforced, and the bundled defaults apply when nothing is specified. Use when styling, theming, or restyling a Next.js and shadcn application, generating design tokens from a brand color, or asked to apply the house www style.

Speak in the short register, always extremely pragmatic and objective: extremely concise lines, grammar sacrificed for concision, lists over paragraphs, no em dashes, an example or snippet for every claim, sources cited. Four working modes on top: a fix beside every problem found when reviewing, no file changes while planning until the action plan is approved, a pointer to where changes landed when implementing, and a copyable conventional commit message with scope after any repo work. Use when the user asks for terse, punchy, or no-fluff replies, sets a brevity rule for the session, or says an answer reads long-winded, padded, or hedged.

Review, critique, and roast code, documents, designs, or any work product for improvements — read-only, no file edits. Use whenever the user asks to review, critique, roast, tear apart, poke holes in, or get honest/brutal feedback on something, or asks "what's wrong with this" or "how would you improve this", even if they don't say the word "roast". Delivers blunt, prioritized suggestions only; never modifies files.

Write Convex actions and scheduled work, covering the Node runtime directive, calling external services with timeouts and bounded retries, reading secrets from deployment environment variables, the loss of transactional guarantees across runQuery and runMutation, idempotency for retried work, scheduler runAfter and runAt, cron definitions, HTTP endpoints for inbound webhooks, and keeping actions internal. Use when a function must call an external API, when work must run later or on a schedule, when an inbound webhook must be received, or when an action is partially applying its changes.

Wire authentication into Convex and enforce access inside functions, covering the auth configuration file and identity provider domain and application id, the authenticated client provider, reading identity with getUserIdentity, mapping the provider subject onto a local user row, per-document authorization checks, server-side rendering with a token, and why client-side gating is not access control. Use when functions must know who is calling, when identity is null despite a signed-in user, or when access must be scoped per document.

Answer quick Convex questions with a compact reference for CLI commands, the three function types and when each applies, argument validators, schema and index definitions, database reader and writer methods, query and pagination hooks, scheduling and crons, file storage calls, environment variables, and generated API imports. Use when someone asks which Convex command, function type, or client call to use, or wants a fast lookup rather than a guided workflow.

Deploy Convex and manage its environments, covering the difference between the development watcher and a production deploy, deploy keys for a pipeline, environment variables per deployment, preview deployments for branches, build integration with a frontend deploy, data export and import between deployments, backward-compatible function and schema rollout, and rollback. Use when a change must reach production, when a pipeline must deploy Convex, when environment variables differ between deployments, or when a deploy broke a running client.

Inspect which Convex deployment is active, whether the project is linked and the generated API exists, the deployment URL the application reads, environment variables set on each deployment, the schema and index state, function and cron inventory, and recent logs, without changing anything. Use before a Convex operation, when it is unclear whether a command targets development or production, when generated types are missing, or when the user asks whether Convex is set up.

Store and serve files through Convex storage, covering upload URLs generated in a mutation, direct browser uploads, recording the storage id on a document, serving with getUrl or an HTTP action, content type and size validation, authorizing access per file, deleting a file alongside its referencing row, and finding orphaned files. Use when files must be uploaded or served, when a stored file URL returns nothing, or when file access must be restricted to its owner.

Write and repair Convex queries and mutations, covering argument validators, public versus internal functions, authorization inside the handler, index-backed reads, pagination, transactional guarantees and read and write limits, helper functions shared between handlers, optimistic updates on the client, and errors surfaced to callers. Use when a function must be added or fixed, when a query is slow or hits a read limit, when a mutation must stay atomic, or when a function is callable by clients that should not reach it.

Connect Convex to the systems around it, covering React and Next.js clients with server-side rendering, identity providers through the auth config, external services called from actions, inbound webhooks on HTTP endpoints, mirroring an external system's records into Convex tables, file and email providers, and pipeline test and deploy steps. Use when a frontend must consume Convex reactively, when an identity provider or payment service must be wired in, or when another system's data must be kept in step with Convex.

Discover, compatibility-check, install, update, or explain Convex's first-party agent skills. Use when asked about Convex native skills, get-convex/agent-skills, agent setup, or whether installed Convex skills match the project's current Convex package and runtime.

Define and change Convex tables, covering field validators, optional and union types, typed document references, index design for the queries that exist, search indexes, schema validation against existing documents, migrating data when a field's shape changes, and the difference between a development push and a production deploy. Use when a table must be added or reshaped, when a schema push is rejected, when a query needs an index, or when a field must change type without losing data.

Set up a Convex project from zero, covering package install, project initialization and deployment linking, the development watcher that generates the API, the client provider for a framework, environment variables for local and hosted use, a first schema and function, and separating the development deployment from production. Use when a repository has no Convex directory, when the generated API is missing, when a project must be linked to a deployment, or when the user asks how to get Convex running.

Diagnose Convex failures from reproducible evidence, covering a missing generated API, queries stuck loading, null identity, rejected schema pushes, read and write limit errors from unindexed queries, argument validator failures, actions partially applying changes, missing deployment environment variables after deploy, broken open clients after an incompatible deploy, and development versus production data confusion. Use when a function errors, when a query never resolves, when a deploy broke something, or when it works locally and fails in production.

Inspect and control CSS3 origins, cascade layers, scope, specificity, inheritance, custom properties, selectors, and source order. Use when styles do not apply, overrides are fragile, specificity is escalating, or stylesheet ownership must be clarified.

Look up CSS3 inspection, setup, validation, and focused operation patterns across cascade and selectors, layout, responsive design, theming, motion. Use when the user wants a concise command or pattern reference instead of a guided workflow.

Inspect the installed CSS3 toolchain, project configuration, source entry points, generated output, target environments, and validation scripts without changing files or dependencies. Use before CSS3 work, when the project conventions are unknown, or when the user asks what is configured.

Connect CSS3 to the surrounding build system, framework, tests, linting, formatting, CI, deployment target, and runtime boundaries while preserving ownership between layers. Use when CSS3 must work with another project subsystem or behave consistently from local development through production.

Build and repair CSS3 layout using normal flow, flexbox, grid, positioning, intrinsic sizing, overflow, aspect ratios, and containment. Use when creating page or component layout, fixing overflow and alignment, or removing brittle positioning.

Create and repair CSS3 transitions, keyframe animations, transforms, view transitions, and reduced-motion alternatives with performance and accessibility checks. Use when adding animation, fixing jank or unexpected precedence, or honoring motion preferences.

Implement responsive CSS3 with fluid sizing, media queries, container queries, logical properties, responsive typography, and input or preference queries. Use when a layout must adapt across viewports or containers, breakpoints are failing, or mobile and desktop behavior diverges.

Install and configure CSS3 from zero, including the project-local toolchain, source entry point, baseline configuration, validation scripts, ignored generated output, and a minimal verified example. Use when a project has no CSS3 setup or the user explicitly asks to initialize it.

Design and operate CSS3 themes with custom-property tokens, color schemes, contrast, dark mode, forced colors, component overrides, and user preference handling. Use when adding a theme, changing design tokens, fixing contrast, or making components consistent across modes.

Diagnose CSS3 failures involving configuration, parsing, compilation, runtime behavior, generated output, browser or server differences, tests, integrations, and performance without masking the original error. Use when CSS3 code fails a check, behaves differently across environments, or produces unexpected output.

Build Docker images from a repository Dockerfile with context, ignore-file, tag, cache, and post-build verification checks. Use when the user asks to build or rebuild an image locally, fix a Docker build, or turn an application directory into a tagged image.

Answer Docker command questions with a compact, safety-aware reference for containers, images, Compose, storage, cleanup, and diagnostics. Use when the user asks what Docker command or flag to use, wants a quick Docker reference, or needs a command translated into plain language.

Measure Docker disk usage, identify unused containers, images, volumes, networks, and build cache, then remove only resources the user explicitly selects. Use when Docker storage is growing, the user asks to prune Docker, or cleanup candidates need a safety review.

Operate Docker Compose applications by locating the project file, validating configuration, inspecting services, viewing logs, and managing startup or shutdown safely. Use when the user mentions Compose, a compose.yaml file, a multi-container app, or service-level operations.

Perform common Docker container operations including run, list, inspect, logs, exec, start, stop, restart, and remove with evidence-first safety checks. Use when the user asks to operate an individual container or wants help understanding its state.

Inspect Docker installation, client and daemon health, active contexts, Compose availability, and local permissions without changing the environment. Use when Docker is not responding, the user asks whether Docker is installed or healthy, or a task needs a safe environment check first.

Manage Docker images with pull, list, inspect, history, tag, remove, and disk-usage workflows. Use when the user needs to find an image, compare tags, download an image, understand image layers, or remove reviewed image data.

Connect Docker to the systems around it, covering continuous integration builds with layer caching, image publishing to registries with short-lived credentials, Compose as a local development dependency stack, development containers, and the image contract an orchestrator such as ECS or Kubernetes depends on. Use when a pipeline must build or publish an image, when local services need to run alongside an application, or when an image must satisfy a deployment target's health, signal, and configuration expectations.

Handle Docker registry workflows for login, logout, pull, tag, and push while protecting credentials and verifying exact image destinations. Use when the user needs to move an image between a local Docker daemon and a registry.

Install Docker Engine or Docker Desktop and configure contexts, the Compose plugin, buildx builders, socket permissions, registry credential helpers, and daemon resource limits, then verify the client reaches the intended daemon. Use when Docker is not installed, when the daemon is unreachable on a new machine, when a context or builder must be created, or when the user asks how to get Docker working.

Diagnose Docker and Compose failures from reproducible evidence, covering daemon access, contexts, pulls, builds, container exits, health checks, ports, volumes, networks, and configuration. Use when the user reports a Docker error, a service will not start, or a container behaves unexpectedly.

Inspect and manage Docker named volumes and user-defined networks, including create, connect, disconnect, and remove workflows with checks for live containers and persistent data. Use when a Docker task concerns storage, service connectivity, or isolated project networks.

Find the commit that introduced a regression with git bisect, covering a reliable reproduction first, choosing good and bad endpoints, manual and automated runs with a test script, exit codes including skip, narrowing to a path, recovering from a wrong verdict, and always resetting afterwards. Use when a bug appeared between two known points, when a regression must be attributed to a commit, or when a bisect session was left half-finished.

List, create, switch, rename, and delete local Git branches with upstream and unmerged-work safeguards. Use for one focused branch-management operation, not a full pull-request workflow.

Answer quick Git command, flag, and workflow questions with a compact safety-aware reference. Use when the user asks what command to run, what a Git flag means, or which simple operation fits a situation.

Create one reviewed local Git commit from explicitly selected staged changes without pushing or amending by default. Use when the user asks to commit work and wants a clear message and post-commit verification.

Choose, compose, and validate Conventional Commits 1.0.0 messages for task commits created by any commit workflow. Use whenever an agent or user-authorized workflow needs to commit its work, including alongside 11ai-operator-git-commit. This skill governs the message only; it does not authorize staging, committing, amending, pushing, or rewriting history.

Answer questions about the 11ai Git operator plugin: which of its skills fits a task, what each skill promises and refuses to do, which actions always need explicit approval, how staging, committing, syncing, branching, tagging, stashing, recovery, and troubleshooting behave, and where the command and triage references live. Routes every question to the plugin's own contracts and references and answers with a citation. Use when a user asks how the Git operator skills behave, which one to run, or what a skill will and will not touch. For questions about Git itself rather than these skills, use the cheatsheet skill instead.

Write, install, debug, and bypass local Git hooks, covering the hook events and their arguments, why hooks are not committed and how hooksPath changes that, staged-file-only checks, exit codes and blocking behaviour, reading stdin for pre-push and pre-receive, keeping hooks fast, and diagnosing a hook that does not fire. Use when a hook must be added or repaired, when a hook blocks work incorrectly, or when a hook is silently not running.

Connect Git to the systems around it, covering remotes and hosting providers, pull-request tooling, continuous integration triggers, local hooks through husky or lefthook, commit-message and lint gates, large file storage, and submodules or subtrees for vendored code. Use when a repository needs a remote or a second one, when a pipeline trigger does not fire, when a pre-commit gate must be added or is blocking work, or when another repository must be embedded in this one.

Open, inspect, review, and land pull requests from the command line, covering a reviewable branch and description, draft state, reading check results and failing logs, review comments and approvals, keeping a branch current without losing review context, merge strategies and what each does to history, and cleaning up after a merge. Use when a pull request must be created, when its checks or reviews must be read, when review feedback must be addressed, or when it is ready to land.

Recover or undo Git work using restore, revert, reflog, and carefully scoped reset decisions. Use when the user asks to discard local edits, undo a commit, recover a lost tip, or repair a mistaken local Git action.

Install Git and configure identity, default branch name, credential helpers, commit signing with SSH or GPG, global ignore rules, line-ending behaviour, merge and pull defaults, and safe directory ownership, then verify the configuration a commit will actually use. Use when Git is unconfigured on a new machine, when commits carry the wrong author or fail to sign, when pushes prompt for a password, or when the user asks how to set Git up.

Review and stage only the intended Git paths or hunks, or safely unstage them without committing. Use when the user wants to prepare a commit, inspect the index, or remove a path from staging.

Temporarily shelve selected Git work, inspect existing stashes, and apply or drop a stash deliberately. Use when the user explicitly wants to pause work without committing it.

Inspect a Git repository's identity, worktree, diffs, history, branches, and upstream state without changing files or refs. Use when the user asks what changed, whether the tree is clean, where HEAD points, or what should happen next.

Operate Git submodules predictably, covering adding one and what gets committed, cloning and initializing recursively, updating to a pinned commit versus tracking a branch, committing a pointer change, running commands across submodules, removing one completely, and the settings that stop a plain clone or pull leaving them empty or stale. Use when a submodule must be added, updated, pinned, or removed, or when a clone has empty submodule directories.

Compare a local branch with its remote, fetch updates, fast-forward or pull deliberately, and push a named branch when explicitly requested. Use when the user asks to synchronize Git state or resolve ahead and behind status.

Create, sign, publish, and correct Git tags, covering annotated versus lightweight tags, semantic version naming, signing and verification, pushing a single tag rather than all of them, listing and describing the nearest tag, and the rules for retagging a tag that has already been published. Use when a release must be tagged, when a tag must be signed or verified, when a tag points at the wrong commit, or when a tag must be deleted locally and remotely.

Diagnose Git and repository-state failures from reproducible evidence, covering dirty trees, conflicts, detached HEAD, upstream divergence, rejected pushes, remotes, credentials, and recovery. Use when Git reports an error or the repository behaves unexpectedly.

Add, list, move, and remove Git worktrees, covering a second checkout of the same repository, the one-branch-per-worktree rule, detached and new-branch checkouts, shared versus per-worktree configuration, locking a worktree on removable storage, pruning stale administrative entries, and removing a worktree without losing uncommitted work. Use when two branches must be checked out at once, when a worktree cannot be removed or its branch cannot be checked out, or when stale worktree entries must be cleaned up.

Look up HTML5 inspection, setup, validation, and focused operation patterns across documents, semantics and accessibility, forms and validation, media and embeds, metadata and seo. Use when the user wants a concise command or pattern reference instead of a guided workflow.

Create and repair HTML5 document shells, landmarks, sections, headings, lists, links, tables, and source order. Use when building or reviewing page structure, fixing invalid nesting, or changing document hierarchy.

Inspect the installed HTML5 toolchain, project configuration, source entry points, generated output, target environments, and validation scripts without changing files or dependencies. Use before HTML5 work, when the project conventions are unknown, or when the user asks what is configured.

Build and repair HTML5 forms covering labels, field groups, input types, autocomplete, native constraints, submission methods, error associations, and disabled or readonly behavior. Use when creating a form, changing submitted field names, fixing validation, or improving autofill and accessibility.

Connect HTML5 to the surrounding build system, framework, tests, linting, formatting, CI, deployment target, and runtime boundaries while preserving ownership between layers. Use when HTML5 must work with another project subsystem or behave consistently from local development through production.

Operate HTML5 images, pictures, audio, video, tracks, iframes, and embedded content with responsive sources, alternatives, loading policy, permissions, and privacy controls. Use when adding media, fixing responsive images, embedding third-party content, or addressing playback and loading problems.

Manage HTML5 head metadata including titles, descriptions, canonical URLs, robots directives, icons, language alternates, social cards, and structured data. Use when adding page metadata, fixing search or social previews, or changing indexing and canonicalization behavior.

Apply native HTML5 semantics, accessible names, keyboard-operable controls, landmark structure, text alternatives, and data-table relationships. Use when a page uses generic interactive elements, lacks accessible names, or needs an HTML5 accessibility review.

Install and configure HTML5 from zero, including the project-local toolchain, source entry point, baseline configuration, validation scripts, ignored generated output, and a minimal verified example. Use when a project has no HTML5 setup or the user explicitly asks to initialize it.

Diagnose HTML5 failures involving configuration, parsing, compilation, runtime behavior, generated output, browser or server differences, tests, integrations, and performance without masking the original error. Use when HTML5 code fails a check, behaves differently across environments, or produces unexpected output.

Design and repair JavaScript promises, async functions, async iterables, cancellation, timeouts, bounded concurrency, retries, and resource cleanup. Use when work races, hangs, leaks, retries incorrectly, or needs cancellation and concurrency limits.

Look up JavaScript commands, configuration, runtime patterns, and focused operations across modules, async control flow, dom and events, data modeling, performance and security. Use when the user wants a concise reference instead of a guided workflow.

Model JavaScript data with objects, arrays, maps, sets, iterables, immutability, cloning, equality, dates, numeric values, and JSON serialization. Use when choosing data structures, fixing mutation bugs, normalizing payloads, or preserving serialized contracts.

Operate browser DOM queries, element creation, event listeners, delegation, custom events, observers, focus, and lifecycle cleanup. Use when adding browser interaction, fixing duplicate handlers or stale nodes, or integrating with native DOM behavior.

Inspect the installed JavaScript runtime, package manager, module mode, project configuration, entry points, generated output, target environments, and checks without changing anything. Use before JavaScript work, when conventions are unknown, or when the user asks what is configured.

Connect JavaScript to build tools, tests, linting, formatting, CI, browser and server runtimes, package boundaries, and deployment artifacts while preserving ownership between layers. Use when JavaScript must cross another project subsystem or behave consistently from development through production.

Operate JavaScript modules across ESM and CommonJS, including imports, exports, package type, file extensions, dynamic loading, cycles, and browser delivery. Use when adding modules, fixing import failures, publishing exports, or migrating module format.

Measure and improve JavaScript runtime performance and security across hot paths, memory retention, parsing, dynamic code, prototype access, and untrusted input. Use when diagnosing slow or leaking code, reviewing injection risk, or hardening an input boundary.

Install and configure JavaScript from zero with a project-local toolchain, explicit runtime and module targets, source and output boundaries, baseline checks, and one verified example. Use when a project has no JavaScript setup or the user explicitly asks to initialize it.

Diagnose JavaScript failures involving parsing, types, modules, configuration, async behavior, runtime differences, generated output, tests, integrations, security, and performance without masking the original error. Use when JavaScript code fails a check, behaves differently across environments, or produces unexpected output.

Write and repair Jest tests for promises, async functions, callbacks, rejected errors, assertion counts, and test timeouts. Use when an async test passes too early, hangs, reports an unhandled rejection, or needs a reliable success and failure path.

Answer quick Jest command, flag, API, configuration, and test-isolation questions from a version-aware reference. Use when the user asks how to run, target, mock, snapshot, time, cover, configure, or troubleshoot a common Jest operation.

Design or verify deterministic Jest commands for CI, including non-interactive execution, coverage and JSON output, worker limits, project selection, retries, and sharding. Use when a Jest run behaves differently in CI or a pipeline needs a reliable test command.

Inspect and make deliberate, minimal changes to Jest configuration for discovery, environments, transforms, module mapping, setup files, projects, coverage, and mock isolation. Use when Jest cannot find tests or modules, uses the wrong environment, or needs an explicit config change.

Collect and interpret Jest coverage for the requested tests or source files, inspect uncovered paths, and make threshold changes only when explicitly requested. Use when the user asks for coverage, a coverage report, a threshold check, or help understanding missing coverage.

Inspect a repository's Jest installation, package manager, test scripts, configuration, test environment, and project layout before another Jest operation. Use when Jest is missing, the active config is unclear, a command behaves differently from expectation, or you need a safe baseline without changing files.

Reproduce and fix nondeterministic Jest tests, covering repeat and randomized runs, order dependence from shared state and leaked mocks, real timers and unawaited promises, open handles that hang a suite, time zone and locale assumptions, concurrency between workers, and why retries hide a defect rather than fixing it. Use when a test passes locally and fails in the pipeline, when a suite fails only in a particular order, or when a run hangs or times out intermittently.

Connect Jest to the tools around it, covering Testing Library and component rendering, request interception with Mock Service Worker, real databases and containers in integration tests, coverage reporting to a pipeline or coverage service, JUnit and JSON reporters for build artifacts, editor and debugger integration, and monorepo project selection. Use when tests must exercise a component, a stubbed network call, or a real dependency, or when the pipeline needs machine-readable results and coverage.

Create and diagnose Jest mock functions, spies, module mocks, manual mocks, implementations, return values, and mock cleanup. Use when a test needs to isolate a dependency or fails because mock state or restoration is wrong.

Diagnose and reduce Jest suite runtime and memory use, covering per-file timing, worker count and its tradeoffs, transform and cache costs, the environment choice, module resolution and barrel imports, heavy setup files, memory growth between files, sharding across machines, and measuring before and after each change. Use when a suite takes too long, when a run exhausts memory, or when the pipeline test step dominates build time.

Run Jest tests at the right scope: the full suite, an exact file, a file pattern, a test name, changed files, related tests, or only previous failures. Use when the user wants to execute, narrow, reproduce, or verify Jest tests without changing test code.

Install and configure Jest in a repository from zero, choosing a TypeScript transform such as ts-jest, Babel, or SWC, deciding between CommonJS and native ECMAScript modules, selecting the node or jsdom test environment, wiring setup files, module name mapping, and package scripts. Use when a project has no test runner yet, when Jest is installed but cannot parse or resolve the project's files, or when the user asks how to add Jest to an application or library.

Review, update, and troubleshoot Jest snapshot tests with a narrow test scope and explicit approval for snapshot file changes. Use when snapshots fail, a snapshot needs intentional regeneration, or the user asks how to inspect snapshot differences.

Write focused Jest tests from an existing behavior contract, covering deriving cases from the contract rather than the implementation, naming and arranging a test, table-driven cases, choosing the right assertion, boundary and error paths, what to stub and what to leave real, and proving a test can fail. Use when new tests must be added for existing behavior, when a bug needs a regression test, or when a suite passes without actually checking anything.

Control Jest fake timers and diagnose timer-driven tests, intervals, polling, debounced work, and timer leaks. Use when time-dependent tests are slow, flaky, stuck, or need deterministic advancement without sleeping.

Diagnose Jest failures systematically across test discovery, transforms, ESM and TypeScript, environments, module mocks, async work, timers, snapshots, coverage, workers, and open handles. Use when a Jest command fails, hangs, flakes, or behaves differently locally and in CI.

Start and control Jest watch mode for fast local feedback, selecting changed tests, all tests, a file, or a test name while preserving an interactive terminal workflow. Use when the user wants Jest to rerun tests as files change or needs help with watch-mode controls.

Look up Material UI v9 installation commands, imports, components, layout primitives, form controls, overlays, theme APIs, styling strategies, slots, and migration tools. Use when the user wants a concise v9 reference instead of a guided workflow.

Build and refactor Material UI v9 component composition and responsive layout with Box, Container, Stack, Grid, breakpoints, spacing, display, semantic elements, and reusable shells. Use when the user asks to arrange MUI components or repair layout behavior across viewports.

Build Material UI v9 data display and feedback with Table, List, Card, Avatar, Chip, Badge, Tooltip, Alert, Snackbar, Progress, Skeleton, empty states, and error states. Use when the user asks to present records, status, loading, results, or transient feedback with MUI Core.

Inspect Material UI v9 packages, React peers, styling engine, provider hierarchy, theme creation, CSS variables, framework adapters, icons, component imports, browser targets, and test setup without changing them. Use when the user asks what MUI setup exists or needs a safe baseline.

Build and operate Material UI v9 forms and inputs including TextField, Select, Autocomplete, Checkbox, Radio, Switch, Slider, validation, controlled state, slots, async options, and accessible labeling. Use when the user asks to create, connect, or repair form behavior.

Connect Material UI v9 to Next.js, routing, Tailwind CSS, CSS modules, form and data libraries, fonts, testing tools, continuous integration, and server rendering with end-to-end verification. Use when the task concerns the seam between MUI Core and another system.

Plan, preview, run, review, and verify Material UI v7-to-v9 migrations across Core packages, React peers, browser targets, Grid, system props, slots, deprecated component props, classes, semantics, themes, icons, tests, and codemods. Use when the user explicitly asks to upgrade an existing Material UI project to v9.

Discover, compatibility-check, install, update, remove, or explain Material UI's first-party styling, theming, Next.js, and Tailwind Agent Skills for MUI v9. Use when asked about native MUI skills, agent setup, upstream guidance, or whether installed Material UI skills match this v9 operator.

Build Material UI v9 navigation and overlays with AppBar, Drawer, Breadcrumbs, Tabs, Menu, Dialog, Modal, Popover, Tooltip, portal containers, close reasons, roving tabindex, focus traps, restoration, and stacking. Use when users navigate, choose actions, or interact with layered MUI surfaces.

Install and configure Material UI v9 with aligned core packages, a deliberate styling engine, React peer checks, providers, baseline styles, fonts, optional icons, framework boundaries, and one verified component. Use when a project has no MUI setup or the user explicitly asks to initialize v9.

Style Material UI v9 components with sx, styled, theme component overrides, GlobalStyles, CssBaseline, slots, slotProps, class APIs, state classes, CSS layers, and injection-order controls. Use when the user asks to customize appearance, replace an internal slot, or repair style precedence.

Manage Material UI v9 themes, design tokens, palettes, typography, spacing, breakpoints, component defaults, CSS variables, color schemes, dark-mode persistence, TypeScript augmentation, and SSR initialization. Use when the user asks to customize or repair the MUI design system.

Diagnose Material UI v9 package, React peer, styling engine, injection order, provider, theme, hydration, portal, focus, controlled-state, browser, TypeScript, and test failures from exact evidence. Use when MUI components fail to render, style, hydrate, interact, or type-check as expected.

Design, run, and explain MongoDB aggregation pipelines for filtering, reshaping, grouping, joining, and reporting. Use when a task needs more than a simple find query or when the user asks for a pipeline.

Operate a MongoDB Atlas cluster and its access, covering the CLI and project context, cluster tiers and scaling, network access lists and private networking, database users and their scoping, backup snapshots and point-in-time restore, alerts and metrics, pausing and terminating a cluster, and why an open access list is an exposure. Use when an Atlas cluster must be inspected, resized, paused, or restored, or when its network and user access must be audited or changed.

Take MongoDB backups and prove they restore, covering mongodump archives and oplog capture, selective namespace dumps, restoring into a scratch namespace for verification, document and index comparison, the destructive restore flags, point-in-time recovery on a managed cluster, retention and encryption, and scheduling with monitored failures. Use when a backup must be taken before a risky change, when a restore must be verified, or when a recovery plan must be established.

Answer common MongoDB command and syntax questions with a compact mongosh and Database Tools reference. Use when the user wants a command lookup, a filter or update example, an aggregation stage reminder, or a quick explanation of MongoDB terminology.

Inspect, create, validate, rename, and remove MongoDB collections with scoped safety checks. Use when the user asks about collection names, options, validators, capped collections, stats, renames, or drops.

Perform everyday MongoDB document creates, reads, updates, and deletes through mongosh with scoped filters and preview-first safety. Use when the user wants to add, inspect, modify, or remove documents in a known collection.

Inspect and manage MongoDB databases with explicit target checks. Use to list databases, select a database, inspect database statistics, create a database through a collection, or deliberately drop a database after approval.

Inspect MongoDB client tools, connection details, server health, authentication context, and deployment capabilities without changing data. Use before an operation or when mongosh cannot connect, the target is unclear, or the user asks whether MongoDB is ready.

Use MongoDB Database Tools for JSON or CSV import, JSON or CSV export, BSON dumps, restores, and BSON inspection. Use when moving data between files and MongoDB or preparing a backup and restore procedure.

Inspect MongoDB indexes, design single or compound indexes, analyze query plans, and remove obsolete indexes with explicit safeguards. Use when queries are slow, a unique constraint is needed, or the user asks about indexes.

Connect MongoDB to the systems around it, covering the Node.js driver and connection reuse, Mongoose or Prisma as a schema layer, connection pooling in serverless and container runtimes, schema migration tooling, change streams feeding an application, tests against a real deployment, and backups. Use when an application must open a connection correctly, when a serverless function exhausts connections, when a migration or seed step must be added, or when tests need a real database.

Find and fix slow MongoDB queries, covering the slow-query log and database profiler levels, reading explain output for the winning plan and examined-versus-returned ratio, collection scans and unindexed sorts, index selectivity and prefix order, covered queries, aggregation stage costs, and proving an index changed the plan. Use when a query or aggregation is slow, when an index must be justified before adding it, or when database load must be attributed to specific operations.

Build precise MongoDB read queries with filters, projections, sorting, pagination, counts, distinct values, dates, arrays, and null handling. Use when a user needs help expressing a search or wants a bounded result set from a collection.

Install mongosh and the MongoDB Database Tools, stand up a local deployment through Docker or a package manager, or prepare an Atlas cluster with a database user, network access, and TLS, then assemble and verify a connection string without exposing its credentials. Use when MongoDB tooling is missing, when a local or hosted deployment must be created, when a connection string has to be built or repaired, or when the user asks how to get MongoDB running.

Write multi-document MongoDB transactions correctly, covering the replica set requirement, sessions and the callback API, read and write concerns, transient error retries and the commit-unknown case, the time and size limits, passing the session to every operation, and when a single-document update or a schema change is the better answer. Use when several documents must change atomically, when a transaction aborts or times out, or when a write must be all-or-nothing.

Diagnose common MongoDB Shell and Database Tools failures using read-only evidence and a symptom-to-cause decision tree. Use for connection, DNS, TLS, authentication, permissions, duplicate-key, validation, timeout, restore, or slow-query problems.

Create and audit MongoDB database users with least privilege, covering the authentication database, built-in roles and what each grants, custom roles scoped to specific actions and collections, listing effective privileges, changing a password without downtime, removing a user, and separating an application account from an administrative one. Use when an application needs credentials, when a user's access must be audited or narrowed, or when a password must be rotated.

Operate Next.js App Router layouts, pages, route segments, groups, dynamic parameters, loading, error, not-found, parallel routes, intercepting routes, and navigation. Use when adding or moving routes, fixing layouts or navigation, or implementing route-specific loading and errors.

Look up Next.js commands, project structure, rendering patterns, and focused operations across app router, server and client components, data and caching, mutations and route handlers, metadata and deployment. Use when the user wants a concise reference instead of a guided workflow.

Operate Next.js server data fetching, request memoization, use cache, cache tags and lifetimes, revalidation, streaming, Suspense, and dynamic request APIs. Use when adding data access, fixing stale or uncached results, choosing rendering behavior, or invalidating cached output.

Inspect the installed Next.js versions, package manager, renderer or router mode, source tree, build configuration, scripts, and target environments without changing anything. Use before Next.js work, when conventions are unknown, or when the user asks what is configured.

Connect Next.js to styling, data sources, tests, browser and server runtimes, build tools, CI, observability, and deployment while preserving component and execution boundaries. Use when Next.js crosses another subsystem or must behave consistently through production.

Operate Next.js metadata, icons, Open Graph images, robots and sitemaps, image and font assets, environment variables, production builds, previews, and deployment configuration. Use when adding SEO metadata, fixing assets, preparing production, or changing runtime and deployment behavior.

Build Next.js Server Functions, form actions, Route Handlers, request validation, authorization, cookies, redirects, revalidation, and error responses. Use when adding mutations or API endpoints, handling forms, setting cookies, or securing server actions and handlers.

Design Next.js Server and Client Component boundaries, serialization, data access, interactivity, providers, browser APIs, and composition. Use when placing use client, fixing hydration, moving data access, or reducing client JavaScript.

Install and configure Next.js from zero with project-local dependencies, explicit rendering and runtime boundaries, source structure, baseline checks, and one verified feature. Use when a project has no Next.js setup or the user explicitly asks to initialize it.

Diagnose Next.js failures involving versions, rendering, state, hydration, routing, caching, async behavior, build output, tests, integrations, and performance without masking the original error. Use when Next.js fails a check, behaves differently across environments, or renders unexpected output.

Add, inspect, or troubleshoot authentication and authorization for Node.js APIs using existing API-key, bearer-token, JWT, session, or framework middleware patterns. Use when an endpoint needs protection, returns 401 or 403 unexpectedly, or authentication behavior must be reviewed without exposing credentials.

Answer common Node.js API command and implementation questions with concise, safety-aware examples for runtime inspection, route work, validation, authentication, HTTP clients, tests, logs, and diagnostics. Use when the user asks what Node.js API command or pattern to use, wants a quick reference, or needs a command translated into plain language.

Add database access and CRUD endpoints to a Node.js API, covering one pool per process and its sizing, parameterized queries, a repository layer separate from handlers, transactions across related writes, mapping database errors to status codes, migrations as the schema owner, connection handling in serverless runtimes, and closing the pool on shutdown. Use when an API must read or write a database, when CRUD endpoints must be added, or when connection or query errors appear under load.

Inspect a Node.js API project's runtime, package manager, framework, scripts, entrypoints, configuration, dependencies, and local prerequisites without changing the environment. Use when a project is unfamiliar, a task needs an evidence-based starting point, or the user asks whether the API is configured or runnable.

Design, repair, or review Node.js API error handling with stable status mapping, structured responses, async propagation, safe logs, and no accidental stack-trace or secret disclosure. Use when an API returns inconsistent errors, crashes on rejected promises, exposes internals, or needs a consistent error middleware pattern.

Add a GraphQL surface to a Node.js API safely, covering schema-first types and resolvers, the N-plus-one problem and batching, depth and complexity limits, disabling introspection and persisted queries in production, authorization per field rather than per request, errors and partial results, pagination conventions, and why a single endpoint defeats path-based rate limiting. Use when a GraphQL endpoint must be added, when queries are slow from repeated database calls, or when a GraphQL surface must be reviewed for abuse resistance.

Implement or review outbound HTTP calls from Node.js APIs with the project's existing fetch, undici, axios, or wrapper conventions, including timeouts, safe retries, response checks, error mapping, authentication, and tests. Use when an API calls an upstream service or fails on timeout, non-success responses, malformed data, or connection errors.

Connect a Node.js API to its dependencies, covering database clients and connection pooling, cache and queue workers, authentication providers and webhook receivers, structured logging with request correlation, tracing and metrics, container images and reverse proxies, and pipeline test and deploy steps. Use when an API must reach a datastore or upstream service, when a webhook endpoint must verify signatures, when requests need correlation across services, or when the API must run behind a proxy or in a container.

Move slow work off the request path into background jobs, covering a durable queue rather than a floating promise, enqueuing inside the transaction that creates the work, idempotent handlers and retries with backoff, a dead letter queue, concurrency and ordering, scheduled and repeating jobs, a separate worker process, graceful shutdown mid-job, and observability. Use when a request is slow because of work that could happen later, when a job runs twice or is lost, or when a worker must be added.

Generate, serve, and check an OpenAPI description of a Node.js API, covering generating the document from the validation schemas that already run rather than hand-writing it, documenting error shapes and security schemes, serving the document and an interactive page, keeping it honest with a drift check in the pipeline, and versioning it alongside the API. Use when an API needs a published contract, when the existing document has drifted from the code, or when clients need a generated SDK.

Add pagination, filtering, and sorting to a list endpoint, covering offset versus cursor paging and when each is correct, a stable sort key, clamped page sizes, allow-listed filter and sort fields, total counts and their cost, the indexes each query shape needs, and a consistent response envelope. Use when a list endpoint returns everything, when paging skips or repeats rows, or when filtering and sorting must be exposed without opening a query surface.

Add rate limiting to a Node.js API without blocking legitimate traffic, covering the key choice of address versus authenticated identity, trusting forwarded headers behind a proxy, a shared store across instances, per-route limits for expensive and authentication endpoints, the standard response headers and 429 status, burst allowance, and excluding health checks. Use when an API must be protected from abuse, when a limiter blocks real users, or when limits reset unexpectedly across instances.

Inspect, add, change, or verify Node.js HTTP routes while preserving the project's framework, router registration, middleware order, response envelope, status codes, naming, and test conventions. Use when the user asks to create or modify an endpoint, route a handler, expose a resource, or understand where an API route is implemented.

Start, inspect, health-check, observe, and safely stop a local Node.js API server using the project's own scripts and discovered port configuration. Use when the user wants to run an API locally, verify that it responds, inspect logs, investigate a port conflict, or stop a process created for the task.

Scaffold a Node.js HTTP API from zero, choosing a framework, setting up TypeScript and the module system, loading configuration from the environment with validation, adding a graceful shutdown and a health route, and wiring development, build, lint, and test scripts. Use when a repository has no API server yet, when an existing project needs its runtime and scripts brought into working order, or when the user asks how to start a Node.js API.

Create and run focused tests for Node.js APIs, including handler, middleware, route, integration, upstream-client, and contract behavior, while using the project's existing test runner and avoiding real production services. Use when an endpoint changes, a regression needs coverage, or API behavior must be verified.

Diagnose Node.js API startup, port, routing, validation, authentication, runtime, upstream, test, and dependency failures through bounded evidence collection and the least invasive next step. Use when the user provides an error, an API is not responding, a route returns an unexpected status, or a Node.js service behaves inconsistently.

Accept file uploads safely in a Node.js API, covering size limits enforced by the server, content type verified from the bytes rather than the client's claim, filename sanitizing and path traversal, storing outside the application and never executing uploads, presigned direct-to-storage uploads for large files, virus scanning, per-user quotas, and cleaning up orphaned objects. Use when an endpoint must accept a file, when an upload exhausts memory or disk, or when upload handling must be reviewed for safety.

Add, repair, or review validation for Node.js API bodies, query strings, path parameters, and headers using the project's existing schema library and error conventions. Use when an endpoint accepts user input, rejects malformed requests inconsistently, or needs a clear validation contract and tests.

Introduce an API version and retire an old one without breaking clients, covering what counts as a breaking change, URL path versus header versioning, running two versions from one codebase with a shared service layer, additive changes that need no new version, deprecation headers and sunset dates, measuring real client usage before removal, and the removal sequence. Use when a change would break existing clients, when a second version must be introduced, or when an old version must be retired safely.

Design, inspect, revalidate, repair, and selectively evict a persistent PokéAPI v2 response cache, including canonical URL keys, query-aware list pages, atomic bodies and metadata, validators, last-known-good fallback, per-key single-flight, cross-process locks, negative entries, and request accounting. Use when adding cache behavior, investigating repeated requests or stale data, refreshing a resource, or cleaning specific cached entries.

Answer quick PokéAPI v2 questions with a compact reference for resource paths, named and unnamed identifiers, pagination, linked resources, language and version filtering, cache-first requests, and fair-use boundaries. Use when someone asks which PokéAPI v2 endpoint or query shape to use, or wants a fast lookup rather than a guided workflow.

Inspect a PokéAPI v2 client's base URL, HTTP stack, persistent cache directory, cache metadata, retry and concurrency policy, pagination bounds, and ability to read one known resource without changing configuration. Use before a PokéAPI operation, when request volume is uncertain, when cached data looks wrong, or when someone asks whether the client is configured for fair use.

Resolve PokéAPI v2 species to numeric evolution-chain resources, walk branching chain links, preserve alternative evolution-detail objects and nullable requirements, read evolution triggers, and cache every species, item, move, location, type, and chain link used in the answer. Use when building an evolution tree, explaining evolution conditions, or diagnosing a missing or incorrect branch.

Read and relate PokéAPI v2 generations, versions, version groups, Pokédexes, and languages while distinguishing their scopes, filtering localized names and flavor text, preserving regional Pokédex numbers, and caching each requested list or detail page. Use when selecting a game context, mapping resources across releases, reading Pokédex membership, or localizing API data.

Connect a cache-first PokéAPI v2 client to server applications, browser-facing APIs, static generation, background jobs, test suites, CI, and supported wrapper libraries while centralizing request budgets, observability, persistence, and same-origin URL validation. Use when wiring PokéAPI into an application stack, sharing cached data across processes, preventing per-browser amplification, or making builds and tests deterministic.

Read and relate PokéAPI v2 items, attributes, categories, pockets, fling effects, berries, berry firmnesses, and berry flavors while preserving version-specific values, item-to-berry links, localized text, and cache-first request accounting. Use when looking up item mechanics, organizing inventory metadata, resolving berries to items, or comparing fling and berry properties.

Read and relate PokéAPI v2 regions, locations, location areas, Pal Park areas, Pokémon encounter routes, encounter methods, conditions, and condition values while filtering nested encounter chances by version and caching each requested resource. Use when finding where a Pokémon appears, listing encounters in an area, resolving region geography, or interpreting encounter requirements.

Read and relate PokéAPI v2 moves, move ailments, battle styles, categories, damage classes, learn methods, targets, numeric machine records, contest types, contest effects, and super contest effects with version-aware filtering and cache-first links. Use when examining move mechanics, learnability, machines, targets, damage classes, or contest behavior.

Read and relate PokéAPI v2 Pokémon resources including battle instances, species, forms, abilities, types, stats, natures, characteristics, egg groups, growth rates, colors, habitats, and shapes while distinguishing identifiers and caching every followed link. Use when looking up a Pokémon, comparing forms or types, reading species lore or breeding data, or joining Pokémon metadata across resource families.

Set up a PokéAPI v2 client from zero with the official HTTPS base URL, GET-only transport, a persistent local response cache, normalized URL keys, atomic writes, per-key single-flight, bounded retries, pagination caps, request accounting, and a two-read cache verification. Use when an application has no PokéAPI v2 wiring, when its cache is only in memory, or when the user asks to configure a fair-use client.

Diagnose PokéAPI v2 failures by separating cache, URL, identifier, pagination, version filtering, response-shape, connectivity, retry, concurrency, and upstream behavior, while preserving exact errors and avoiding request amplification. Use when requests return 404 or 5xx, data appears stale or incomplete, the wrong form or version is shown, cache hits do not occur, or a client sends more network traffic than expected.

Look up React commands, project structure, rendering patterns, and focused operations across components and composition, state and context, effects and refs, forms and actions, performance and testing. Use when the user wants a concise reference instead of a guided workflow.

Create and refactor React function components, JSX, props, children, composition, context boundaries, and reusable component APIs. Use when building components, splitting or combining UI, repairing prop contracts, or reviewing composition.

Design and repair React effects, effect dependencies, cleanup, refs, imperative handles, subscriptions, timers, and external-system synchronization. Use when effects loop, run twice, leak, use stale values, or a component must coordinate with a non-React system.

Inspect the installed React versions, package manager, renderer or router mode, source tree, build configuration, scripts, and target environments without changing anything. Use before React work, when conventions are unknown, or when the user asks what is configured.

Build React forms and actions with native semantics, controlled or uncontrolled inputs, validation, async submission, pending state, optimistic updates, and server error recovery. Use when creating a form, fixing field state, adding async actions, or handling validation and optimistic updates.

Connect React to styling, data sources, tests, browser and server runtimes, build tools, CI, observability, and deployment while preserving component and execution boundaries. Use when React crosses another subsystem or must behave consistently through production.

Measure and improve React rendering performance and test component behavior using Profiler evidence, memoization, Suspense boundaries, interaction tests, and bundle inspection. Use when renders are slow, memoization is proposed, Suspense behavior is wrong, or component tests need reliable coverage.

Install and configure React from zero with project-local dependencies, explicit rendering and runtime boundaries, source structure, baseline checks, and one verified feature. Use when a project has no React setup or the user explicitly asks to initialize it.

Operate React state ownership, derived state, reducers, controlled and uncontrolled components, context, keys, and preservation or reset behavior. Use when state is duplicated, stale, unexpectedly reset, shared across components, or difficult to update.

Diagnose React failures involving versions, rendering, state, hydration, routing, caching, async behavior, build output, tests, integrations, and performance without masking the original error. Use when React fails a check, behaves differently across environments, or renders unexpected output.

Discover, preview, install, adapt, and verify shadcn v4 blocks and multi-component page compositions for application shells, dashboards, authentication, commerce, and chat without surrendering routing, data, state, or dependency ownership. Use when the user asks for a shadcn block, full section, page composition, dashboard, shell, or chat interface.

Install, inspect, build, customize, test, optimize, and safely update shadcn v4 charts using Recharts v3, ChartContainer, ChartConfig, semantic tokens, axes, legends, tooltips, interactions, responsive sizing, accessible alternatives, and explicit data contracts. Use when the user asks for charts, graphs, dashboards, or data visualization in a shadcn project.

Look up shadcn CLI v4 commands, project configuration fields, component and registry discovery, previews, presets, bases, aliases, docs, additions, charts, updates, and migration patterns. Use when the user wants a concise shadcn v4 reference instead of a guided workflow.

Discover, inspect, preview, add, compose, customize, test, and safely update shadcn v4 components across Base UI, Radix, and React Aria bases, preserving project aliases, semantic tokens, local source ownership, variants, slots, state, and accessibility. Use when the user asks for any shadcn component or a component-level UI change.

Inspect shadcn CLI v4 availability, components.json, framework, package manager, primitive base, style, icon library, React Server Components mode, Tailwind family, CSS entry, aliases, resolved paths, installed components, registries, and local modifications without changing them. Use when the user asks what shadcn setup exists or needs a safe baseline.

Build and verify shadcn v4 fields, forms, validation, data tables, filters, pagination, sorting, selection, server-data states, and accessible feedback while preserving the host application's state and schema choices. Use when the user asks for form controls, React Hook Form or schema integration, data tables, editable data, filters, or loading, empty, and error states.

Connect shadcn CLI v4 source components to Next.js, Vite, React Router, TanStack Start, Astro, Laravel, Tailwind v3 or v4, monorepos, form and data libraries, Recharts, testing tools, continuous integration, and private registries. Use when the task concerns the seam between shadcn and another system.

Discover, compatibility-check, install, update, remove, or explain shadcn's first-party Agent Skill for CLI v4 component, registry, preset, styling, composition, and primitive-base workflows. Use when asked about native shadcn skills, agent setup, upstream guidance, or whether an installed shadcn skill matches this v4 operator.

Resolve, compare, apply, and verify shadcn v4 presets, themes, styles, primitive bases, icon libraries, fonts, radii, color schemes, and semantic tokens while preserving project-specific component source and brand decisions. Use when the user asks to restyle shadcn, apply a preset, change theme variables, switch icons or fonts, or plan a base and style change.

Discover, validate, inspect, authenticate, consume, and author shadcn v4 registries from namespaces, local sources, GitHub repositories, and private endpoints without leaking credentials or overwriting owned source blindly. Use when the user asks about registry items, registry.json, custom registries, GitHub items, private components, or publishing reusable shadcn code.

Initialize shadcn CLI v4 projects with a pinned CLI, supported framework template, deliberate Base UI, Radix, or React Aria primitive base, style, icons, aliases, Tailwind configuration, CSS variables, RSC mode, and one verified component. Use when a project has no shadcn setup or the user explicitly asks to initialize v4.

Diagnose shadcn CLI v4 configuration, package runner, alias, resolved-path, primitive-base, Tailwind, CSS-variable, registry, authentication, dependency, component-drift, server-boundary, chart, and build failures from exact evidence. Use when CLI commands fail or copied components render, style, type-check, or interact incorrectly.

Plan, preview, execute, verify, and roll back shadcn v4 component updates, preset changes, CLI upgrades, primitive-base migrations, Tailwind transitions, and irreversible ejection while preserving locally owned source. Use when the user asks to update shadcn, reconcile upstream changes, migrate Base UI, Radix, or React Aria code, switch Tailwind families, or eject shared styles.

Continuously inspect, reproduce, prioritize, fix, verify, and re-audit software defects until the project reaches a high-confidence quality bar. Use when Codex must find and fix bugs across a project, debug failing tests or builds, eliminate regressions, repair runtime, type, API, data, integration, UI, state, concurrency, or resource-lifecycle errors, or keep hunting for additional defects after a known bug is resolved. Stops and reports when the change set becomes unmanageable or troubleshooting outweighs progress.

Audit, repair, and repeatedly raise the quality of a codebase, module, diff, or file until it reaches a high, evidence-backed bar, while keeping observable behavior unchanged. Use when Codex must clean up or refactor code, reduce complexity, remove duplication and dead weight, fix misleading names and unclear structure, repair swallowed errors and unsafe boundaries, improve comments, close gaps in test coverage for risky behavior, or keep improving a codebase after an initial cleanup is done. Owns the correctness of what it touches: it protects behavior with characterization tests before any rewrite and never claims a rewrite is safe because it compiles. Every change must retire a countable defect rather than express a style preference. Excludes feature work, architecture redesign, dependency upgrades, and performance tuning, and honors audit-only requests by reporting findings without editing.

Audit, repair, and iteratively improve a web project's search metadata, technical SEO, social sharing metadata, structured data, indexability controls, sitemap, robots directives, canonical URLs, favicons, and Open Graph images, including generating or replacing social preview images when needed. Use when asked to review or fix SEO, metadata, search appearance, link previews, OG or Twitter images, canonicalization, robots.txt, sitemaps, JSON-LD, or route-level metadata in a website or web application. Continue until all critical and major findings are resolved and the project meets a high-confidence quality bar, always ending with a session summary. Stops and reports when the change set becomes unmanageable or troubleshooting outweighs progress.

Audit, profile, fix, and repeatedly optimize software project speed and resource efficiency. Use when Codex needs to investigate a slow application, API, page, query, build, test suite, startup path, or background job; eliminate critical and major performance problems; improve latency, throughput, responsiveness, bundle size, memory, CPU, network, or database efficiency; validate production-like performance; or continue performance work until the project meets a high evidence-based bar. Stops and reports when the change set becomes unmanageable or troubleshooting outweighs progress.

Audit, update, and repeatedly improve a repository's README files until they meet a high documentation bar — fix existing READMEs that no longer match the code, add missing information, create new READMEs in folders that need one, and keep running fresh review passes until no material issue remains. Use when Codex needs to refresh, audit, fix, or generate READMEs or repository documentation, when docs are stale or out of date, or when the user asks to "update the readmes" in any form and wants them iterated to a high-confidence quality bar. Stops and reports when the change set becomes unmanageable or troubleshooting outweighs progress.

Audit, remediate, and harden a software project's security through repeated evidence-based review and verification. Use when Codex needs to perform a security audit or secure-code review, fix vulnerabilities, address critical/high/major security findings, harden authentication, authorization, APIs, dependencies, secrets, deployment configuration, or production-facing web controls, and continue improving the project until it meets a high-confidence security bar. Stops and reports when the change set becomes unmanageable or troubleshooting outweighs progress.

Continuously audit, repair, and verify AI skill packaging across common harnesses until it reaches a high-confidence compatibility bar. Use when Codex must QA SKILL.md frontmatter and formatting, remove nonportable YAML block scalars, reconcile missing Codex or Claude metadata, test real skill discovery, validate plugin and marketplace manifests, check catalogs and package contents, repair creator templates that reintroduce defects, or add deterministic CI guardrails without changing skill routine content. Stops and reports when the change set becomes unmanageable or troubleshooting outweighs progress.

Audit, repair, and iteratively improve a project's user interface and user experience using the running product, source code, and objective quality gates. Use when Codex must review UI/UX, fix critical or major usability and accessibility defects, improve responsive behavior, interaction states, information architecture, visual hierarchy, consistency, or polish, and continue validating improvements until the experience meets a high bar. Apply to web, mobile, and desktop interfaces, and honor audit-only requests by reporting findings without editing. Stops and reports when the change set becomes unmanageable or troubleshooting outweighs progress.

Audit, fix, and continuously improve the measurable visual accessibility of a project's interface in both light and dark themes, using the running product, computed styles, and objective thresholds. Use when Codex must resolve unreadable or low-contrast text, dark mode or light mode legibility problems, washed-out or hard-to-read theme colors, accent colors that disappear against a background, weak or invisible focus indicators, undersized touch targets, content that clips when text is scaled, missing reduced-motion support, or forced-colors failures. Measures every foreground and background pair in both themes, repairs root causes at the design-token layer, keeps the two themes balanced against the same thresholds, and repeats until both meet a high bar. Excludes aesthetic direction and brand redesign, and honors audit-only requests by reporting measured findings without editing.

Answer quick OpenSSH questions with a compact reference for connection flags, key generation and inspection, client configuration keywords, port forwarding forms, agent commands, scp and rsync syntax, and host key handling. Use when someone asks which SSH flag or config keyword to use, how a forwarding form is written, or wants a fast lookup rather than a guided workflow.

Add and repair entries in the SSH client configuration, covering host aliases, hostnames, users, ports, identity files, jump hosts, keep-alive settings, connection multiplexing, wildcard and pattern matching, Include files, and first-match-wins precedence. Use when a host alias must be created or fixed, when the wrong key or user is being used, when a jump host is needed, or when config changes appear to have no effect.

Inspect the SSH client version, key inventory, agent contents, effective per-host configuration, known-hosts entries, and reachability without changing anything or connecting where it is not needed. Use before an SSH operation, when a connection behaves unexpectedly, when it is unclear which key or user a host will use, or when the user asks whether SSH is set up.

Copy and synchronize files over SSH with scp, rsync, and sftp, covering direction, trailing-slash semantics, dry runs, deletion policy, permissions and ownership, excludes, resumable transfers, bandwidth limits, and verification by checksum or size. Use when files must move between a local machine and a remote host, when a directory must be synchronized, or when a previous transfer produced the wrong layout or deleted something.

Connect SSH to the systems around it, covering Git hosting authentication and signing, deploy keys, pipeline access through ephemeral keys, bastion and jump host chains, restricted authorized_keys entries for automation, remote Docker contexts, rsync-based deploys, and editor remote development. Use when a pipeline or another service needs SSH access to a host, when a repository must authenticate over SSH, or when access must be routed through a bastion.

Create, inspect, authorize, rotate, and revoke SSH key pairs, covering key types, passphrases, fingerprints, agent loading, authorized_keys entries with command and source restrictions, and separate keys per identity or per machine. Use when a key must be generated or replaced, when a key needs authorizing on a host, when a key is being retired, or when it is unclear which key a host trusts.

Open interactive SSH sessions and run remote commands non-interactively, covering batch mode and timeouts, quoting and here-documents, exit status and output capture, jump hosts, connection multiplexing, long-running work under tmux or screen, and safe handling of commands that change a remote host. Use when a command must run on a remote machine, when a session must be opened or kept alive, or when remote output has to be captured reliably.

Install or verify an OpenSSH client, create a first key pair, load it into the agent so a passphrase is typed once, set the correct file permissions, add a host entry, and authorize the public key on a server. Use when SSH is missing or unconfigured on a new machine, when a first key must be created and installed, or when the user asks how to get SSH working.

Diagnose SSH failures from reproducible evidence, covering unreachable ports, refused connections, publickey denials, wrong user or key selection, file permission problems, agent and passphrase failures, changed host keys, too many authentication failures, forwarding failures, and dropped or hanging sessions. Use when an SSH command fails, when a key that should work does not, when a host key warning appears, or when a session stalls.

Forward ports through SSH, covering local forwarding to reach a private service, remote forwarding to expose a local one, dynamic SOCKS proxies, jump hosts, bind addresses, background tunnels, and how to verify and tear one down. Use when a database or internal service must be reached through a bastion, when a local port must be reachable from a remote host, or when a tunnel is open but nothing connects through it.

Answer quick Stripe questions with a compact reference for keys and their scope, CLI commands and webhook forwarding, customers, products and prices, Checkout sessions, subscriptions, payment intents and refunds, idempotency keys, expanding and listing objects, amounts in minor units, test cards, and common event types. Use when someone asks which Stripe API call, CLI command, or test card to use, or wants a fast lookup rather than a guided workflow.

Build Stripe Checkout sessions and handle their outcome, covering payment, subscription, and setup modes, server-side price lookup, attaching a customer and a client reference, success and cancel URLs, why fulfilment belongs in the webhook rather than the success page, trials and promotion codes, tax and address collection, expiry, and the billing portal as the management surface. Use when a purchase or signup flow must be built, when a user is charged but nothing was provisioned, or when the success page is doing work it should not.

Create, find, and reconcile Stripe customers against local user or tenant records, covering lookup by metadata rather than email, storing the customer id locally, avoiding duplicates on retry, payment methods and the default for invoices, tax identifiers and addresses, the billing portal, and deleting versus keeping a customer. Use when a customer must be created for a user or organization, when duplicate customers appear, when a subscription cannot find its customer, or when local records and Stripe disagree.

Confirm which Stripe account and mode an application is using, whether the key pair is consistent, whether any secret key is reachable from client code, the pinned API version, which webhook endpoints and enabled events exist, and the products and prices configured, without changing anything. Use before any Stripe operation, when a customer or price seems missing, when a webhook is not arriving, or when the user asks whether Stripe is set up.

Connect Stripe to the systems around it, covering the local billing mirror and how access is derived from it, linking customers to users or tenants and to an identity provider, entitlement checks in application code, the client library and Elements, tax and invoicing configuration, reconciliation jobs, revenue reporting exports, and pipeline test and deploy steps. Use when billing state must drive access, when Stripe must link to an identity provider or database, or when local records and Stripe disagree.

Take one-off payments and issue refunds, covering payment intents with idempotency keys, server-side amount calculation, automatic payment methods and authentication steps, confirming on the client, capture timing, reading the outcome from the webhook rather than the response, partial and full refunds, disputes and evidence, and reconciling amounts against local orders. Use when a one-off charge must be taken, when a payment needs confirming or capturing, when a refund must be issued, or when a charge and a local order disagree.

Model Stripe products and prices and change pricing safely, covering the immutability of a price, amounts in minor units and zero-decimal currencies, recurring intervals and trials, tiered and metered pricing, multiple currencies, lookup keys instead of hard-coded ids, deactivating rather than deleting, and grandfathering existing subscribers when a price changes. Use when a plan must be created, when an amount or currency must change, when a price id must be referenced from code, or when subscribers are on an outdated price.

Set up Stripe in an application from zero, covering test mode keys and their scope, the server client with a pinned API version, the CLI and local webhook forwarding, the webhook route left public and reading a raw body, a first product and price, idempotency conventions, and the checklist before going live. Use when an application has no Stripe wiring, when webhook forwarding must be set up locally, or when the user asks how to add Stripe.

Manage Stripe subscription lifecycles and mirror their state locally, covering statuses and what each means for access, creating with trials, upgrades and downgrades with proration behaviour, quantity changes, cancelling at period end versus immediately, pausing, dunning and past_due handling, reactivation, and reconciling the local mirror when events were missed. Use when a plan must change, when a cancellation must be scheduled, when access does not match what someone is paying for, or when a failed payment must be handled.

Diagnose Stripe failures from reproducible evidence, covering test and live mode confusion, mismatched key pairs, secret keys reachable from the browser, webhook signature failures and protected webhook routes, API version mismatches on an endpoint, duplicate charges from missing idempotency keys, duplicate customers, subscriptions billed for two items, access that does not match subscription status, amount and currency mismatches, and declines versus errors. Use when a payment, subscription, or webhook misbehaves, when a customer or price seems missing, or when local records and Stripe disagree.

Receive and handle Stripe webhook events safely, covering endpoint registration per mode, signature verification against the raw body, keeping the route public in middleware, the API version a payload carries, idempotency keyed on the event id, acknowledging before processing, out-of-order delivery and reading current state, retries and the retry window, local forwarding with the CLI, and replaying missed events. Use when billing state must follow Stripe, when events arrive but nothing happens, when verification fails, or when an event applied twice.

Configure and debug Supabase authentication, covering email and password sign-in, magic links, OAuth providers, redirect URL allow lists, session cookies and server-side refresh, validating a user on the server, the auth.users table and a linked profiles row, app metadata versus user metadata, email templates, and administrative user operations. Use when sign-in must be added or repaired, when a redirect is rejected, when a session is lost on refresh, or when a user record must be created or inspected.

Answer quick Supabase questions with a compact reference for CLI commands, local stack control, migrations and database diffing, type generation, client query and filter syntax, auth calls, storage calls, edge function commands, and the key and URL differences between environments. Use when someone asks which Supabase CLI command or client call to use, or wants a fast lookup rather than a guided workflow.

Query and change Postgres inside a Supabase project, covering psql and Studio access, schema inspection, scoped reads and writes, transactions, database functions and triggers, extensions, generated columns, explain plans, and the difference between acting through the client and acting as a superuser. Use when data must be read or corrected, when a query is slow, when a database function or trigger is needed, or when schema details must be inspected.

Write, run, and deploy Supabase edge functions, covering the Deno runtime and imports, local serving with secrets, request handling and CORS, calling the database with the caller's session or the service role, verifying the JSON Web Token or accepting unauthenticated webhooks, scheduling, logs, and deployment to a linked project. Use when a server-side endpoint is needed, when a function fails locally or after deploy, or when a webhook receiver must be built.

Inspect the Supabase CLI version, whether a project directory is initialized and linked, which remote project reference is targeted, the local stack status and its URLs, which keys and URLs the application reads, migration state on both sides, and the Docker prerequisite, without changing anything. Use before a Supabase operation, when it is unclear whether a command hits local or remote, or when the user asks whether Supabase is set up.

Connect Supabase to the systems around it, covering client libraries per framework and rendering model, server-side session handling, direct Postgres access from an ORM alongside the client, realtime subscriptions, database webhooks to external services, continuous integration with a throwaway database, branch environments, and third-party auth providers. Use when an application must talk to Supabase, when an ORM must coexist with the client, when realtime updates are needed, or when a pipeline must run against a real schema.

Create, review, and apply Supabase migrations, covering handwritten migration files, generating one from a schema diff, local reset and replay, seed data, remote push and its approval boundary, drift between local and remote, repairing migration history, and safe patterns for destructive or long-running schema changes. Use when the schema must change, when a Studio change needs capturing as a file, when local and remote have diverged, or before pushing anything to a linked project.

Discover, compatibility-check, install, update, or explain Supabase's first-party agent skills. Use when asked about Supabase native skills, supabase/agent-skills, Postgres best-practice skills, agent setup, or compatibility with the project's Supabase CLI, client, and Postgres versions.

Write and verify Postgres row level security policies in Supabase, covering enabling security per table, separate policies per command, using and check expressions, the auth helper functions, joins and membership checks, performance of policy predicates, security definer helper functions, and testing a policy from the perspective of an anonymous, wrong, and correct user. Use when a table must be protected, when a query returns no rows or too many, or when a policy must be reviewed before shipping.

Set up a Supabase project from zero, covering CLI installation, project initialization, linking to a remote project reference, starting the local Docker stack, creating the environment files for local and hosted use, generating database types, and separating the anon key from the service role key. Use when a repository has no Supabase directory, when the local stack must be started for the first time, when a project must be linked, or when the user asks how to get Supabase running.

Create and operate Supabase storage buckets, covering public versus private buckets, storage access policies on the objects table, uploads with content type and cache control, signed URLs and signed upload URLs, path conventions that scope files per user, listing and moving objects, image transformations, and deletion. Use when files must be uploaded or served, when a bucket must be secured, when an upload is rejected, or when a file URL returns nothing.

Diagnose Supabase failures from reproducible evidence, covering local stack and Docker problems, wrong key or wrong environment, empty results caused by row level security, migration drift and failed pushes, session loss and redirect rejections, storage upload and URL failures, edge function and CORS errors, connection exhaustion, and stale generated types. Use when a Supabase call errors or returns nothing, when a migration push fails, when sign-in or a redirect breaks, or when something works locally but not when deployed.

Operate Tailwind CSS v3 CLI and PostCSS builds, explicit content globs, raw sources, safelists, watch mode, minification, and generated CSS outputs. Use when classes must be discovered reliably or a v3 build pipeline needs a focused change.

Look up Tailwind CSS v3 commands, directives, content configuration, theme extension, utilities, variants, plugins, and build patterns. Use when the user wants a concise v3 reference instead of a guided workflow.

Inspect Tailwind CSS v3 versions, package manager, scripts, JavaScript configuration, PostCSS integration, content sources, input stylesheets, plugins, and output ownership without changing them. Use when the user asks what Tailwind setup exists or needs a safe baseline before other work.

Connect Tailwind CSS v3 to framework build pipelines, PostCSS, editors, component libraries, monorepos, tests, and continuous integration with end-to-end verification. Use when the task concerns the seam between Tailwind v3 and another system.

Install, configure, author, inspect, and remove Tailwind CSS v3 official or custom plugins using the v3 plugin API and generated utility, component, base, and variant contracts. Use when a task involves typography, forms, container queries, or project-specific plugin behavior.

Install and configure Tailwind CSS v3 with a version-constrained package, explicit content paths, layer directives, build scripts, and one verified template. Use when a project has no Tailwind setup or the user explicitly asks to initialize the v3 family.

Manage Tailwind CSS v3 JavaScript configuration including theme extension, design tokens, presets, prefixes, important selectors, core plugins, and shared configuration. Use when the user asks to customize or review the v3 design system and configuration behavior.

Diagnose Tailwind CSS v3 installation, content detection, configuration, plugin, PostCSS, watch, specificity, missing-style, and oversized-output failures from exact evidence. Use when a v3 build fails, classes are absent or ineffective, or generated CSS behaves unexpectedly.

Author and refactor Tailwind CSS v3 utility compositions, arbitrary values, component classes, custom layer rules, apply directives, and reusable patterns. Use when the user asks to style or consolidate an interface without changing the theme or build boundary.

Manage Tailwind CSS v3 responsive, state, dark-mode, group, peer, data, supports, arbitrary, and container-query variants with explicit interaction checks. Use when styling depends on viewport, parent, sibling, attribute, feature, or color-scheme state.

Operate Tailwind CSS v4 Vite, PostCSS, CLI, and webpack builds, automatic detection, source base paths, explicit and inline sources, exclusions, watch mode, minification, and output. Use when classes must be discovered reliably or a v4 build boundary needs a focused change.

Look up Tailwind CSS v4 commands, build adapters, source detection, CSS-first themes, custom utilities, variants, compatibility directives, and migration patterns. Use when the user wants a concise v4 reference instead of a guided workflow.

Inspect Tailwind CSS v4 core and adapter versions, scripts, CSS entry, automatic and explicit sources, theme variables, compatibility directives, plugins, generated output, and browser requirements without changing them. Use when the user asks what v4 setup exists or needs a safe baseline.

Connect Tailwind CSS v4 to framework build pipelines, CSS modules and component styles, editors, monorepos, component libraries, tests, continuous integration, and deployment with end-to-end checks. Use when the task concerns the seam between Tailwind v4 and another system.

Plan, preview, execute, review, and verify Tailwind CSS v3-to-v4 migrations across packages, build adapters, CSS imports, configuration, utilities, variants, templates, browser requirements, and plugins. Use when the user explicitly asks to upgrade an existing v3 project to v4.

Operate Tailwind CSS v4 CSS plugins, JavaScript plugin compatibility, explicit config loading, source safelists, references, prefixes, important modifiers, Preflight, and legacy integration seams. Use when v4 must consume a plugin or retain bounded behavior from a v3-era setup.

Install and configure Tailwind CSS v4 with aligned version constraints, one deliberate Vite, PostCSS, CLI, or webpack adapter, a CSS import, source ownership, and one verified template. Use when a project has no Tailwind setup or the user explicitly asks to initialize v4.

Manage Tailwind CSS v4 theme variable namespaces, tokens, default resets, static emission, shared theme packages, runtime CSS variable access, and responsive design values. Use when the user asks to customize or review the v4 CSS-first design system.

Diagnose Tailwind CSS v4 core and adapter mismatches, source detection, theme, plugin, compatibility, browser, watch, missing-style, and oversized-output failures from exact evidence. Use when a v4 build fails, classes are absent or ineffective, or generated CSS behaves unexpectedly.

Author and refactor Tailwind CSS v4 utility compositions, arbitrary values, custom utility definitions, custom variants, responsive and container behavior, state modifiers, and apply usage. Use when the user asks to style an interface or define a reusable v4 utility or variant.

Look up TypeScript commands, configuration, runtime patterns, and focused operations across compiler configuration, type modeling, narrowing and generics, modules and packages, migrations and declarations. Use when the user wants a concise reference instead of a guided workflow.

Inspect and change TypeScript compiler configuration including target, lib, strictness, module, moduleResolution, paths, emit, incremental builds, and project references. Use when creating or repairing tsconfig files, changing compiler behavior, or resolving configuration inheritance.

Inspect the installed TypeScript runtime, package manager, module mode, project configuration, entry points, generated output, target environments, and checks without changing anything. Use before TypeScript work, when conventions are unknown, or when the user asks what is configured.

Connect TypeScript to build tools, tests, linting, formatting, CI, browser and server runtimes, package boundaries, and deployment artifacts while preserving ownership between layers. Use when TypeScript must cross another project subsystem or behave consistently from development through production.

Migrate JavaScript to TypeScript and author or generate declaration files with allowJs, checkJs, JSDoc, ambient modules, declaration emit, and compatibility tests. Use when incrementally adopting TypeScript, typing an untyped dependency, or publishing declaration files.

Operate TypeScript module resolution, package exports and imports, ESM and CommonJS interop, file extensions, type-only imports, path aliases, and consumer compatibility. Use when imports fail, package types are missing, dual-package behavior diverges, or exports must be published.

Apply TypeScript control-flow narrowing, type predicates, assertion functions, generics, constraints, conditional types, mapped types, and inference without over-generalizing APIs. Use when a union is hard to use, an API needs reusable type relationships, or inference and constraints are incorrect.

Install and configure TypeScript from zero with a project-local toolchain, explicit runtime and module targets, source and output boundaries, baseline checks, and one verified example. Use when a project has no TypeScript setup or the user explicitly asks to initialize it.

Diagnose TypeScript failures involving parsing, types, modules, configuration, async behavior, runtime differences, generated output, tests, integrations, security, and performance without masking the original error. Use when TypeScript code fails a check, behaves differently across environments, or produces unexpected output.

Model TypeScript values and APIs with object types, interfaces, unions, intersections, literals, discriminants, readonly data, utility types, and exact boundary validation. Use when designing a type contract, replacing unsafe assertions, or aligning runtime data with compile-time types.

Operate AI Gateway authentication with Vercel OIDC, API keys, dashboard BYOK credentials, request-scoped BYOK, scopes, rotation, and system-credential fallback. Use when configuring credentials, migrating from provider keys, adding BYOK, rotating a key, or diagnosing authentication.

Inspect and manage AI Gateway key budgets, refresh periods, user quotas, credits, request attribution, usage exports, and cost guardrails. Use when setting spend caps, investigating usage, attributing cost, or preventing runaway agents.

Look up Vercel AI Gateway commands, configuration, policy, and focused operations across models and capabilities, routing and fallbacks, authentication and byok, budgets and usage, observability and security. Use when the user wants a concise reference instead of a guided workflow.

Inspect Vercel AI Gateway versions, local project structure, account or team context, environment variable names, configured resources, policies, observability, and safe checks without changing anything. Use before Vercel AI Gateway work, when the target is uncertain, or when the user asks what is configured.

Connect Vercel AI Gateway to application runtimes, identity, external services, persistence, observability, CI, and deployment while preserving account, credential, data, and action boundaries. Use when Vercel AI Gateway must cross another system or operate consistently through production.

Discover and select AI Gateway models and providers by canonical model ID, capability, modality, context window, pricing, region, and API compatibility. Use when choosing or changing a model, checking capability support, or building a model catalog.

Operate AI Gateway observability and security including request volume, tokens, TTFT, cost, reporting APIs, provider allowlists, zero-data-retention routing, no-training policy, and redaction. Use when investigating reliability or spend, exporting reports, enforcing provider policy, or reviewing prompt privacy.

Configure AI Gateway provider filtering, ordering, per-provider timeouts, automatic prompt caching, load balancing, and model fallbacks with explicit reliability semantics. Use when controlling provider choice, improving availability, adding fallbacks, or debugging unexpected routing.

Install and configure Vercel AI Gateway from zero with project-local tooling, exact account and project scope, server-only credentials, baseline policies, one minimal feature, and bounded verification. Use when a project has no Vercel AI Gateway setup or the user explicitly asks to initialize it.

Diagnose Vercel AI Gateway failures involving versions, account scope, credentials, permissions, configuration, remote resources, durability, providers, observability, costs, and deployment without masking the original error. Use when Vercel AI Gateway fails, behaves differently across environments, or causes unexpected remote effects.

Look up Vercel AI SDK installation, inspection, core calls, operational limits, and focused patterns across generation, streaming ui, structured output, tools and agents, providers and middleware. Use when the user wants a concise reference instead of a guided workflow.

Inspect Vercel AI SDK package versions, runtime and framework context, configuration, environment variable names, adapters or providers, persistence, scripts, and safe local checks without changing anything. Use before Vercel AI SDK work, when the target is uncertain, or when the user asks what is configured.

Operate AI SDK text, image, video, speech, transcription, and realtime generation with explicit models, inputs, abort signals, usage accounting, stop conditions, and error handling. Use when adding a model call or controlling modality, latency, cost, streaming, and cancellation.

Connect Vercel AI SDK to application runtimes, persistence, authentication, observability, CI, deployment, and adjacent external services while preserving credential, data, and action boundaries. Use when Vercel AI SDK must cross another system or operate consistently from local development through production.

Configure AI SDK providers, model registries, provider options, middleware, fallbacks, embeddings, telemetry, and shared model policy. Use when adding or switching providers, wrapping models, routing by task, enabling telemetry, or standardizing model configuration.

Install and configure Vercel AI SDK from zero with project-local packages, explicit runtime and external targets, server-only credentials, baseline policy, one minimal example, and bounded verification. Use when a project has no Vercel AI SDK wiring or the user explicitly asks to initialize it.

Build AI SDK streaming user interfaces with UI messages, useChat, server stream responses, data parts, tool states, cancellation, reconnection, and persisted history. Use when creating chat UI, fixing stream parsing, restoring messages, or rendering tool and error states.

Generate and stream structured AI SDK outputs with explicit schemas, descriptions, validation, partial object handling, error recovery, and compatibility checks. Use when a model must return typed data, object generation fails validation, or a schema must evolve.

Design and operate AI SDK 7 tools and agents with runtime context, input schemas, execution boundaries, result contracts, WorkflowAgent durability, timeouts, approvals, and observability. Use when adding model-callable tools, building an agent, requiring human approval, or preventing runaway loops.

Diagnose Vercel AI SDK failures involving versions, configuration, credentials, runtime boundaries, streaming or events, persistence, external APIs, rate limits, costs, deployments, and recovery without masking the original error. Use when Vercel AI SDK fails, behaves differently across environments, or causes unexpected external effects.

Configure and operate Chat SDK official, vendor, and custom adapters with capability checks, platform credentials, bot identity, and normalized contracts. Use when adding Slack, Teams, Discord, GitHub, Linear, WhatsApp, or another adapter, or fixing adapter-specific behavior.

Look up Vercel Chat SDK installation, inspection, core calls, operational limits, and focused patterns across adapters, events and handlers, messages and interactive ui, state and concurrency, webhooks and deployment. Use when the user wants a concise reference instead of a guided workflow.

Inspect Vercel Chat SDK package versions, runtime and framework context, configuration, environment variable names, adapters or providers, persistence, scripts, and safe local checks without changing anything. Use before Vercel Chat SDK work, when the target is uncertain, or when the user asks what is configured.

Implement Chat SDK handlers for mentions, subscribed messages, reactions, slash commands, buttons, selections, modals, and platform events with explicit routing and errors. Use when adding bot behavior, fixing duplicate or missing handlers, or normalizing events across platforms.

Connect Vercel Chat SDK to application runtimes, persistence, authentication, observability, CI, deployment, and adjacent external services while preserving credential, data, and action boundaries. Use when Vercel Chat SDK must cross another system or operate consistently from local development through production.

Create Chat SDK posts, streaming responses, edits, reactions, files, cards, modals, ephemeral messages, and cross-platform fallbacks with accessible content. Use when sending or updating messages, streaming AI output, building cards, or handling interactive forms.

Install and configure Vercel Chat SDK from zero with project-local packages, explicit runtime and external targets, server-only credentials, baseline policy, one minimal example, and bounded verification. Use when a project has no Vercel Chat SDK wiring or the user explicitly asks to initialize it.

Operate Chat SDK state adapters, thread subscriptions, distributed locks, overlapping-message strategies, deduplication, and cold-start recovery. Use when deploying beyond one process, messages overlap, subscriptions disappear, or duplicate replies occur.

Diagnose Vercel Chat SDK failures involving versions, configuration, credentials, runtime boundaries, streaming or events, persistence, external APIs, rate limits, costs, deployments, and recovery without masking the original error. Use when Vercel Chat SDK fails, behaves differently across environments, or causes unexpected external effects.

Configure Chat SDK webhook routes, signature or token verification, local tunnels, platform registration, environment separation, deployment, and delivery diagnostics. Use when exposing bot webhooks, registering callbacks, deploying a bot, or diagnosing delivery failures.

Look up Vercel Core Platform CLI commands, account and project context, deployment, security, delivery, compute, observability, and CI/CD patterns. Use when the user wants a concise platform reference instead of a guided workflow.

Operate Vercel CI and CD including projects, Git integration, builds, previews, environment variables, checks, deployment inspection, aliases, promotion, rollback, and cleanup. Use when linking or deploying a project, configuring preview and production, diagnosing builds, promoting, rolling back, or cleaning deployments.

Operate Vercel content delivery including domains, DNS, TLS, CDN caching, cache-control headers, redirects, rewrites, compression, static assets, and targeted invalidation. Use when adding a domain, fixing TLS or caching, changing redirects, or diagnosing stale and regional delivery.

Inspect Vercel CLI and account state, team and project links, Git context, deployments, environment variable names, domains, build configuration, runtime settings, and observability without changing anything. Use before Vercel platform work, when scope is uncertain, or when the user asks what is configured.

Operate Vercel Functions and Fluid Compute across runtimes, regions, concurrency, duration, memory, streaming, background work, connection reuse, and resource limits. Use when configuring compute, fixing timeouts or cold starts, scaling functions, or controlling runtime cost and behavior.

Connect Vercel Core Platform to Git providers, build systems, DNS, identity, data services, observability destinations, CI checks, and incident processes while preserving account and environment boundaries. Use when the platform must cross another system or support an end-to-end delivery flow.

Operate Vercel observability across runtime logs, metrics, traces, Web Analytics, Speed Insights, dashboards, alerts, drains, retention, and incident correlation. Use when adding telemetry, diagnosing production, configuring alerts, exporting data, or reviewing performance and reliability.

Operate Vercel platform security including firewall rules, WAF, bot management, security headers, deployment protection, secure compute boundaries, roles, audit, and incident safeguards. Use when hardening a project, changing traffic security, reviewing access, or responding to abuse and incidents.

Install and configure Vercel Core Platform access from zero with a project-local CLI, exact team and project, Git and build settings, separated environments, safe authentication, one local build, and explicit deployment approval. Use when a repository has no Vercel setup or the user asks to initialize platform access.

Diagnose Vercel Core Platform failures involving account and project scope, builds, deployments, environments, domains, CDN caching, functions, security policy, observability, and CI/CD without masking the original error. Use when a build or deployment fails, traffic is wrong, production differs from preview, or platform behavior is unexpected.

Configure eve channels and schedules with platform triggers, cron definitions, identities, delivery targets, autonomous-run bounds, timezone handling, and failure recovery. Use when putting an agent in chat, adding scheduled work, changing triggers, or diagnosing duplicate and missed autonomous runs.

Look up Vercel eve commands, configuration, policy, and focused operations across definitions and tools, sessions and workflows, subagents and approvals, channels and schedules, evals and observability. Use when the user wants a concise reference instead of a guided workflow.

Create and operate eve agent definitions, instructions, model configuration, skills, MCP connections, and typed tools with explicit authority and validation. Use when defining an agent, adding knowledge or tools, configuring a model, or connecting an MCP server.

Inspect Vercel eve versions, local project structure, account or team context, environment variable names, configured resources, policies, observability, and safe checks without changing anything. Use before Vercel eve work, when the target is uncertain, or when the user asks what is configured.

Author and operate eve eval suites, CI gates, Agent Runs, traces, token and tool accounting, redaction, retention, and regression review. Use when testing an agent, gating deployment, inspecting a failed run, or measuring prompt and tool changes.

Connect Vercel eve to application runtimes, identity, external services, persistence, observability, CI, and deployment while preserving account, credential, data, and action boundaries. Use when Vercel eve must cross another system or operate consistently through production.

Operate eve durable sessions and workflow-backed conversations including creation, streaming, continuation tokens, checkpoints, pause, resume, crash recovery, and version behavior. Use when starting or resuming sessions, fixing lost progress, consuming the session API, or validating durability.

Install and configure Vercel eve from zero with project-local tooling, exact account and project scope, server-only credentials, baseline policies, one minimal feature, and bounded verification. Use when a project has no Vercel eve setup or the user explicitly asks to initialize it.

Design eve built-in and declared subagents plus durable human approvals with scoped delegation, isolated context, permission boundaries, decision payloads, and resume behavior. Use when adding specialists, delegating parallel work, or requiring a person to approve consequential agent actions.

Diagnose Vercel eve failures involving versions, account scope, credentials, permissions, configuration, remote resources, durability, providers, observability, costs, and deployment without masking the original error. Use when Vercel eve fails, behaves differently across environments, or causes unexpected remote effects.

Look up Vercel Passport account, identity provider, project protection, visitor identity, team policy, session, and verification patterns. Use when the user wants a concise Passport reference instead of a guided workflow.

Inspect Vercel Passport plan access, team and project scope, provider applications, project assignments, team defaults, deployment protection, visitor-identity code, and safe checks without changing anything. Use before Passport work, when access behavior is uncertain, or when the user asks what is configured.

Configure Vercel Passport identity provider applications with OAuth or OpenID Connect discovery, issuer and endpoints, confidential clients, redirect URI, scopes, assignments, and secret rotation. Use when connecting Okta, Auth0, Entra, or another provider, repairing discovery, or rotating the provider application secret.

Connect Vercel Passport to an identity provider, server-side application authorization, local user mapping, audit systems, CI previews, and deployment operations while preserving identity and secret boundaries. Use when Passport identity must cross into application or enterprise systems.

Operate Vercel Passport protection for individual projects, including enablement, identity provider assignment, deployment coverage, interaction with other protection methods, verification, and rollback. Use when protecting an internal project, changing its provider, checking deployment access, or disabling Passport.

Operate Vercel Passport session and audit behavior including cookies, expiry, provider deprovisioning, access review, project coverage evidence, log redaction, incident response, and recovery. Use when investigating persistent access, reviewing who can enter deployments, handling deprovisioning, or responding to a protection incident.

Configure Vercel Passport from zero with an Enterprise team, reviewed OAuth or OpenID Connect provider application, exact callback, project or team policy, server-side visitor identity, and bounded access verification. Use when a team has no Passport setup or the user explicitly asks to protect deployments.

Manage Vercel Passport team-wide defaults, new-project inheritance, bulk assignment to existing projects, exceptions, administrator roles, rollout inventory, and rollback. Use when standardizing internal app protection, assigning Passport across projects, or auditing team coverage.

Diagnose Vercel Passport failures involving plan and roles, provider discovery, callback and endpoints, client credentials, scopes, assignments, project protection, visitor claims, sessions, and deployment access without weakening protection. Use when sign-in loops, access is denied or unexpectedly allowed, identity is missing, or rollout coverage is wrong.

Read and use Vercel Passport visitor identity from the injected token header with stable external subject claims, server-only handling, claim validation, authorization mapping, and spoofing resistance. Use when identifying authenticated visitors, mapping them to local users, protecting server routes, or debugging missing claims.

Look up Vercel Sandbox commands, configuration, lifecycle controls, and focused operations across lifecycle, commands and files, runtimes and snapshots, networking and exposure, security and limits. Use when the user wants a concise reference instead of a guided workflow.

Execute Vercel Sandbox commands and operate files with explicit argv, working directories, environment allowlists, streaming output, upload, download, atomic writes, and path validation. Use when running code in a sandbox, transferring files, streaming logs, or modifying a sandbox filesystem.

Inspect Vercel Sandbox package and CLI versions, project and account context, configuration, environment variable names, resources or runs, persistence, limits, and safe checks without changing anything. Use before Vercel Sandbox work, when the target is uncertain, or when the user asks what is configured.

Connect Vercel Sandbox to application runtimes, identity, storage, external events, observability, CI, and deployment while preserving isolation, durability, credential, and action boundaries. Use when Vercel Sandbox crosses another system or must operate consistently through production.

Operate Vercel Sandbox v2 lifecycle including creation, lookup, persistence, timeout, reconnection, stop, exit, and deterministic cleanup. Use when creating or resuming a sandbox, changing lifetime, inspecting state, or cleaning up persistent remote compute.

Operate Vercel Sandbox networking including outbound requests, DNS, development servers, port exposure, live preview URLs, request proxying, and network restrictions. Use when a sandbox needs network access, must run a server, expose a preview, or cannot reach a dependency.

Configure Vercel Sandbox runtimes, dependency installation, environment images, snapshots, restore, reproducibility, and safe reuse boundaries. Use when choosing Node or Python runtime, speeding startup, capturing a prepared environment, or restoring consistent sandboxes.

Harden Vercel Sandbox use with threat modeling, process and filesystem isolation, sudo controls, compute and storage limits, timeouts, abuse prevention, audit logs, and incident cleanup. Use when running untrusted code, reviewing sandbox safety, setting resource controls, or responding to suspicious execution.

Install and configure Vercel Sandbox from zero with project-local packages, exact account and environment scope, server-only authentication, baseline limits and persistence, one minimal operation, and bounded verification. Use when a project has no Vercel Sandbox setup or the user explicitly asks to initialize it.

Diagnose Vercel Sandbox failures involving versions, scope, authentication, resource or run state, persistence, retries, timeouts, isolation, networking, observability, usage, and deployment without masking the original error. Use when Vercel Sandbox fails, stalls, resumes incorrectly, or causes unexpected remote effects.

Look up Vercel Workflows commands, configuration, lifecycle controls, and focused operations across definitions and steps, durability and retries, sleep and events, human approval, versioning and observability. Use when the user wants a concise reference instead of a guided workflow.

Author Vercel Workflow definitions and steps with directives, serializable inputs and outputs, deterministic orchestration, side-effect boundaries, and typed results. Use when creating a workflow, splitting work into steps, fixing serialization, or moving side effects into durable boundaries.

Configure workflow durability, checkpoints, retries, backoff, timeouts, idempotency, crash recovery, compensation, and poison-step handling. Use when a workflow must survive failures, retries duplicate work, or recovery and compensation need design.

Inspect Vercel Workflows package and CLI versions, project and account context, configuration, environment variable names, resources or runs, persistence, limits, and safe checks without changing anything. Use before Vercel Workflows work, when the target is uncertain, or when the user asks what is configured.

Implement human-in-the-loop workflow approvals with immutable action previews, approver identity, authorization, expiry, denial, audit, and durable resume semantics. Use when a workflow proposes consequential action, must pause for review, or approval behavior is incorrect.

Connect Vercel Workflows to application runtimes, identity, storage, external events, observability, CI, and deployment while preserving isolation, durability, credential, and action boundaries. Use when Vercel Workflows crosses another system or must operate consistently through production.

Install and configure Vercel Workflows from zero with project-local packages, exact account and environment scope, server-only authentication, baseline limits and persistence, one minimal operation, and bounded verification. Use when a project has no Vercel Workflows setup or the user explicitly asks to initialize it.

Operate durable workflow sleeps, timers, hooks, events, correlation identifiers, external callbacks, races, timeout paths, and resume validation. Use when pausing without compute, waiting for an external event, resuming from callbacks, or handling timeout races.

Diagnose Vercel Workflows failures involving versions, scope, authentication, resource or run state, persistence, retries, timeouts, isolation, networking, observability, usage, and deployment without masking the original error. Use when Vercel Workflows fails, stalls, resumes incorrectly, or causes unexpected remote effects.

Operate workflow versioning and observability including atomic deployment versions, run history, step timelines, logs, traces, usage, schema migration, rollback, and incident review. Use when deploying workflow changes, inspecting runs, correlating failures, or rolling back without corrupting in-flight work.

Wire and repair AuthKit sign-in, covering the hosted sign-in and sign-up URLs, organization-scoped sign-in, the callback exchange, encrypted session cookies, middleware refresh of short-lived access tokens, reading the user and role on the server, protecting routes by default, impersonation, and sign-out. Use when sign-in must be added or fixed, when users are unexpectedly signed out, when a callback fails, or when route protection must be added.

Answer quick WorkOS questions with a compact reference for AuthKit sign-in and callback calls, session helpers, single sign-on and directory sync APIs, organization and membership calls, user management, webhook verification, environment values and their scope, and the staging versus production distinction. Use when someone asks which WorkOS call or environment value to use, or wants a fast lookup rather than a guided workflow.

Set up and reconcile directory sync, covering the Admin Portal handoff for SCIM and directory providers, directory states, cursor-paginated listing of users and groups, mapping directory users and groups onto local records and roles, handling activate and deactivate events rather than deletions, group membership changes, and a full reconciliation pass when events were missed. Use when an enterprise customer must provision users automatically, when a directory shows fewer users than expected, or when deprovisioning has not taken effect in the application.

Inspect which WorkOS environment an application targets, which API key and client id it holds, whether the redirect URI matches a registered one, the cookie password strength, the configured connections and directories per organization, and which webhook endpoints exist, without changing anything. Use before a WorkOS operation, when sign-in fails on a redirect, when an object seems missing, or when the user asks whether WorkOS is set up.

Connect WorkOS to the systems around it, covering framework SDKs and session middleware, mirroring users and organizations into a local database, scoping every query by the organization from the session, protecting an API boundary with a verified token, machine-to-machine access, tying billing to an organization, and staging versus production promotion. Use when WorkOS identity must reach a local user table, when an API or another service must trust a WorkOS session, or when tenant scoping must be enforced.

Discover, compatibility-check, install, update, list, or remove WorkOS's first-party coding-agent skills. Use when asked about WorkOS native skills, workos skills commands, AuthKit agent setup, or whether the installed WorkOS skill matches the project's current SDK.

Manage WorkOS organizations and their members, covering creating organizations, verified domains and domain-based joining, memberships and role slugs, invitations, listing and pagination, mapping an organization onto a local tenant record, switching the active organization in a session, and deleting an organization and what that removes. Use when a tenant must be created or renamed, when a domain must be added, when members or roles must change, or when a user belongs to more than one organization.

Set up WorkOS in an application from zero, covering the environment and API key, client id, a cookie password of sufficient length, registered redirect URIs, the AuthKit SDK install and callback route, middleware for session refresh, the sign-out redirect, and keeping staging separate from production. Use when an application has no WorkOS wiring, when keys and redirect URIs must be configured, or when the user asks how to get WorkOS working.

Configure and test enterprise single sign-on connections, covering SAML and OpenID Connect connection types, the Admin Portal handoff to a customer's identity provider administrator, connection states, domain verification and identifier-first routing, attribute and profile mapping, just-in-time provisioning, and testing a connection before it goes live. Use when an enterprise customer must sign in with their own identity provider, when a connection is inactive or misconfigured, or when profile attributes arrive wrong or missing.

Diagnose WorkOS failures from reproducible evidence, covering wrong environment and key mismatches, unregistered or mismatched redirect URIs, short cookie passwords, missing session refresh, inactive connections and directories, partial directory listings from unpaginated reads, webhook signature failures and duplicate delivery, missing role slugs after promotion, and cross-tenant scoping mistakes. Use when sign-in fails or loops, when users are unexpectedly signed out, when an object seems missing, or when events arrive but nothing happens.

Receive and handle WorkOS webhook events safely, covering endpoint registration per environment, signature verification against the raw request body, replay-window tolerance, idempotency keyed on the event id, acknowledging quickly and processing afterwards, ordering and out-of-order delivery, retries and failure handling, and local delivery for development. Use when an endpoint must consume WorkOS events, when events arrive but nothing happens, when signature verification fails, or when an event has been applied twice.

Call, spawn, or delegate to an AI agent running in a different harness (Claude Code, Codex CLI, Gemini CLI) and collect its output. Use whenever one agent should hand a task to a model it cannot run itself — for example Codex (GPT 5.6) calling Claude Code (Claude Fable 5) for UI work, or Claude Code calling Codex (GPT 5.6 Luna) to generate a title — including cross-model second opinions, fan-out to parallel workers, and multi-turn sessions with another CLI agent.

Decide which model gets which task when delegating work across harnesses — routes UI, design, and copywriting to Claude Fable 5 (with Sonnet 5 and Opus 4.8 fallbacks) and everything else to a GPT 5.6 tier (Luna, Terra, or Sol) by scope and impact. Use whenever an agent must choose a model for a delegated task, pick between GPT and Claude for a job, apply the team's model routing policy, or resolve a fallback when the assigned model is unavailable.

Apply the visual and interaction language of v0/www to new or existing web interfaces: neutral semantic color tokens, Inter/mono typography, type-led hierarchy, restrained shadcn components, compact analytical variants, accessible responsive layouts, and honest data visualization. Use when designing, restyling, reviewing, or implementing a website, dashboard, catalog, report, benchmark UI, or data-heavy frontend that should look and behave like 11ai.

Build or restyle a web interface toward the contemporary 'modern clean' look used by products like Linear, Vercel, and shadcn/ui: neutral surfaces with one accent color, generous whitespace, clear type hierarchy, soft borders and shadows instead of heavy chrome, and restrained motion. Framework-agnostic principles with concrete Tailwind/shadcn guidance. Use when the user asks for a UI that looks modern, clean, minimal, polished, or professional; wants a design system or styleguide for a new app; says a page looks '90s', cluttered, generic, or like a template; or is starting a new product's frontend and wants it to look and feel high quality from the first screen.

Take an application's user-facing content, reach one deliberate style and design decision for it, and execute that design end to end — using the tools already in the codebase first (framework, CSS system, component library, theme tokens, fonts), installing at most one or two small critical packages when something essential is missing. Use when the user asks to style, restyle, polish, or "pimp" a UI, make an app or page look designed instead of default, pick a visual direction for existing content, or upgrade a working-but-plain interface — standalone, with no other skill required.

Examine a project, decide what its public site should display, choose a design direction, and build an elegant frontend that presents the project — either in a dedicated www/ folder or embedded in an existing app. The site treats the repository as its single source of truth: real project files are scanned at build time, so content, counts, and catalog pages update automatically when the project changes. Use when the user asks for a project site, a landing page for a repo, a catalog or docs browser over repository content, "build a www for this", or "display the concept of the project" — and follow through from content inventory to a verified, statically generated build.

Continuously audit a repository's AI-agent marketplace, plugin, and skill configuration surfaces against the published specifications for Claude Code, Claude Cowork, OpenAI Codex, ChatGPT, and the open Agent Skills standard until no confirmed critical or major finding remains. Read-only: discovers which config surfaces exist, checks every manifest field, enum value, path, limit, and cross-file consistency rule from bundled conformance references, records evidence-backed findings in a severity-ranked ledger, writes a timestamped Markdown report, and re-audits with fresh lenses after each pass. Use when asked to audit, verify, or continuously check marketplace.json, plugin.json, SKILL.md, or agents/openai.yaml conformance, or before publishing a skills repository to multiple agent ecosystems.

Answer questions about marketplace, plugin, and skill configuration formats across Claude Code, Claude Cowork, claude.ai, the Claude API, OpenAI Codex, ChatGPT, the open Agent Skills standard, and the skills.sh CLI, from bundled research references verified against official docs, JSON schemas, and vendor source code on 2026-08-06. Covers file locations, every schema field and enum value, source variants, policy values, install flows, settings, caching, and how this repository's own config surfaces and validator map onto each ecosystem. Use when a user asks how any of these config files work, which fields or values are allowed, how the ecosystems differ, or where 11ai deviates from a spec.

A stand-in for the 11ai-security plugin while its real skills are built: threat modeling, secure-coding review, and secrets handling. It runs no checks itself. Use it to learn what this plugin is for, and read the 11ai-audit plugin instead if you want a security check that works today.