What's New

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.

End-to-end research paper generation and revision for ML/AI/CV/NLP papers from repositories, notes, experiments, and conference templates. Use when turning a research project into a publication-ready LaTeX draft, building a paper story, writing or revising Abstract/Introduction/R

Develop, audit, and deploy Solana programs with the Anchor framework. Covers account structures and constraints, security-by-default checks, CPI interactions, PDA design, and testing with Mollusk and LiteSVM — the full write-test-deploy loop.

Build on the Aptos blockchain with the Move language. Covers Move modules and resources, smart contracts, NFTs, and DeFi primitives, plus deploying and testing across devnet, testnet, and mainnet.

Generate production-ready Arduino and embedded C++ for UNO, ESP32, and RP2040. Sensors, actuators, I2C/SPI, non-blocking timers, state machines, EEPROM, SD logging, and WiFi — with proper memory management and board-specific optimization.

Build and debug ARKit features for Apple visionOS. Covers ARKitSession setup and authorization, data providers for world tracking, plane detection, scene reconstruction, and hand tracking, anchor processing, and RealityKit integration in immersive spaces.

Move fast with the Bun runtime for JavaScript and TypeScript. Covers the package manager, bundler, test runner, and native APIs, plus migrating an existing Node.js project to Bun for lower cold starts and faster installs.

Ship Deno apps to production on Deno Deploy's edge. Covers the deno deploy CLI, environment variables, Deno KV, custom domains, and the --tunnel flag for testing edge behavior locally before you go live.

Generate and troubleshoot ESPHome configurations for ESP32 and ESP8266 devices. Ready-to-use YAML templates, GPIO pin-assignment guidance, sensor and actuator setup, WiFi and OTA config, plus fixes for common compile and connection errors.

Extract, analyze, and reverse-engineer firmware for embedded and IoT security. Covers firmware unpacking, filesystem and binary analysis, and vulnerability research across routers, IoT devices, automotive systems, and industrial controllers.

Design connected-device architectures end to end — MQTT and device protocols, edge computing, device management, and cloud data pipelines. Build scalable, secure, reliable IoT systems on stacks like Mosquitto, AWS IoT, Azure IoT, and Node-RED.

Explore and query blockchain data through The Graph subgraphs. Inspect GraphQL schemas, build queries for NFT transfers, DEX swaps, and DeFi metrics, iterate on them interactively, and export finished queries for your app.

Build Ethereum interactions with viem — the modern, type-safe replacement for ethers.js. Covers public/wallet clients, transports, transactions, signing, ABI encoding/decoding, and smart-contract reads and writes with first-class TypeScript inference.

Test smart contracts thoroughly with Hardhat and Foundry. Covers unit and integration tests, mainnet forking, fixtures, and coverage — so you catch reentrancy, accounting, and access-control bugs before deploying to mainnet.

Build web-based AR and VR with the WebXR Device API. Access XR sessions and reference spaces directly from the browser, handle controllers and hand input, and render immersive scenes that run on headsets and phones without an app install.

Catch infrastructure-as-code misconfigurations before they ship with Checkov by Prisma Cloud. Scans Terraform, CloudFormation, Kubernetes, Helm, Dockerfile, and ARM for insecure defaults, writes custom policies, suppresses false positives, and gates CI on policy violations.

Sign and verify container images and artifacts with Cosign and Sigstore for supply chain integrity. Set up keyless signing with OIDC, attach SBOM and provenance attestations, verify signatures in admission controllers, and enforce signed-only deploys in CI/CD.

Detect threats at runtime in containers and Kubernetes with Falco, the CNCF runtime security engine. Monitors system calls to catch anomalous behavior — shells in containers, unexpected network connections, sensitive file access — and write custom detection rules with MITRE ATT&CK mapping.

Make web apps GDPR and privacy compliant. Audit PII, add consent management and cookie banners, build data subject access and deletion endpoints, define retention policies, and generate a privacy policy — turning privacy requirements into shippable engineering work.

Generate SBOMs and scan for known vulnerabilities with Anchore's Syft and Grype. Build accurate software bills of materials for container images and filesystems, scan them for CVEs, track dependency exposure over time, and enforce vulnerability policies in CI.

Manage secrets, encryption keys, and dynamic credentials with HashiCorp Vault. Configure secret engines, issue short-lived dynamic database and cloud credentials, write access policies, integrate with Kubernetes and CI, and use Transit for encryption-as-a-service.

Map networks and audit exposure with Nmap — the standard network discovery and security auditing tool. Discover live hosts, enumerate open ports and service versions, fingerprint operating systems, and script custom checks with the Nmap Scripting Engine for authorized assessments.

