What's New

Build conversational multi-agent workflows with Microsoft AutoGen. Generates agent role definitions, group chat orchestration, tool-using assistants, code-execution sandboxes, and human-in-the-loop checkpoints.

Run Chroma as an embedded or client-server vector store. Generates collection setup, persistent storage configs, custom embedding functions, metadata filters, and migration paths to managed vector DBs later.

Author Dagster assets, jobs, sensors, and schedules. Generates asset-based DAGs, partitioned backfills, dbt+Dagster integrations, IO managers for warehouses, and observability with declarative scheduling.

Author dbt models, tests, and docs for analytics warehouses. Generates staging/mart layers, incremental models, snapshot logic, ref/source patterns, and CI tests for Snowflake, BigQuery, and Databricks.

Build LLM pipelines as composable modules with DSPy. Writes signatures, chain-of-thought modules, retrieval-augmented programs, and bootstrapped few-shot optimizers that improve prompts automatically from data.

Run fast analytical queries on Parquet, CSV, and JSON with DuckDB. Generates in-process pipelines, S3/HTTPFS reads, MotherDuck deploys, and pandas/polars integration for local-first analytics.

Get reliable JSON from any LLM with Instructor. Generates Pydantic response models, validation+retry loops, streaming partial objects, and provider-agnostic clients for OpenAI, Anthropic, Mistral, and local models.

Fine-tune open models efficiently with LoRA and QLoRA. Generates PEFT configs, dataset formatting, training scripts using transformers + bitsandbytes, eval harnesses, and merge-and-export steps for serving.

Track ML experiments, models, and prompts with MLflow. Wires up autologging for sklearn/PyTorch/transformers, GenAI evaluation runs, model registry promotion flows, and Postgres+S3 backends for team-shared servers.

Run open-weight models locally with Ollama. Generates Modelfile configs, GPU/CPU tuning, OpenAI-compatible API wiring, structured outputs with JSON mode, and per-model memory budgets for laptop dev.

Add vector similarity search to Postgres with pgvector. Generates schemas with HNSW/IVFFlat indexes, embedding columns, hybrid keyword+vector queries, and pooling-friendly patterns for production RAG.

Manage Pinecone serverless and pod-based indexes. Handles namespace design, upsert batching, metadata filtering, sparse-dense hybrid queries, and cost-aware index sizing for production RAG.

Migrate from pandas to Polars for fast, lazy DataFrames. Rewrites groupby/window/join chains using expression API, streams large datasets that don't fit in RAM, and emits idiomatic LazyFrame pipelines.

Design and query Weaviate collections for semantic search. Generates class schemas, vectorizer configs, hybrid BM25+vector queries, multi-tenancy patterns, and async batch import for millions of objects.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

"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 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.

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 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.

Build 3D web experiences with Three.js and React Three Fiber. Creates scenes, lighting, materials, animations, physics simulations, and interactive 3D interfaces that run in the browser.

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.

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.

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.

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 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.

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.

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

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 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.

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

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.

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

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.

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.

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.

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.

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 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.

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.

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

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.

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.

Reflective pass over memory files: merge duplicates, fix stale facts, prune the index.

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.

Build interactive HTML dashboards with charts, filters, KPI cards. Self-contained browser report.

Create publication-quality charts with Python. Right chart type for any comparison or trend.

Profile and explore datasets: null rates, distributions, duplicates, data quality issues.

Write correct, performant SQL across all dialects. Optimized analytical queries with CTEs.

Apply stats methods: descriptive stats, trend analysis, outlier detection, hypothesis testing.

QA analysis before sharing: methodology checks, accuracy, aggregation logic, bias review.

Write optimized SQL: CTEs, window functions, joins. Supports Snowflake, BigQuery, Postgres.

WCAG 2.1 AA audit for designs and pages. Color contrast, keyboard nav, screen reader behavior.

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

Generate developer handoff specs: layout, tokens, component props, interaction states, breakpoints.

