What's New

Multi-agent debate, red-team, evidence checking and judge skills for Claude Code, OpenAI Codex, Hermes Agent, OpenClaw and AI coding agents

Imposes a Trappist-style vow of silence on Claude. Claude continues to fulfill every request, but produces zero conversational prose — work flows through tool calls, file edits, code blocks, and bracketed stage-direction glyphs. Long answers are written to scrolls under `cloister

Use when user needs academic diagrams, methodology figures, statistical plots, or presentation slides from text descriptions or data files. Also use for evaluating generated figures against references.

Pure instruction-pack skill wrapping Ai2's Asta MCP server (Semantic Scholar). Intent-to-tool routing, safe defaults, multi-agent.

Three-phase collaboration workflow between Claude Code (planner/decision-maker) and Codex CLI (implementer/reviewer) via the codex-plugin-cc plugin. Use whenever a coding task involves multiple files, new modules, cross-cutting refactors, business logic changes, or anything that

Interactive project scaffolding wizard — detects environment, audits existing tools, then sets up any stack with explicit user approval at every step

Search GitHub for Claude Code skills, plugins, and agents. Use when the user asks to find, discover, or list community Claude Code skills, or asks "what skills exist for X" (e.g. SEO, testing, deployment, content).

Use when profiling wallets, analyzing protocols or pools, inspecting token metrics, evaluating DEX liquidity or LP/vault performance, reading smart contract state, resolving proxy contracts and unknown interfaces, tracing exploit fund flows, or investigating on-chain incidents on

Use when organizing media files (movies, TV, anime) on NAS or local storage - cleaning junk files, merging scattered episodes, normalizing folder names to "Title (Year)" format, and verifying episode completeness against TMDB

Audit web applications for WCAG 2.2 AA/AAA compliance. Checks color contrast, keyboard navigation, ARIA attributes, screen reader compatibility, focus management, and generates remediation code fixes.

Design and run load tests for APIs using k6 or Artillery. Creates test scenarios with realistic traffic patterns, ramp-up strategies, and performance thresholds to find breaking points before your users do.

Build blazing-fast static and hybrid sites with Astro. Generates components, content collections, API routes, view transitions, and island architecture patterns with any UI framework integration.

Define AWS cloud infrastructure using TypeScript or Python with AWS CDK. Generates type-safe construct libraries, stack definitions, and CloudFormation templates with best-practice patterns.

Set up Biome as a unified linter and formatter — 56x faster than ESLint + Prettier. Configures rules, migrates from existing setups, integrates with CI/CD, and handles project-wide code quality enforcement.

Build reliable background job processing with BullMQ. Generates job producers, consumers, schedulers, flow pipelines, and dashboard configurations for Redis-backed job queues in Node.js.

Analyze and reduce JavaScript bundle sizes. Identifies heavy dependencies, suggests tree-shaking opportunities, recommends lighter alternatives, and implements code splitting strategies for webpack, Vite, and esbuild.

Auto-generate changelogs from git history, PRs, and conventional commits. Creates formatted CHANGELOG.md files with categorized entries (features, fixes, breaking changes) and links to PRs and issues.

Build multi-agent AI systems with CrewAI. Designs agent roles, task delegation, tool integration, and orchestration flows where specialized AI agents collaborate to complete complex workflows.

Analyze and optimize conversion funnels. Designs A/B test hypotheses, analyzes heatmap data, identifies drop-off points, generates landing page copy variants, and creates data-driven CRO reports.

Write component and end-to-end tests with Cypress. Generates test suites with custom commands, fixture data, intercept stubs, component mounting, and visual regression testing for React, Vue, and Angular.

Build data pipelines and ETL workflows. Generates extraction scripts, transformation logic, loading procedures, and scheduling for moving data between APIs, databases, warehouses, and file systems.

Plan and generate safe database migrations for PostgreSQL, MySQL, and SQLite. Creates migration files with rollback support, handles schema diffs, and flags risky operations like column renames on large tables.

Configure reproducible development environments with Dev Containers. Generates devcontainer.json configs, Dockerfile setups, VS Code extensions lists, and post-create scripts for instant onboarding.

Create and optimize Docker Compose configurations for local development and staging environments. Generates multi-service setups with proper networking, volumes, health checks, and environment management.

Build type-safe database queries with Drizzle ORM. Generates schema definitions, relational queries, migrations, and SQL-like query builders for PostgreSQL, MySQL, and SQLite with zero overhead.

Design and code responsive HTML email templates that work across all email clients. Generates table-based layouts with inline styles, dark mode support, and compatibility with Gmail, Outlook, and Apple Mail.

Build high-performance Python APIs with FastAPI. Generates Pydantic models, async route handlers, dependency injection, background tasks, and auto-generated OpenAPI docs with proper error handling.

Automate video processing with FFmpeg commands. Generates complex filter chains for transcoding, trimming, concatenating, adding subtitles, extracting audio, creating thumbnails, and batch-processing video files.

Convert Figma designs to production code. Extracts design tokens, generates React/HTML components from frames, maps auto-layout to Flexbox/Grid, and syncs Figma variables to CSS custom properties.

Build beautiful cross-platform apps with Flutter and Dart. Generates widgets, state management patterns (Riverpod, Bloc), platform channels, animations, and production-ready app architecture.

Create fluid animations and transitions in React with Framer Motion. Generates layout animations, gesture interactions, scroll-triggered effects, page transitions, and complex orchestrated sequences.

Master complex git operations — interactive rebasing, cherry-picking, bisecting, reflog recovery, subtree merging, and conflict resolution strategies for large teams and monorepos.

Create and optimize GitHub Actions workflows for CI/CD pipelines. Generates workflow YAML with proper caching, matrix builds, environment secrets, and reusable workflows following GitHub's latest best practices.

Build fast Go web APIs with Fiber — the Express-inspired framework on Fasthttp. Generates handlers, middleware, validation, Swagger docs, and structured project layouts for Go microservices.

Build 2D and 3D games with Godot Engine using GDScript or C#. Generates scenes, scripts, physics setups, UI systems, and shader code for cross-platform game development.

Design and generate Grafana dashboards with PromQL and LogQL queries. Creates panels for system metrics, application KPIs, SLO tracking, and alerting rules with proper thresholds and visualization types.

Generate fully typed client code, resolvers, and SDK from your GraphQL schema. Creates TypeScript types, React hooks, resolver signatures, and API clients with zero runtime overhead.

Build ultrafast web APIs with Hono — the multi-runtime framework for Bun, Deno, Cloudflare Workers, and Node.js. Generates routes, middleware, RPC clients, and type-safe handlers with 2-4x more throughput than Express.

Internationalize web applications with i18next. Generates translation files, React hooks for language switching, plural/gender rules, date/number formatting, and automated translation workflows.

Optimize images for the web — generates responsive srcsets, converts to modern formats (AVIF, WebP), compresses without visible quality loss, and creates lazy-loading implementations for faster page loads.

Build reliable background jobs and scheduled workflows with Inngest. Generates event-driven functions with automatic retries, cron triggers, step functions, and durable execution that survives crashes.

Generate and debug Kubernetes YAML manifests — Deployments, Services, Ingress, ConfigMaps, RBAC, and Helm charts. Follows production-ready patterns with proper resource limits, health checks, and security contexts.

Build Retrieval-Augmented Generation (RAG) systems using LangChain. Creates document loaders, vector store configurations, retrieval chains, and conversational agents with proper chunking and embedding strategies.

Build web applications with Laravel. Generates Eloquent models, migrations, controllers, middleware, Blade templates, Livewire components, and queue jobs following Laravel best practices.

Run Lighthouse audits and get actionable fixes for Core Web Vitals — LCP, INP, and CLS. Analyzes performance scores, identifies bottlenecks, and generates specific code changes to improve page speed.

Build Model Context Protocol (MCP) servers that give AI agents access to your tools and data. Generates server scaffolding, tool definitions, resource handlers, and transport configurations for Claude, Cursor, and other MCP clients.

Add instant search to your application with Meilisearch. Generates index configurations, search UI components, faceted filtering, typo-tolerant queries, and relevancy tuning for sub-50ms search results.

Build enterprise-grade Node.js backends with NestJS. Generates modules, controllers, services, guards, interceptors, and microservice patterns with full dependency injection and TypeScript decorators.

Build Next.js applications using App Router best practices. Generates server components, server actions, route handlers, middleware, and data fetching patterns with proper caching and revalidation strategies.

Automate Notion workspaces via the API. Creates databases, pages, templates, and integrations that sync project data, generate meeting notes, build dashboards, and manage team workflows programmatically.

Implement authentication and authorization — OAuth 2.0/OIDC flows, JWT handling, session management, RBAC, and integration with providers like Auth0, Clerk, and NextAuth. Generates secure auth code with proper token handling.

Generate, validate, and maintain OpenAPI 3.x specifications for your REST APIs. Creates schemas from existing code, generates client SDKs, and produces interactive API documentation.

Instrument your applications with OpenTelemetry for distributed tracing, metrics, and logging. Generates SDK setup, custom spans, metric collectors, and exporter configurations for Jaeger, Grafana, and Datadog.

Build type-safe, zero-runtime CSS with Panda CSS. Creates design tokens, recipes, slot recipes, and responsive patterns with compile-time CSS extraction — no runtime overhead from the Chakra UI team.

Build content-driven applications with Payload CMS. Generates collection configs, custom fields, access control policies, hooks, and API endpoints with full TypeScript type safety and self-hosted deployment.

Build HTML5 browser games with Phaser.js. Generates game scenes, sprite animations, physics bodies, tilemap levels, particle effects, and audio management for Canvas and WebGL games.

Write and maintain end-to-end tests with Playwright. Generates test suites with proper page objects, fixtures, visual regression checks, and CI integration for cross-browser testing.

Instrument applications with PostHog for product analytics, session replay, feature flags, and A/B experiments. Generates event tracking code, funnel definitions, cohort queries, and experiment configurations.

"PRE Engineering — Set up a Plan-Review-Execute multi-agent collaborative framework for any project. Three AI agent roles (Planner, Executor, Reviewer) work together through a shared collaboration log to continuously deliver project goals. TRIGGER when: user wants multiple AI age

Write Prisma schemas, queries, and migrations with best practices. Generates type-safe database access code, optimizes relation queries, and handles schema design for PostgreSQL, MySQL, and SQLite.

Design, test, and optimize prompts for LLMs. Implements structured prompting techniques — chain of thought, few-shot learning, system prompts, and evaluation frameworks to improve AI output quality and reliability.

Build data science workflows with Python — pandas DataFrames, scikit-learn models, matplotlib/plotly visualizations, and Jupyter notebooks. Generates clean, production-ready data pipelines with proper preprocessing.

Analyze and optimize slow SQL queries. Reads EXPLAIN plans, suggests index strategies, rewrites subqueries as JOINs, and identifies N+1 patterns. Supports PostgreSQL, MySQL, and SQLite.

Build transactional and marketing emails with React components. Generates responsive email templates that render correctly in Gmail, Outlook, and Apple Mail using the React Email library from Resend.

Build cross-platform mobile apps with React Native using the New Architecture (Fabric, JSI, TurboModules). Generates components, navigation flows, native modules, and performance-optimized patterns.

Generate comprehensive README files by analyzing your codebase. Creates sections for installation, usage, API reference, configuration, contributing guidelines, and badges from your actual code and package config.

Implement Redis caching and data structures for high-performance applications. Designs cache-aside, write-through, and TTL strategies plus pub/sub messaging, rate limiting, and session management.

Build, test, and explain regular expressions. Generates regex patterns from natural language descriptions, explains complex existing patterns step by step, and handles edge cases across JavaScript, Python, and Go flavors.

Build high-performance web APIs in Rust with Axum. Generates route handlers, middleware, extractors, error handling, database integration with SQLx, and async patterns on the Tokio runtime.

Implement file upload and storage with S3-compatible services. Generates presigned URL flows, multipart uploads, image processing pipelines, and CDN configurations for AWS S3, Cloudflare R2, and MinIO.

Run lightweight static analysis on your code using Semgrep. Supports 30+ languages with customizable rules for security vulnerabilities, bug patterns, and code style enforcement.

Build headless Shopify storefronts with Hydrogen. Generates product pages, cart logic, checkout flows, collection filters, and Storefront API queries with server-side rendering on Oxygen or Vercel.

Build real-time applications with Socket.io. Generates WebSocket servers with rooms, namespaces, acknowledgments, binary streaming, and auto-reconnection for chat, collaboration, and live dashboards.

Integrate Stripe payment processing — checkout sessions, subscriptions, webhooks, customer portal, and billing logic. Generates type-safe server code with proper error handling and idempotency.

Find gaps in your test suite using mutation testing with Stryker. Introduces deliberate code mutations and reports which ones your tests fail to catch, revealing undertested code paths.

Build backend features with Supabase — authentication, database queries, row-level security policies, edge functions, real-time subscriptions, and storage. Generates type-safe client code with proper RLS.

Generate production-ready UI components using Tailwind CSS. Creates responsive layouts, interactive elements, dark mode variants, and accessible components following Tailwind best practices and design patterns.

Manage server state in React with TanStack Query. Implements query caching, background refetching, optimistic updates, infinite scroll, pagination, and stale-while-revalidate patterns with full TypeScript support.

Multi-source drug-target due-diligence: ranked gene list → per-gene dossier across UniProt, OpenTargets, PubMed + cross-lineage DE scan + composite re-ranking. Claude Code / OpenClaw / SkillsMP skill.

Write, plan, and manage cloud infrastructure using Terraform HCL. Generates provider configs, resource definitions, modules, and state management strategies for AWS, GCP, Azure, and 3000+ providers.

Scan your codebase for leaked credentials, API keys, and secrets using TruffleHog. Detects 800+ credential types with live verification against real APIs to confirm which leaks are active.

Set up and manage monorepos with Turborepo. Configures task pipelines, remote caching, workspace dependencies, shared packages, and CI/CD optimization that reduces build times by 70-90%.

Master advanced TypeScript — generics, conditional types, template literals, branded types, discriminated unions, and type-level programming. Generates type-safe utilities and fixes complex type errors.

Generate professional PDFs with Typst — the modern LaTeX alternative. Creates reports, invoices, resumes, academic papers, and presentations with clean markup that compiles instantly.

Build AI-powered applications with the Vercel AI SDK. Generates streaming chat UIs, tool-calling agents, structured output extraction, and multi-provider LLM integrations with React Server Components.

Write fast unit tests with Vitest — the Vite-native test runner. Generates test suites with mocking, spying, snapshot testing, code coverage, and in-source testing with native ESM and TypeScript support.

Transcribe audio and video files to text using OpenAI Whisper. Generates accurate transcripts with timestamps, speaker diarization, and subtitle files (SRT/VTT) in 99+ languages.

Build headless WordPress sites with the REST API or WPGraphQL. Generates custom post types, ACF field groups, GraphQL queries, and Next.js/Astro frontend integrations for decoupled WordPress architectures.

Design type-safe validation schemas with Zod. Generates runtime validators for API inputs, form data, environment variables, and config files with automatic TypeScript type inference and custom error messages.

Manage React application state with Zustand. Creates typed stores, implements middleware (persist, devtools, immer), handles async actions, and designs store architecture for complex applications.

Senior UI/UX Engineer. Architect digital interfaces overriding default LLM biases. Enforces metric-based rules, strict component architecture, CSS hardware acceleration, and balanced design engineering.

This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.

Create and edit Word documents: reports, memos, letters with tables of contents and formatting.

Create and edit presentations: slide decks, pitch decks, templates, speaker notes.

Create, modify, and test custom skills. Run evals, benchmark performance, optimize triggers.

Work with Excel/CSV files: add columns, formulas, charts, clean messy data, convert formats.

Structured design feedback on usability, hierarchy, and consistency for any stage of design.

Generate standup updates from git commits and recent work. Formats yesterday/today/blockers in seconds.

Weighted sales forecast with best/likely/worst scenarios, commit vs upside, gap analysis.

Analyze pipeline health, prioritize deals, flag risks, and get a weekly action plan.

Detailed content brief for articles: keyword angle, outline, audience, competitive positioning.

Analyze and improve internal link structure: orphan pages, link equity, site architecture.

Technical SEO audit: Core Web Vitals, crawlability, sitemap, robots.txt, render blocking.

Create data visualizations using D3.js — charts, graphs, maps, and interactive visual data explorations with production-quality output.

Create animation-rich HTML presentations with smooth transitions, code highlighting, and interactive elements. Export-ready slide decks with modern web technologies.

Lightweight meta-prompting and spec-driven development system. Forces structured thinking before coding — write specs first, then implement with clear requirements.

Build and navigate iOS apps through Xcode simulator automation. Streamlines iOS development with automated building, testing, and UI interaction workflows.

Multi-agent autonomous startup system orchestrating 37 AI agents. Automates end-to-end startup operations from ideation through launch with specialized agent roles.

General-purpose browser automation using Playwright. Automate web interactions, testing, scraping, and browser-based workflows with full control over navigation and DOM.

Give Claude Code full context on shadcn/ui components — proper usage patterns, theming, composition, and accessibility. Build UIs with the shadcn component library correctly.

Convert documentation websites into Claude Skills automatically. Scrapes docs, structures content, and generates proper SKILL.md files from any documentation site.

Core skills library with 20+ battle-tested skills for Claude Code. Includes memory management, task planning, code review, git workflows, and development automation.

Security analysis skills from Trail of Bits — static analysis with CodeQL and Semgrep, vulnerability detection, code auditing, and security review workflows.

Build server-side API routes in Expo Router. Create REST endpoints, handle authentication, connect to databases, and deploy serverless functions alongside your mobile app.

Deploy Expo/React Native apps with EAS Build and Submit. Configure build profiles, app signing, over-the-air updates, and app store submission workflows.

Review code with Sentry's engineering standards. Focuses on error handling, observability, logging, and production-readiness patterns.

Debug and fix production issues using Sentry data. Analyze error traces, performance bottlenecks, and user impact to prioritize and resolve issues quickly.

Integrate Sentry monitoring into Next.js applications. Setup, configuration, error boundaries, performance monitoring, and source maps for full-stack observability.

Build AI agents on Cloudflare Workers using the Agents SDK. Stateful agents, durable workflows, WebSocket apps, scheduled tasks, MCP servers, chat and voice agents.

Create and review Cloudflare Durable Objects for stateful coordination — chat rooms, multiplayer games, booking systems with RPC, SQLite, alarms, and WebSockets.

Analyze web performance using Chrome DevTools. Measures Core Web Vitals (LCP, INP, CLS), identifies render-blocking resources, layout shifts, caching issues, and accessibility gaps.

Review and author Cloudflare Workers code against production best practices. Checks streaming, floating promises, global state, secrets, bindings, and observability.

Comprehensive Cloudflare platform skill covering Workers, Pages, KV, D1, R2, Workers AI, Vectorize, Agents SDK, feature flags, networking, security, and IaC with Terraform/Pulumi.

Cloudflare Workers CLI for deploying, developing, and managing Workers, KV, R2, D1, Vectorize, Queues, Workflows, and Secrets Store with correct syntax and best practices.

React composition patterns that scale. Compound components, render props, context providers, and component architecture for building flexible component libraries.

Deploy applications and websites to Vercel instantly. Handles deployment, preview URLs, environment variables, and project configuration.

React and Next.js performance optimization guidelines from Vercel Engineering. 40+ rules across 8 categories covering components, data fetching, bundle optimization, and rendering.

Prepare for a sales call with account context, attendee research, suggested agenda, and discovery questions. Walk into every call knowing the company's priorities, likely objections, and what a win looks like.

Research a prospect then draft personalized cold outreach emails and LinkedIn messages. Uses web research to find specific hooks — recent news, hires, product launches, or pain points — that make your message stand out.

Audit, document, or extend your design system. Checks for naming inconsistencies, hardcoded values across components, writes component documentation with variants and accessibility notes.