Run fast, template-based vulnerability scanning against web apps and infrastructure with Nuclei by ProjectDiscovery. Detect CVEs, misconfigurations, and exposures using thousands of community templates, write custom templates, and integrate severity-ranked results into CI.

Enforce policy-as-code across your stack with Open Policy Agent, the CNCF policy engine. Write Rego policies for Kubernetes admission control, API authorization, Terraform validation, and CI gates — with unit tests, coverage, and OPA/Gatekeeper or Conftest integration.

Find web application vulnerabilities with OWASP ZAP, the leading open-source DAST scanner. Configure baseline and active scans, write scan policies, catch OWASP Top 10 issues like XSS, SQL injection, and CSRF, and integrate automated security testing into CI/CD.

Handle payment card data safely under PCI DSS. Scope your cardholder data environment, pick the right SAQ, implement required controls like encryption, segmentation, and logging, minimize scope with tokenization, and prepare evidence for your acquirer or QSA.

Audit an application for security vulnerabilities across the OWASP Top 10. Reviews code for injection, XSS, broken access control, and insecure config, scans dependencies for CVEs, detects exposed secrets, and returns prioritized findings with severity ratings and concrete fixes.

Find and fix vulnerabilities in code, open-source dependencies, containers, and IaC with Snyk. Scans npm, PyPI, and more for CVEs, suggests upgrade paths and patches, checks Docker images and Terraform, and integrates security gates into pull requests and CI.

Prepare for SOC 2 Type II with mapped Trust Service Criteria, control implementation, and evidence collection. Turn security requirements into concrete engineering tasks, automate evidence gathering, close common audit gaps, and get enterprise-ready for B2B customers.

Test your own applications for SQL injection with sqlmap, the standard automated SQLi detection tool. Identify injectable parameters, confirm vulnerabilities, and demonstrate impact during authorized security testing — then get concrete remediation like parameterized queries and input validation.

Scan container images, filesystems, and git repos for CVEs, misconfigurations, exposed secrets, and license issues with Trivy. Covers Docker/OCI images, IaC (Terraform, Kubernetes, Dockerfile), SBOM generation, and gating builds in CI on severity thresholds.

Use when the user describes non-clinical work-energy problems such as fatigue, feeling drained, AI/tool fatigue, low focus, irritability, low motivation, study-rhythm collapse, or asks for a plan to improve their energy, focus, or recovery. Do not use for medical diagnosis, thera

Move data with Airbyte ELT. Configures sources and destinations, builds and tests custom connectors with the CDK, sets up incremental and CDC replication, schedules syncs, and wires failure alerting across 300+ APIs and databases.

Build an open lakehouse on Apache Iceberg. Designs Iceberg tables and partitions, manages schema and partition evolution, handles snapshots, time travel, and compaction, and queries from Spark, Trino, and DuckDB across S3 or GCS.

Process big data at scale with Apache Spark. Writes PySpark ETL jobs, builds DataFrame and Spark SQL transformations, tunes shuffles, partitions, joins, and caching, fixes data skew, and runs on Databricks, EMR, Dataproc, or Kubernetes.

Explore and visualize data with Apache Superset. Builds charts and dashboards, writes SQL Lab queries, defines datasets, metrics, and calculated columns, configures row-level security and caching, and automates assets through the Superset API.

Query and model data in BigQuery. Writes performant GoogleSQL, partitions and clusters tables to cut scan costs, builds scheduled queries and materialized views, and manages datasets, UDFs, and BI Engine for fast, cheap analytics.

Define metrics once and serve them everywhere with Cube. Models cubes, dimensions, measures, and joins, exposes a headless semantic layer over REST, GraphQL, and SQL, and tunes pre-aggregations, caching, and multi-tenant security.

Scale Python and pandas with Dask. Parallelizes DataFrame and array workloads across cores or a cluster, tunes partitions and the task graph, handles larger-than-memory data, and diagnoses spill and shuffle bottlenecks from the dashboard.

Build BI reports as code with Evidence. Writes SQL plus Markdown pages that render interactive charts and tables, parameterizes reports with query results, and ships polished, version-controlled data apps as static sites — no drag-and-drop BI.

Orchestrate data workflows with Kestra's declarative YAML. Writes flows with schedule, webhook, and flow triggers, script tasks, and parallel or conditional logic, adds retries, timeouts, and error handling, and migrates DAGs from Airflow or Prefect.

Build self-service analytics with Metabase. Creates questions and native SQL queries, designs dashboards with filters, sets up models and a semantic layer, configures signed embedding and permissions, and automates assets through the Metabase API.