Synthesize user research into themes, insights, and recommendations from interviews and surveys.

Plan and conduct user research. Interview guides, usability tests, survey design.

Pre-deployment verification checklist. Verify CI, migrations, flags, rollback plan before shipping.

Write and maintain technical docs: READMEs, runbooks, API docs, architecture guides.

Run incident response: triage, communicate, resolve, and write a blameless postmortem.

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

Design systems, services, and APIs. Covers data models, service boundaries, scaling trade-offs.

Identify, categorize and prioritize technical debt. Audit code health and build a refactoring backlog.

Design test strategies and plans. From unit to e2e, coverage targets, and CI integration.

Review content against brand voice and style guide. Flags deviations with before/after fixes.

Full campaign brief with objectives, audience, messaging, channel strategy, and content calendar.

Research competitors and generate positioning comparison with content gaps and threats.

Draft blog posts, social media, email newsletters, landing pages with SEO recommendations.

Build marketing performance reports with trend analysis, wins, misses, and next-period priorities.

Comprehensive SEO audit: keyword research, on-page analysis, content gaps, technical checks.

Brainstorm product ideas, explore problem spaces, stress-test assumptions as a thinking partner.

Competitive analysis brief for features or market position. For roadmap and board materials.

Review product metrics with trend analysis. Investigate spikes, compare against targets.

Update, create, or reprioritize your product roadmap. Now/Next/Later view from scratch.

Plan a sprint: scope work, estimate capacity, set goals, handle carryover.

Generate stakeholder updates tailored to audience: exec brief, engineering detail, customer-facing.

Synthesize user research from interviews, surveys, tickets into structured insights.

Two-tier memory system. CLAUDE.md for working memory, memory/ directory for knowledge base.

Initialize the productivity system. Bootstrap working memory from your task list.

Sync tasks and refresh memory. Pull new assignments, triage stale tasks, catch buried todos.

Deep research on target accounts and contacts. Actionable sales intel from web research.

Process call notes or transcripts: action items, follow-up email, internal summary.

Research competitors and build interactive battlecards with comparison matrix.

Generate tailored sales assets: landing pages, decks, one-pagers from deal context.

Start your day with a prioritized sales briefing: meetings, pipeline, priorities.

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.

Optimize how your brand appears in AI responses (ChatGPT, Claude, Perplexity). GEO strategy.

Find and fix broken links on a site or codebase. Identifies dead URLs and suggests fixes.

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

Translate content for international SEO with hreflang, keyword research, cultural adaptation.

Generate SEO-optimized content: full article with title, meta, headings, internal links, schema.

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

Cluster keywords into topical groups mapped to content pages with recommendations.

Optimize a specific page for SEO: title, meta, headings, structured data, keyword placement.

Generate JSON-LD structured data for rich snippets: Article, Product, FAQ, LocalBusiness.

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.

Official Expo team skills for building React Native apps with Expo. Covers project setup, navigation, native modules, EAS builds, and deployment workflows.

Expert guidance for ffuf web fuzzing during penetration testing. Directory brute-forcing, parameter discovery, virtual host enumeration, and fuzzing workflows.

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.

Comprehensive collection of scientific research skills — data analysis, experiment design, literature review, statistical modeling, and reproducible research workflows.

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.

Generate favicons, app icons, social media images, and Open Graph assets. Creates all required sizes and formats for web, iOS, Android, and social platforms.

Create generative art using p5.js with seeded randomness and interactive parameter exploration. Build flow fields, particle systems, and computational aesthetic movements expressed through code.

Apply Anthropic's official brand colors, typography, and visual identity to artifacts. Use when brand styling, corporate identity, or company design standards apply to any deliverable.

Create beautiful visual art in PNG and PDF formats using design philosophy. Build posters, artwork, and static visual pieces with original design philosophies expressed on canvas.

Create distinctive, production-grade frontend interfaces with bold design choices that avoid generic AI aesthetics. Build web components, landing pages, dashboards, and full applications.

