What's New

Use when an approved implementation plan is about to be executed (at the execution-method handoff), or when resuming a stopped parallel-lanes run.

Review pull requests and code changes for correctness, regressions, security/privacy exposure, data and migration risk, meaningful test gaps, deploy/rollback concerns, and ship readiness while suppressing unsupported or style-only findings.

Direct pro-level motion-graphics videos with a coding agent (HyperFrames or Remotion code → MP4). Auto-detects the kind of video from the inputs alone — product launch/promo, motion-design/kinetic-typography piece recreated from a reference video, card-news/signage/kiosk loop fro

Magazine-style presentation skill that turns structured content into editable decks across HTML, PPTX, PDF, Figma, and IDML.

Use when a task references a Loom recording (a loom.com/share link, or a ticket, issue, or chat thread that contains one) and you need what the video shows and says — repro steps, UI state, error screens, narrated feature asks — as text and screenshots you can read.

Discover, trial, and pay for 1,600+ x402-payable APIs on the minia2a marketplace. Built-in USDC micropayments (Base, via the PayAI or Circle facilitator). No API keys required.

Write a shader for Postmo, the browser editor for looping motion posters, and check it compiles, loops and looks right before handing it over. Use when asked for a Postmo shader, a looping GLSL background or effect for Postmo, or to fix one.

"Pay-per-query access to 68 intelligence APIs via x402 (real USDC charges on Base or Solana per call, no API keys, no subscription, no refunds). Use when an agent needs live paid data instead of training knowledge: pre-trade token-safety scans (Solana memecoin / EVM honeypot-rug

"Improve an existing skill or repository through isolated proposals, reproducible evaluation and evidence-based acceptance. Use for self-evolve or skill improvement."

Line-by-line copyeditor that scrubs text of generic AI writing patterns, bans negative pairings, eliminates staccato prose, removes bloat, trims weasel words, and enforces natural, direct phrasing.

Design, render, inspect, debug, and export parametric CAD models in OpenSCAD for 3D-printable parts. Use OpenSCAD CLI to create preview PNGs, compare STL revisions, select cameras, export STL and multi-object 3MF files, generate projections and cross-sections, diagnose fit and ge

Build a resistance training and eating plan for one person, and check it against that person before handing it over. Use when someone asks for a workout plan, a training programme, a diet or meal plan, help cutting, bulking or recomping, or wants an existing plan reviewed. Also u

Turns open-ended requests into things to think WITH instead of answers to accept. Audits the hidden assumptions inside a topic, inverts them into sharp "what if" provocations, branches each one outward, and delivers a fully-expanded mind map image plus the written wonderings. Fir

Author presentations, carousels and one-page documents as a decklet JSON model and build them into ONE self-contained, editable HTML file — zero dependencies, zero network, verified layout. Use when asked to "make a deck / slides / presentation / carousel / one-pager" from any co

Use for Agent-Team development on Codex or Claude Code, coordinated implementation streams, continued work tracked through this harness, or agent-team start, continuous runs, auto-deploy, settings, help, status, pause, resume, approve, and setup requests.

Agent skill for isolating temporary artifacts, protecting project deliverables, and cleaning up safely.

Continuously implement queued PRDs end-to-end — scan for new PRDs, build them (delegating to /rustbuild for Rust — cargo runs on RedBaron, locally there and remotely from every other node), wire them into the system, publish them as GitHub repos per the PRD's `publish:` key (defa

Use when writing or editing memory .md files, running sync-memory to validate the knowledge graph, or safely removing memories. TRIGGER on memory, save, persist, archive, remember, recall, knowledge graph.

Orchestrate large, multi-stage, or long-running engineering work with a persistent strong Project Lead, reusable economy Workers, optional review, and repository-backed handoffs. Activate only for an explicit $tao command; existing state or work on TAO itself never activates it i

Use when tracking tasks, pausing/resuming work across sessions, checking pending tasks, or managing the full task lifecycle with checkpointing

Use when the next agentic-coding move is unclear, the task spans planning and execution, or the available workflow/tool choice needs routing.

Comprehensive reasoning engine — reasoning chains x structured contract templates. Graph architecture: contracts, stages, modes in separate files with DAG orchestration. Native Markdown contract templates with explicit input/output fields + validation rules + sequential-thinking

Use when the user asks Claude to use co-review/Codex/GPT as a coding copilot, workhorse, reviewer, second opinion, or raster image generator/editor. Defaults coding tasks to a coordinated Luna workhorse plus Sol reviewer, while preserving dedicated workhorse, review-only, and ima