Run Kafka-compatible streaming on Redpanda with rpk. Creates and configures topics, manages clusters, profiles, and connections, wires SASL and TLS and the schema registry, and operates tiered storage — a drop-in Kafka replacement with no ZooKeeper.

Capture rich behavioral data with Snowplow. Designs event and entity schemas, instruments web and mobile trackers, configures the collector and enrich pipeline and warehouse loaders, and models clean event data for product and marketing analytics.

Catch bad data before it hits dashboards with Soda. Writes SodaCL checks for freshness, completeness, uniqueness, validity, and custom business rules, profiles datasets, and wires quality gates into pipelines and CI to stop bad data early.

Analyze and optimize Trino queries. Reads EXPLAIN plans, predicts CPU, memory, and scan cost before running, rewrites expensive federated queries, and surfaces partition-pruning and join-order fixes for faster, cheaper distributed SQL.

"万能复刻 / universal website copy-remix workflow with evidence-based reference recon. Use when the user wants to copy, clone, recreate, remix, migrate, or rebuild any reference website's look, interaction feel, scroll rhythm, hero motion, layout structure, visual system, deployed st

Local-first connector routing and dry-run planning for agent workflows.

Auto-split mixed changes into logical commit batches with validated Conventional Commit messages. MUST BE USED for ANY git add, git commit, or git push operation.

"People and company intelligence via the Sixtyfour AI API. AI research agents that read the live web — not static databases — to return structured, confidence-scored profiles. Use when you need to: (1) enrich a lead with full profile data (name, title, email, phone, LinkedIn, tec

Validate pandas DataFrames with pandera schemas. Defines column checks, dtype and range constraints, class-based schema models, and decorator-based validation so bad data fails fast in your pipelines.

Work with Apache Parquet effectively. Chooses compression codecs, designs partition layouts, applies predicate and column pushdown, and handles schema evolution so analytical reads stay fast and cheap.

Validate records with Pydantic models. Builds field and model validators, nested models, and batch validation patterns to enforce types and business rules at the edges of your data pipelines and APIs.

Implement signal-based reactive state in Angular v20+. Uses signal(), computed(), linkedSignal(), and effect() for fine-grained reactivity and converts legacy BehaviorSubject/Observable patterns to signals.

Write performant, maintainable Angular apps. Covers standalone components, change-detection optimization, lazy routing, OnPush strategy, bundle-size reduction, and modern control-flow syntax.

Architect a design-token system — semantic color, typography, spacing, and radius scales as CSS variables with light/dark themes. Uses the Tailwind CSS 4 @theme directive for a single source of truth.

Build production-grade web animations with GSAP (GreenSock). Creates timeline sequences, scroll-triggered effects, SVG and text animation, and physics-based easing with performant, framework-agnostic code.

Build accessible, headless UI with Radix Primitives. Composes dialogs, menus, popovers, and comboboxes with correct focus management and ARIA, then styles them with your own tokens and compound-component patterns.

Choose and implement the right React state solution — Redux Toolkit, Zustand, Jotai, or TanStack Query. Separates server state from client state and structures stores that scale without prop drilling or over-rendering.

Add accessible, themeable UI to Svelte apps with shadcn-svelte. Installs and composes Button, Card, Dialog, Form, and Table components wired to design tokens and Tailwind.

Build high-performance UIs with SolidJS. Uses signals, memos, effects, stores, and resources for fine-grained reactivity with no virtual DOM — ideal for granular, low-overhead updates.

Set up and configure Storybook 9 for any framework with autodetection and best practices. Scaffolds stories, args/controls, interaction tests, a11y checks, and CI-ready component documentation.

Build fast, modern web apps with SvelteKit. Covers routing, load functions, form actions, server vs client data flow, SSR/CSR/prerender adapters, and Svelte 5 runes for reactive state.

Build type-safe forms with TanStack Form v1 — field-level validation with Zod, async validation, multi-step wizards, dynamic field arrays, and Server Actions with shadcn/ui integration.

Bootstrap and build full-stack React apps with TanStack Start — type-safe file routing, server functions, TanStack Query data loading, Tailwind 4, and shadcn/ui on Vite.

Write accessible, maintainable component tests with Testing Library (React and React Native). Enforces role/label queries, correct async handling, user-event flows, and pragmatic mocking over implementation-detail assertions.

Build Vue 3 apps with the Composition API and TypeScript. Covers reactive state with ref/reactive, composables, script setup, Pinia stores, component patterns, and typed props/emits.

Test Vue 3 apps with Playwright — component tests and end-to-end flows covering Vue Router navigation, reactive state, authentication, and network mocking with reliable, non-flaky patterns.