Create animated GIFs optimized for Slack with proper dimensions, frame rates, and file sizes. Handles emoji GIFs (128x128) and message GIFs (480x480).

Apply professional font and color themes to artifacts — slides, docs, reports, landing pages. 10 pre-set themes with colors and fonts, plus on-the-fly custom theme generation.

Build, debug, and optimize Claude API and Anthropic SDK applications. Handles prompt caching, tool use, batch processing, thinking, compaction, and model migration between Claude versions.

Build high-quality MCP (Model Context Protocol) servers to integrate external APIs and services. Supports Python (FastMCP) and Node/TypeScript (MCP SDK) implementations.

Build complex multi-component claude.ai HTML artifacts using React, Tailwind CSS, and shadcn/ui. Handles state management, routing, and component composition for rich web experiences.

Test local web applications using Playwright for UI verification. Capture screenshots, debug UI behavior, view browser logs, and verify frontend functionality.

Structured workflow for co-authoring documentation, proposals, technical specs, and decision docs. Three-stage process: context gathering, refinement, and reader testing.

Write internal communications using company-standard formats: 3P updates, status reports, leadership updates, newsletters, FAQs, incident reports, and project updates.

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.

Build native UI components in Expo using SwiftUI (iOS) and Jetpack Compose (Android). Create truly native experiences beyond React Native's built-in components.

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.

Automated PR review powered by Sentry context. Reviews pull requests with awareness of production error patterns, performance regressions, and observability gaps.

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.

Vercel cost and performance optimization for deployed projects. Analyzes metrics, usage, and project config to produce ranked recommendations for bill reduction and speed improvements.

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

React Native and Expo best practices for performant mobile apps. 16 rules across 7 sections covering performance, architecture, animations, and platform-specific patterns.

Implement smooth, native-feeling animations using React's View Transition API. Page transitions, shared element animations, route change animations, and directional navigation.

Review UI code for web interface best practices compliance. Audits 100+ rules covering accessibility, performance, UX patterns, and responsive design.

Everything with PDF files: read and extract text or tables, combine or split PDFs, rotate pages, add watermarks, create new PDFs, fill forms, encrypt/decrypt, extract images, and OCR scanned documents.

Answer data questions — from quick metric lookups to full analyses. Investigates trends, compares segments, explains drops and spikes, and prepares formal data reports for stakeholders.

Simple but powerful task management using a shared TASKS.md file. Track commitments, add and complete tasks, manage priorities, and stay on top of deadlines without switching to another app.

Develop a content strategy for SEO and organic growth. Includes topic research, keyword clustering, content calendar, audience targeting, and competitive positioning to maximize organic traffic.

Run a comprehensive SEO audit — keyword research, on-page analysis, content gaps, technical checks, and competitor comparison. Get a prioritized action plan split into quick wins and strategic investments.

Write a feature spec or PRD from a problem statement or feature idea. Turns vague ideas into structured documents with goals, non-goals, success metrics, user stories, and acceptance criteria.

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.

Draft marketing content across channels — blog posts, social media, email newsletters, landing pages, press releases, and case studies with channel-specific formatting and SEO recommendations.

Design and draft multi-email sequences with full copy, timing, branching logic, exit conditions, and performance benchmarks for onboarding, lead nurture, re-engagement, and product launches.

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

Write or review UX copy — microcopy, error messages, empty states, CTAs, confirmation dialogs, and onboarding text. Gets the words right so your interface feels polished and human.

Create and evaluate architecture decision records (ADRs). Use when choosing between technologies, documenting design decisions with trade-offs, reviewing system design proposals, or designing new components from requirements.

Review code changes for security vulnerabilities, performance issues, and correctness. Catches N+1 queries, injection risks, missing edge cases, and error handling gaps before they reach production.

Structured debugging session — reproduce, isolate, diagnose, and fix. Best for error messages, stack traces, staging vs production divergence, or when behavior unexpectedly deviates from expected.