Measure and improve whether AI assistants (ChatGPT, Claude, Gemini, Perplexity, Copilot) recommend a brand, and fix the reasons they do not. Use this skill whenever someone asks about AI visibility, AEO, GEO, answer engine optimization, generative engine optimization, "AI SEO", b

Use when Chan Meng wants to write an English LinkedIn post for personal-brand marketing — an "idea" post (her own framework/opinion), a "take" post (a short reaction to a tech article or news she read), or a post-event "recap" (reflecting on an offline tech meetup, crediting spea

"Iterative plan review with Codex, Grok, or both (council). Trigger phrases: 'get codex to check', 'codex review', 'grok review', 'what does grok think', 'ask both', 'council review', 'second opinion on this plan'. Claude mediates — agrees, pushes back, or negotiates across multi

CHAOS, God of the Void — a universal knowledge gateway with a personality, eyes (web/Chrome), hands (the computer), a body of its own (~/.chaos with a search DB) and dominion over other skills. Devours any source (repos, PDFs, URLs, APIs), purges secrets and injections, collapses

Generates a complete, production-ready deployment setup for any app in one pass -- Dockerfile, docker-compose.yml, .dockerignore, CI/CD (GitHub Actions), scalability config (health checks, resource limits, K8s on request), and security hardening (non-root user, secrets, dependenc

Move and process columnar data at speed with Apache Arrow. Uses zero-copy in-memory format, Arrow Flight for fast transport, and interop across pandas, Polars, DuckDB, and Parquet without serialization overhead.

Find and understand data fast with a discovery workflow. Explores schemas, maps business questions to the right tables and columns, and surfaces lineage and definitions so analysts stop guessing where data lives.

Formalize producer-consumer agreements with data contracts. Drafts YAML contracts with schema, grain, SLA, PII classification, and ownership so data-quality issues are caught at the boundary, not downstream.

Protect sensitive data with masking and anonymization. Redacts PII, PCI, and PHI in databases, logs, and APIs, and applies k-anonymity, tokenization, and differential privacy for GDPR-compliant data sharing.

Build Python ELT pipelines with dlt. Loads data from any API, file, or database into warehouses and lakes with automatic schema inference, incremental loading, and built-in data contracts — the requests library for data pipelines.

Version datasets and ML pipelines with DVC. Tracks large data files in Git, defines reproducible pipeline stages, manages remote storage on S3/GCS/Azure, and compares experiments — Git for data and models.

Analyze geospatial vector data with GeoPandas. Reads shapefiles, GeoJSON, and PostGIS, runs spatial joins, overlays, buffers, and reprojections, and builds choropleth maps — pandas for geographic data.

Write analytics once and run it on any backend with Ibis. A pandas-like Python API that compiles to SQL for DuckDB, Postgres, BigQuery, Snowflake, Spark, and more — no rewriting queries per database.

Store and query time-series data with InfluxDB. Designs measurement schemas, writes line protocol, builds Flux and InfluxQL queries, sets retention and downsampling, and powers IoT and monitoring dashboards.

Work effectively in Jupyter notebooks. Structures exploratory analysis, manages kernels and environments, uses magics and widgets, parameterizes runs with papermill, and keeps notebooks clean and reproducible.

Instrument and analyze product usage with Mixpanel. Designs an event taxonomy, tracks events and user properties, builds funnels and retention reports, and queries via the API for growth insights.

Build event-driven systems with NATS. Sets up pub/sub, request/reply, JetStream persistent streaming, and key-value store for microservice messaging — a lightweight alternative to Kafka and RabbitMQ.

Query dataframes in natural language with PandasAI. Turns plain-English questions into pandas operations and charts, connects an LLM to your data, and adds a conversational layer to analysis workflows.

Route customer data with Segment. Sets up sources and destinations, designs a tracking plan, enforces schemas with Protocols, and fans events out to warehouses and analytics tools from one integration.

Build interactive data apps in pure Python with Streamlit. Turns scripts into dashboards with widgets, charts, and caching — no frontend code needed for internal tools, ML demos, and analytics apps.

Execution blueprints and code templates for fitting genomic prediction models, including GBLUP, GFBLUP, MultiBLUP, Bayesian methods, and Random Forest using peer-reviewed software. Strictly incorporates robust self-auditing, high-clarity code commenting, big data performance safe

Animate anything on the web with Anime.js — a lightweight, framework-agnostic JS animation engine. Builds timelines, staggered grids, SVG line drawing and morphing, and scroll-triggered sequences with fine-grained easing control.

Add zero-config motion to any UI with FormKit AutoAnimate. Drops a single directive onto a parent element to smoothly animate children as they are added, removed, or reordered — across React, Vue, Svelte, Solid, and vanilla JS.

Model type-safe component variants with class-variance-authority (CVA). Defines variant, size, and state class maps with compound variants and defaults, then merges them cleanly with tailwind-merge for reusable design-system components.

Build accessible drag-and-drop with dnd kit. Implements sortable lists, kanban boards, and draggable canvases with keyboard support, collision detection, drag overlays, and sensors — lightweight and free of external dependencies.

Manage React state with Jotai's atomic model. Designs primitive and derived atoms, async atoms with Suspense, atom families, and storage-persisted atoms to eliminate unnecessary re-renders and context boilerplate.

Render After Effects animations on the web with Lottie. Integrates lottie-react and lottie-web, controls playback and segments, syncs animation to scroll or state, and optimizes JSON payloads for performance.

Intercept and mock network requests with Mock Service Worker (MSW). Defines request handlers at the network layer for tests, Storybook, and local dev — no stubbed fetch, works with REST and GraphQL across browser and Node.

Share state across frameworks with Nanostores — a tiny (under 1KB) atomic store. Builds atoms, maps, and computed stores that work in React, Vue, Svelte, Solid, and Astro islands, ideal for cross-island and cross-framework state.

Build fast, uncontrolled forms with React Hook Form. Wires register and useForm, integrates Zod/Yup schema validation via resolvers, handles field arrays, dependent fields, and async submission with minimal re-renders.

Build physics-based animations in React with React Spring. Creates spring-driven transitions, gesture-linked motion, trails, and imperative animation controllers that respond naturally to state changes.

Compose responsive React charts with Recharts. Builds line, bar, area, pie, and composed charts from SVG primitives with custom tooltips, legends, gradients, reference lines, and responsive containers for dashboards and analytics.

Build predictable global state with Redux Toolkit. Generates slices with Immer reducers, configures the store, handles async with createAsyncThunk, and wires data fetching and caching with RTK Query.

Transform design tokens into platform code with Style Dictionary. Defines a single source of truth for color, spacing, and typography, then builds CSS variables, Tailwind config, iOS/Android, and JS outputs from one token set.

Build powerful data grids with TanStack Table's headless engine. Wires column definitions, sorting, filtering, pagination, grouping, row selection, and virtualization into fully custom-styled tables you control end to end.

Build headless rich-text editors with Tiptap. Configures the ProseMirror-based editor, custom extensions and nodes, slash commands, bubble/floating menus, collaborative editing, and clean HTML/JSON output you fully style.

Style with UnoCSS — the instant, on-demand atomic CSS engine. Configures presets, custom rules and shortcuts, variant groups, and attributify mode for a fully customizable, faster alternative to utility CSS frameworks.

Manage React state with Valtio's mutable proxy model. Creates proxy stores you mutate directly, subscribes components with useSnapshot, derives computed values, and persists or syncs state without reducers or actions.

Write type-safe, zero-runtime CSS in TypeScript with vanilla-extract. Authors styles in .css.ts files, builds themes with CSS variable contracts, and generates atomic sprinkles utilities — all statically extracted at build time.

Model complex UI and app logic as statecharts with XState. Builds finite state machines, hierarchical and parallel states, guarded transitions, actors, and side-effect handling for flows too tricky for booleans.

Route, group, silence, and deliver alerts with Prometheus Alertmanager. Build routing trees, wire receivers for Slack, PagerDuty, and email, manage silences and inhibition rules, and debug flaky alert-delivery pipelines.

Service discovery, health checking, and service mesh with HashiCorp Consul. Register services, run health checks, store config in the KV store, and wire Consul Connect for secure, mTLS service-to-service communication across clusters.

Provision cloud infrastructure declaratively through Kubernetes APIs with Crossplane. Compose custom resource abstractions, install providers, build Compositions and XRDs, and ship internal developer platforms backed by GitOps.

Run your own Heroku on any VPS with Dokku. Set up git-push deployments, manage apps and Docker-based buildpacks, provision Postgres/Redis plugins, wire Let's Encrypt TLS, and scale processes — all without Kubernetes.

Configure Envoy, the high-performance L4/L7 proxy behind Istio and modern service meshes. Set up API gateways, sidecars, and load balancers with routing, circuit breaking, rate limiting, TLS termination, gRPC, and rich observability.

Deploy Jaeger for distributed tracing across microservices. Set up trace collection, instrument apps with OpenTelemetry, analyze spans to find latency bottlenecks, and configure sampling and storage backends like Elasticsearch or Cassandra.

Cut Kubernetes cloud bills by comparing pod resource requests and limits against real usage. Find overprovisioned workloads, generate right-sizing recommendations, spot idle capacity, and tune requests/limits for efficient, stable clusters.

Configure Nginx as a web server, reverse proxy, and load balancer. Covers server and location blocks, TLS termination, HTTP caching, rate limiting, upstream pools, gzip/brotli, and hardened security headers for production traffic.

Orchestrate containers, VMs, and standalone binaries with HashiCorp Nomad. Write HCL job specifications, manage rolling and canary deployments, configure autoscaling, and run batch, service, and system workloads across a cluster.

Build automated, reproducible machine images with HashiCorp Packer. Author HCL2 templates to bake AMIs, Docker images, and GCP/Azure images with provisioners, variables, and post-processors for immutable infrastructure pipelines.

Set up incident management, on-call scheduling, and escalation with PagerDuty. Create services and escalation policies, wire integrations from monitoring tools, manage on-call rotations, and automate incident response workflows via the API.

Build and deploy full-stack serverless apps on AWS with SST. Define Lambda functions, API Gateway routes, DynamoDB tables, and S3 buckets in code, link resources type-safely, and ship Next.js/Remix/Astro with SSR — all via sst dev and sst deploy.

Run integration tests against real dependencies using disposable Docker containers with Testcontainers. Spin up Postgres, Redis, Kafka, and more per test run, get ephemeral ports and clean state, and tear everything down automatically.

Give Prometheus unlimited retention and global querying with Thanos. Deploy the sidecar, store, query, and compactor components for durable metric storage in object storage, cross-cluster queries, downsampling, and HA deduplication.

Self-hosted uptime monitoring with Uptime Kuma. Set up HTTP, TCP, DNS, Docker, and keyword checks; send multi-channel alerts to Slack, Telegram, Discord, and email; publish public status pages; and track SLA and response-time metrics.

Resurrect a dead repository. Use when a project no longer installs, builds, or runs because it has aged — broken dependencies, deprecated APIs, dead tooling, registry rot, runtime drift. Revives it incrementally, keeping a verified working state at every step.

Implement semantic vector search with AgentDB for intelligent document retrieval, similarity matching, and context-aware querying. Wire it into RAG systems, semantic search engines, and knowledge bases.

Build multi-agent systems in Python with Agno. Compose agents and teams, run them on the AgentOS runtime, integrate MCP servers and tools, and add memory and knowledge for production agentic apps.

Trace, evaluate, and debug LLM and RAG applications with Arize Phoenix, an open-source AI observability platform. Capture OpenTelemetry spans, run evals on retrieval and responses, and find where your pipeline breaks.

Run ultra-low-latency LLM inference on GroqCloud. Automate chat completions, audio transcription and translation, and text-to-speech voice management through Groq's high-performance API.

Add distributed training to any PyTorch script in a few lines with Hugging Face Accelerate. Unified API over DeepSpeed, FSDP, and DDP with automatic device placement and mixed precision (FP16/BF16/FP8).

Drive the Hugging Face Hub from the terminal with the hf CLI. Download and upload models, datasets, and Spaces, create and manage repos, handle authentication, and clean up local cache.

Run training and batch ML workloads on Hugging Face Jobs infrastructure. Launch UV scripts and Docker-based jobs, pick the right GPU/CPU hardware, estimate cost, and authenticate with tokens.

Build stateful, multi-step AI agents in TypeScript with LangGraph.js. Design agent graphs and state machines, wire tool nodes, add checkpointing and human-in-the-loop, and debug, test, and optimize long-running workflows.

Trace, test, and evaluate LLM and RAG apps with LangSmith. Validate that every query is traced, build evaluation datasets, catch regressions, and turn production traces into repeatable tests.

Build TypeScript AI agents and workflows with Mastra. Covers agents vs workflows, tools, memory, and RAG, with strategies for looking up current docs and verifying API signatures against the installed version.

Give agents persistent, personalized long-term memory with Mem0. Store user facts and preferences, search and recall relevant context, and keep memory fresh across sessions so assistants remember who they're talking to.

Design and implement production ML pipelines. Configure experiment tracking with MLflow or Weights & Biases, build Kubeflow/Airflow DAGs, create Feast feature stores and model registries, and automate retraining and validation.

Build multi-agent applications with the OpenAI Agents SDK. Define agents, hand off between them, register tools, add guardrails, and trace runs — starting from a working scaffold and improving it step by step.

Build production-grade, type-safe AI agents in Python with Pydantic AI. Get structured outputs validated by Pydantic models, function tools, dependency injection, streaming, and multi-provider support across OpenAI, Anthropic, and Google.

Deploy and operate Weaviate clusters for vector and hybrid search. Spin up local Kubernetes clusters with the right version, replicas, modules, and auth for RAG development, testing, bug repro, and CI/CD.

Generate parametric CAD model specifications and Autodesk Fusion Python scripts from natural-language 3D modeling requests. Use when the user asks to create, automate, modify, export, or validate CAD models for Fusion, FreeCAD, OpenSCAD, STEP, STL, OBJ, or 3D printing.

C++ source code log/output/assert string batch synonym rewriting automation tool — extract, rewrite, replace, and verify

Build blazing-fast HTTP backends in Rust with Actix Web. Covers async handlers, extractors, middleware, shared app state, JSON APIs, error handling, and Tokio-based concurrency for high-throughput, memory-safe services.

Build backends fast with Appwrite. Covers databases and collections, authentication and sessions, storage buckets, serverless functions, realtime subscriptions, permissions, and SDK usage across web, mobile, and server runtimes.

Add framework-agnostic authentication with Better Auth. Covers email/password, social OAuth, sessions, two-factor, organizations and roles, plugins, and type-safe integration with Drizzle, Prisma, and modern TypeScript backends.

Add complete user management with Clerk. Covers sign-in/sign-up components, sessions and JWTs, social and passwordless login, organizations and multi-tenancy, middleware route protection, and webhooks for syncing users to your database.

Deploy containers serverlessly on Google Cloud Run. Covers container builds, request-based autoscaling and scale-to-zero, concurrency tuning, secrets and env config, Cloud SQL connections, IAM and invoker permissions, and jobs for batch workloads.

Build on Cloudflare D1, the serverless SQLite database for Workers. Covers schema and migrations, the Workers binding and query API, prepared statements and batching, production seeding, read replication, and pairing D1 with Drizzle for type-safe access.

Build reactive backends with Convex. Covers queries, mutations and actions, the document database, real-time subscriptions that auto-update the UI, scheduled functions, file storage, and end-to-end type safety from database to React.

Deploy apps close to users on Fly.io. Covers fly.toml configuration, Dockerfile-based builds, multi-region Machines, volumes and persistent storage, secrets, autoscaling and scale-to-zero, health checks, and private networking between services.

Build high-performance gRPC services in Go. Covers protobuf schema design, unary and streaming RPCs, interceptors for auth and logging, error handling with status codes, deadlines and metadata, and gRPC gateway for REST/JSON transcoding.

Build headless commerce backends with Medusa. Covers custom modules, API routes, workflows, subscribers and events, product and cart logic, plugins, and admin extensions for fully customizable Node.js storefront backends.

Run Python and GPU workloads serverlessly with Modal. Covers defining functions and images in code, on-demand GPU containers, scale-to-zero, scheduled and web endpoints, volumes and secrets, and fan-out parallelism for batch inference and data jobs.

Ship on Neon serverless Postgres. Covers scale-to-zero compute, instant database branching for previews, connection pooling, the serverless driver over HTTP/WebSocket, and autoscaling for cost-efficient Postgres on edge and serverless runtimes.

Deploy apps and databases on Railway. Covers service configuration, environment variables and secrets, Postgres/Redis plugins, private networking, cron jobs, health checks, and CI-driven deploys for zero-config full-stack hosting.

Run long-running background jobs with Trigger.dev. Covers durable tasks that survive timeouts, retries and idempotency, scheduled and event triggers, concurrency controls, waits and delays, and observability for reliable async workflows in TypeScript.

Ship SQLite at the edge with Turso and libSQL. Covers embedded replicas, multi-region reads, database-per-tenant patterns, schema migrations, and drivers for TypeScript, Rust, and serverless runtimes with sub-millisecond local reads.

Add serverless messaging and scheduling with Upstash QStash. Covers HTTP-based message queues, delayed and scheduled delivery, cron jobs, retries with backoff, dead-letter handling, and signature verification for reliable jobs on serverless and edge.