"Git Context Controller (GCC) v2 — Lean agent memory backed by real git. Stores hash + intent + optional decision notes instead of verbose markdown. Auto-bridges to aiyoucli vector memory when available. Dual mode: git-backed (lean index.yaml) or standalone (markdown fallback). T

"UI/UX design intelligence for web and mobile. Includes 50+ styles, 161 color palettes, 57 font pairings, 161 product types, 99 UX guidelines, and 25 chart types across 10 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui, and HTML/CSS). Act

Pull YouTube video transcripts from a URL, then provide a structured summary and analysis.

Automate Buildkite pipelines — trigger builds, inspect steps and jobs, and manage pipeline runs. Kicks off builds on branches, monitors step status, and retrieves job logs and annotations for hybrid self-hosted CI/CD.

Manage Cilium and Hubble network observability for Kubernetes. Writes eBPF-based network policies, observes live traffic flows with Hubble, and troubleshoots pod-to-pod connectivity and dropped packets.

Automate CircleCI — trigger pipelines, monitor workflows and jobs, and retrieve artifacts and test metadata. Kicks off runs, watches workflow status, pulls failing test output, and downloads build artifacts for debugging.

Manage Coolify deployments, apps, databases, and services via its API. Deploys, starts, stops, and restarts self-hosted applications, provisions databases, and manages servers on this open-source Heroku/Netlify alternative.

Automate Datadog observability — query metrics, search logs, and manage monitors, dashboards, events, and downtimes. Builds metric queries and alert monitors, mutes noisy alerts with scheduled downtimes, and wires dashboards for services and infrastructure.

Validate, lint, and test Fluent Bit log pipelines. Checks config syntax, enforces best practices, flags security issues, and runs dry-run tests on inputs, filters, parsers, and outputs before you ship a logging config to production.

Build and maintain GitLab CI/CD pipelines with testing, coverage reporting, caching, snapshot builds, and automated releases. Scaffolds .gitlab-ci.yml stages, wires artifacts and caches, and sets up tag-driven release automation.

Configure Istio traffic management — routing, load balancing, circuit breakers, and canary deployments. Writes VirtualServices and DestinationRules for progressive delivery, retries, and resilience across a service mesh.

Generate best-practice Jenkinsfiles for Declarative and Scripted pipelines. Scaffolds build/test/deploy stages, wires credentials, agents, and post conditions, and models parallel stages and shared libraries for robust CI/CD.

Deploy containerized apps to any server with Kamal — zero-downtime rollouts, no Kubernetes. Configures deploy.yml, wires accessories and secrets, and ships Rails or any web app to a VPS/cloud host as a self-hosted Heroku/Render alternative.

Generate ConfigMaps, Secrets, and overlays with Kustomize for Kubernetes. Builds base + overlay structures, uses generators for config and secrets, and patches manifests per environment without templating or Helm.

Implement Linkerd service mesh patterns for lightweight, zero-trust networking. Installs the mesh, meshes workloads, configures mTLS and traffic policies, and sets up retries and traffic splits with minimal overhead.

Automate New Relic observability — manage alert policies, notification channels, and alert conditions, and monitor application and browser performance. Wires up APM alerting, defines conditions on golden signals, and routes notifications to the right teams.

Generate best-practice Terragrunt configurations — root configs, child modules, stacks, and multi-environment setups. Keeps Terraform DRY with shared inputs, remote state, and dependency wiring across dev/staging/prod.

Manage Traefik reverse proxy for local and container development. Routes domains to services, configures CORS and TLS, checks service health, and debugs connectivity — with dynamic Docker-label and file-based routing.

Read/write KeePassXC .kdbx vaults to manage per-project/per-env credentials (init/get/set/list/delete/run/export/import/check/envs/mv/rekey). Replaces .env as the source of truth; injects secrets into commands without printing them. Use when a project needs to store, retrieve, or

Test and benchmark LLM agents with behavioral tests, capability assessments, reliability metrics, and production monitoring — catching the failures that pass benchmarks but break in the real world.

Add mechanical guardrails that stop AI agents from bypassing your rules. Enforces policies with git hooks, secret detection, deployment verification, and import registries — born from real production incidents.

Architect memory for AI agents — short-term context, long-term vector storage, and the retrieval strategies that decide what an agent actually remembers. Covers chunking, embedding, and recall over storage.

Build production agents with the Claude Agent SDK. Covers agent architecture, tool design, hooks, skills, MCP server integration, and the patterns for reliable, long-running agentic workflows.

Design computer vision pipelines for detection, segmentation, and visual reasoning. Covers object detection, segmentation, vision-language models, and real-time inference for production CV systems.

Choose and optimize embedding models for semantic search and RAG. Compares model trade-offs, designs chunking strategies, handles domain adaptation, and tunes embedding quality to improve retrieval accuracy.

Build RAG agents with Google ADK and Vertex AI RAG Engine. Sets up corpora, the VertexAiRagRetrieval tool, and citation-backed responses for document Q&A on Google Cloud.

Instrument LLM apps with Langfuse for tracing, prompt management, evaluation, and datasets. Captures nested traces across LangChain, LlamaIndex, and OpenAI calls to debug latency, cost, and quality in production.

Build data-centric RAG apps with LlamaIndex. Wires up document ingestion across 300+ connectors, vector and hybrid indices, query engines, and agents with multi-modal support for document Q&A and knowledge retrieval.

Fine-tune LLMs with LoRA, QLoRA, and PEFT. Prepares JSONL datasets, sets hyperparameters, runs adapter training and instruction tuning, and applies RLHF/DPO — then quantizes and deploys the resulting model.

Track ML experiments with reproducible parameters, metrics, and artifacts. Logs runs, compares hyperparameter sweeps, and versions models so training results stay reproducible and easy to compare.

Design multi-agent systems with orchestrator, peer-to-peer, and hierarchical patterns. Covers task decomposition, agent handoffs, shared state, and coordination so a team of agents stays reliable instead of looping.

Use Qdrant for vector search, semantic caching, and long-term agent memory. Builds collections with metadata filtering, hybrid search, and semantic caches that cut LLM calls and shrink context windows.

Build classical ML pipelines with scikit-learn. Covers classification, regression, clustering, preprocessing, feature selection, model selection, and cross-validation with a consistent fit/transform/predict API.

Serve LLMs at high throughput with vLLM. Configures PagedAttention, continuous batching, tensor parallelism, and OpenAI-compatible endpoints, plus GPTQ/AWQ/FP8 quantization for serving on limited GPU memory.

Complete App Store Optimization toolkit - generate metadata in any language, analyze competitors, optimize keywords, set up IAPs/subscriptions, and submit to App Store Connect via direct API

Vibe Coding OS — Claude/Codex/Cursor skill framework with 139 skills, 111 commands, 95 templates, 22 tracked sources, 28/28 validation gates PASS. Quality Shield, Engineering Discipline Pack, plugin marketplace.

Build production serverless apps on AWS. Covers Lambda functions, API Gateway, DynamoDB, SQS/SNS event-driven patterns, SAM and CDK deployment, and cold-start optimization for cost-efficient scale-to-zero backends.

Build Django web apps and REST APIs with Django REST Framework. Generates models with proper indexes, optimizes ORM queries with select_related/prefetch_related, builds DRF serializers and viewsets, and wires up JWT authentication.

Build .NET 8 backends with minimal APIs and clean architecture. Implements Entity Framework Core, CQRS with MediatR, JWT authentication, and AOT compilation for cloud-native microservices.

Write idiomatic Elixir with OTP patterns, supervision trees, and Phoenix LiveView. Builds fault-tolerant, highly concurrent backends and real-time features on the BEAM with GenServers and channels.

Build Express.js APIs the right way. Structures routes and middleware, centralizes error handling, validates requests, and configures CORS so your Node backend stays maintainable as it grows.

Build high-performance Node.js APIs with Fastify. Uses JSON Schema validation and serialization, plugins and decorators, hooks, and typed routes to get maximum throughput with minimal overhead.

Develop lightweight Flask APIs with routing, blueprints, database integration, authentication, and clean request/response handling. Ideal for microservices and small web services where Django would be overkill.

Design GraphQL schemas, implement Apollo Federation, and build real-time subscriptions. Covers resolvers with DataLoader batching, query optimization, federation directives, and schema-first API architecture.

Design distributed systems and decompose monoliths into bounded-context services. Recommends communication patterns, produces service-boundary diagrams, and applies saga, event-sourcing, and CQRS resilience strategies.

Build Rails 7+ apps with Hotwire. Optimizes Active Record queries with includes/eager_load, implements Turbo Frames and Streams for partial page updates, configures Action Cable WebSockets, sets up Sidekiq background jobs, and writes RSpec suites.

Design clean REST APIs and OpenAPI specs. Covers resource modeling, versioning strategies, pagination patterns, consistent error handling, and contract-first API architecture before you write a line of server code.

Generate Spring Boot 3.x services. Creates REST controllers, implements Spring Security 6 auth flows, sets up Spring Data JPA repositories, and configures reactive WebFlux endpoints for high-throughput Java microservices.

Build full-stack dApps on Arbitrum with Stylus (Rust) and/or Solidity. Covers local devnode setup, contract development and testing, deployment to Arbitrum, and React frontend integration with viem. An opinionated, end-to-end guide for shipping on L2.

Compile C and C++ to WebAssembly for the modern web with Emscripten. Port existing native libraries, expose clean JS bindings, manage the heap, and ship high-performance C++ components that run in the browser. Sourced from Google Chrome's modern web guidance.

Write firmware for microcontrollers and RTOS applications. Configure peripherals, write interrupt handlers, implement DMA transfers, debug timing issues, and optimize power consumption for STM32, ESP32, FreeRTOS, and bare-metal targets.

Develop and test Solidity smart contracts with the Foundry toolkit. Write Forge tests, deploy with scripts, and debug using Cast and Anvil. Triggers on forge/cast/anvil commands and files like foundry.toml, *.t.sol, and *.s.sol.

Scaffold and build cross-platform desktop apps with Tauri v2. Sets up an opinionated core plus opt-in modules — CLI+MCP, SQLite, tray and auto-updater, release/preflight, and a Swift sidecar — on top of the official create-tauri-app boilerplate.

Build production-quality vanilla Three.js scenes (no R3F) — voxel worlds, procedural geometry, instancing/BatchedMesh, particle systems, and GLSL shader effects (bloom, god rays, depth of field, glitch). Includes EffectComposer post-processing and draw-call optimization.

Build interactive 3D web experiences with Three.js. Set up scenes, cameras, meshes, materials, lights, and animations; handle textures and loaders; and optimize WebGL/WebGPU rendering for product configurators, data viz, and immersive sites.

Build game systems in Unity and Unreal Engine. Implement ECS architecture, configure physics and colliders, set up multiplayer with lag compensation, write shaders, optimize to 60+ FPS, and apply patterns like object pooling and state machines.

Design, optimize, and deploy modern browser-based games and game-like web apps. Step-by-step guidance on game loops, input, rendering choices, asset pipelines, and shipping playable builds to the web.

Ship near-native performance to the browser, serverless, and the edge with WebAssembly. Covers Rust, Go, and C++ toolchains (wasm-pack, TinyGo, Emscripten), JS interop, memory layout, and when WASM actually beats plain JavaScript.

Use when setting up a multi-agent team workflow in Claude Code — scaffolds 7 agents (PM, architect, frontend, backend, QA, reviewer, librarian), an 8-stage serial flow with human approval gates and change-size tiers (S/M/L), a document system (PRD/SPEC/TEST-PLAN/ADR/RUNBOOK/BACKL

Generate and monitor CyberBara Public API v1 image, video, audio, and music tasks end-to-end. Use when work involves CyberBara `/api/v1` endpoints for listing models, uploading reference media, quoting credits, creating generation tasks, polling task status, checking credits bala

Audit GitHub Actions workflows for prompt-injection and security flaws in AI agent integrations (Claude Code Action, Gemini CLI, OpenAI Codex, GitHub AI Inference). Detects attacker-controlled input reaching agents in CI/CD.

Search and explore Burp Suite project files (.burp) from the command line. Regex-search response headers and bodies, dump proxy history and site map, and extract findings from captured HTTP traffic.

Scan a codebase for security vulnerabilities using CodeQL's interprocedural data flow and taint tracking. Build databases, run security-and-quality and experimental suites, and process SARIF output to surface high-precision findings.

Detect timing side-channel vulnerabilities in cryptographic code across C, C++, Go, Rust, Swift, Java, JS/TS, Python, and more. Flags secret-dependent branches, division on secrets, and non-constant-time comparisons.

Map the attack surface of smart contracts by finding every state-changing entry point. Categorizes externally callable functions by access level (public, admin, role-restricted) and generates structured audit reports across Solidity, Vyper, Solana/Rust, Move, TON, and CosmWasm.

Scan Android APKs for Firebase misconfigurations — open databases, public storage buckets, weak authentication, and exposed cloud functions. For authorized mobile app security audits and research.

Detect fail-open insecure defaults — hardcoded secrets, weak auth, and overly permissive security settings — that let an app run insecurely in production. Audits config management and environment variable handling.

Parse, filter, deduplicate, and convert SARIF output from CodeQL, Semgrep, and other scanners. Aggregate findings across tools and wire results into CI/CD without re-running the scans themselves.

Generate minimal, allowlist-based macOS Seatbelt sandbox profiles to isolate and restrict applications. Locks a process down to only the files, network, and syscalls it actually needs.

Scan Solana programs for 6 critical vulnerability classes including arbitrary CPI, improper PDA validation, missing signer and ownership checks, and sysvar spoofing. Tuned for Solana and Anchor programs.

Analyze ERC20/ERC721 token implementations and integrations against Trail of Bits' token integration checklist. Checks conformity, 20+ weird-token patterns, owner privileges, and how protocols handle non-standard tokens.

After finding one bug, hunt for its variants across the codebase using pattern-based analysis. Helps build CodeQL and Semgrep queries to systematically find every instance of a vulnerability class.

Author high-quality YARA-X detection rules for malware identification and threat hunting. Covers naming conventions, string selection, performance optimization, migration from legacy YARA, and false-positive reduction.

Detect sensitive data left in memory and zeroization stripped by compiler optimizations. Uses assembly-level and control-flow analysis to verify keys, passwords, and secrets are actually wiped in C, C++, and Rust.

Use when an autonomous agent or builder needs to deploy through Agent OS, export a Micro ECF harness packet, execute routed work, resolve agent:// aliases, discover capabilities, or list paid services on Agoragentic with USDC settlement on Base L2.

Build, debug, and operate Apache Airflow pipelines. Writes DAGs and TaskGroups, triggers and monitors runs via the CLI, reads task logs, diagnoses import and parse errors, and manages connections, variables, and pools.

Design and query ClickHouse for real-time analytics. Models MergeTree tables, writes fast aggregations and materialized views, tunes partitions and indexes, and connects from Node and Python clients.

Build asset-based data pipelines with Dagster and the dg CLI. Creates projects, defines software-defined assets, schedules, sensors, and components, then debugs materializations and project structure.

Build, test, and ship analytics-engineering projects with dbt. Scaffolds projects, generates models and sources, writes data tests and documentation, manages packages, and deploys to dbt Cloud or Core.

Run fast in-process analytics with DuckDB. Queries CSV, Parquet, and JSON directly, converts between formats, joins local files, and writes performant SQL for ad-hoc analysis without a server.

Build stateful stream-processing jobs with Apache Flink. Writes DataStream and SQL jobs, manages windows, watermarks, and state, configures checkpointing, and tunes throughput for real-time pipelines.

Add automated data-quality gates with Great Expectations. Profiles datasets, generates expectation suites, runs validations and checkpoints, and wires quality gates into pipelines to catch bad data early.

Build event-streaming systems with Apache Kafka. Writes producers and consumers, designs topics and partitioning, handles consumer groups and offsets, and implements idempotent, exactly-once processing.

Write expert pandas for cleaning, reshaping, and analysis. Handles merges, group-bys, pivots, time series, and vectorization, fixes slow or memory-heavy code, and produces tidy, reproducible DataFrames.

Wrangle data at speed with Polars. Loads, filters, joins, groups, and reshapes large datasets using expressions and lazy frames, and migrates pandas code to faster Polars equivalents.

Orchestrate Python data workflows with Prefect. Writes flows and tasks, configures retries and caching, creates deployments, and monitors runs through the Prefect UI and CLI.

Cut Snowflake spend by analyzing warehouse and query costs. Surfaces the most expensive queries, detects anti-patterns like full scans and oversized warehouses, and recommends concrete optimizations.

Build transformation pipelines with SQLMesh. Writes MODEL blocks and Python models, chooses incremental kinds, runs plan/apply/audit, manages virtual environments and snapshots, and migrates dbt projects.

Use when turning a hand-drawn, sketched, or scanned logo into clean reproducible code — fitting smooth cubic Bézier curves to the real outline to produce an editable SVG, color/layout variants, and PNG/ICO/favicon exports. For brand logos, monkey/mascot marks, wordmarks, avatars,

Generate production-ready Ansible playbooks and roles for server configuration and deployment automation. Produces idempotent tasks, proper handlers and variables, role structure, and inventory patterns following Ansible best practices.

Drive ArgoCD via CLI and REST API for GitOps automation. Manages Applications and ApplicationSets, syncs and rolls back deployments, configures Projects and RBAC, registers repos and clusters, mints tokens, and troubleshoots sync and health failures.

Cut AWS spend with FinOps workflows. Finds unused resources, analyzes the bill, rightsizes EC2/RDS, evaluates Spot and Graviton, detects cost anomalies, compares Reserved Instances vs Savings Plans, and sets up tagging and budgets for cost allocation.

Design, optimize, and secure CI/CD pipelines across GitHub Actions and GitLab CI. Builds workflows, debugs flaky tests and failures, adds SAST/DAST/SCA scanning, speeds up builds with caching and matrix sharding, and hardens pipelines with OIDC and secret management.

Bootstrap and operate Flux CD on Kubernetes. Creates and manages GitOps sources (Git, Helm, OCI, Bucket), configures Kustomizations and HelmReleases, reconciles resources on demand, sets up image automation and alerting, and pushes OCI artifacts.

Design GitOps deployment workflows with ArgoCD and Flux. Structures Git repos (app-of-apps, monorepo vs polyrepo), deploys to multiple clusters with ApplicationSets, manages secrets with SOPS/Sealed Secrets/External Secrets, implements canary and blue-green rollouts, and compares ArgoCD vs Flux.

Stand up and operate Grafana Loki for horizontally scalable log aggregation. Configures object-storage backends (S3, GCS, Azure Blob), writes LogQL queries, tunes retention and compaction, deploys via Helm, and troubleshoots Loki on Kubernetes.

Deploy and operate Grafana Tempo, a high-scale distributed tracing backend for OpenTelemetry. Configures object-storage backends, writes TraceQL queries, deploys via Helm, explains trace and span structure, and troubleshoots Tempo on Kubernetes.

Generate and validate Helm charts for Kubernetes applications. Scaffolds chart structure, templates Deployments/Services/Ingress with sane values, parameterizes via values.yaml, adds helpers and hooks, and checks charts against best practices.

Systematic Kubernetes incident response and debugging. Diagnoses CrashLoopBackOff, ImagePullBackOff, OOMKilled, and Pending pods, fixes NotReady nodes and DiskPressure, debugs service networking and PVC failures, investigates Helm releases, and runs post-incident reviews.

Design end-to-end observability: metrics, logs, and traces. Applies the Four Golden Signals and RED/USE methods, stands up Prometheus/Grafana/Loki, instruments with OpenTelemetry, calculates SLOs and error budgets, and optimizes Datadog cost or migrates to an open-source stack.

Query and operate Prometheus via its HTTP API. Writes PromQL for instant and range queries, inspects targets, alerts, and rules, accesses series and label metadata, and runs TSDB admin operations to troubleshoot monitoring infrastructure.

Scaffold and write Pulumi infrastructure-as-code in TypeScript. Configures cloud resources for AWS/Azure/GCP, manages Pulumi ESC environments for centralized secrets, sets up OIDC authentication, builds reusable component resources, and works with stack references.

"Generate polished HTML slide decks, Feishu (Lark) whiteboard SVGs, and editable PowerPoint (.pptx) source files from a single content description, with coordinated aesthetics and built-in anti-AI-slop design rules. Use when the user wants to create slides / a presentation / deck

Extract, define, and apply a design's DNA across three dimensions: design system (tokens), design style (qualitative feel), and visual effects (Canvas, WebGL, 3D, particles, shaders, scroll). Turn reference images or URLs into a structured JSON profile, or generate a design from one.

Generate complete typography systems from Google Fonts. Suggests single fonts or pairs across 1,900+ families tagged by personality and contrast, then outputs a full type scale as CSS custom properties, Tailwind config, and embed links.

Build cross-platform mobile apps with Ionic Framework and Capacitor. Covers ion-* components, @ionic/react, angular, and vue, Capacitor plugins (Camera, Geolocation, Push, Filesystem), dark mode, lifecycle hooks, and iOS/Android deployment patterns Claude doesn't know from training.

Autonomous research agent powered by Google NotebookLM. Ingests sources (URL, PDF, DOCX, YouTube, Drive), runs deep web research, asks cited questions, and generates artifacts — audio podcasts, video, slide decks, reports, quizzes, flashcards, mind maps, and study guides.

Set up a self-optimizing, multi-vendor AI agent team in a folder of Markdown. Each agent is a citizen with a signed capability card; tasks are contracts routed to the best performer by a learning bandit; settled contracts produce lessons that compound into team memory.

A toggleable anti-hallucination mode that enforces citation requirements, source grounding, and explicit 'I don't know' behavior based on Anthropic's guardrail guidance. Turn it on for factual work and off for creative work.

Run a single Markdown file as a portable app, tool, or shell session through the String MCP runtime. Use /open, /act, /install, and /set to read files and URLs, run actions, install apps, and manage credentials from any agent.

Run structured threat-hunting workflows in agentic IDEs like Claude Code. Shapes hypotheses, maps the environment, plans and runs hunts, audits evidence, and publishes findings — with phase-based orchestration, forensics, and milestone tracking.

LLM-agnostic SEO and GEO agent. Audits technical health, scores E-E-A-T content, generates Schema.org JSON-LD, checks Core Web Vitals, crawlability, robots.txt, sitemaps, and hreflang — and optimizes for AI search citation in AI Overviews, ChatGPT, and Perplexity.

"CTI Expert — cyber threat intelligence and OSINT analysis toolkit. Activates on: OSINT, CTI, threat intelligence, digital footprint, social media investigation, username enumeration, email tracing, domain recon, OPSEC, metadata analysis, people search, geolocation, breach checki