Performance plugins

Control Chrome programmatically through the DevTools Protocol via MCP — debug web pages, automate browser interactions, run performance and accessibility audits, capture screenshots, and diagnose memory leaks, all from an AI assistant.

Guides Next.js developers through implementing Cache Components and Partial Prerendering (PPR) with patterns for the 'use cache' directive, cacheLife, cacheTag, and cache invalidation, auto-activating in projects configured with cacheComponents: true

Generate algorithmic art manifestos as p5.js sketches, build Godot 4 games with GDScript patterns, develop Unity games with optimized C# and URP/HDRP pipelines, and apply 2D/3D game development and design principles for indie game prototyping.

Automate SEO content strategy and optimization—from keyword research and article generation to structured data validation and content structure analysis—to improve search rankings.

Scaffold, write, and optimize systems-level code in Rust, Go, C, and C++ with agents and skills for memory safety, concurrency (goroutines, Tokio async), and production project setup

Frontend development bundle that optimizes forms for higher conversion, designs distinctive interfaces, enforces Next.js App Router best practices, applies 45 React performance rules, provides modern React patterns, diagnoses SEO issues, and configures Tailwind CSS v4 design tokens.

Provide expert guidance for building, debugging, and optimizing TypeScript and JavaScript applications with modern frameworks like Next.js and Node.js, covering ES6+ patterns, React performance, App Router, framework selection, and advanced type-level programming.

Write systems-level code in C++, Go, and Rust with idiomatic patterns, concurrency, memory safety, and performance profiling for production-ready services, CLIs, and libraries.

Diagnose performance bottlenecks, implement distributed tracing, and manage incident response with Prometheus, Grafana, OpenTelemetry, and Datadog. Define SLIs/SLOs, run blameless postmortems, and build production-ready observability pipelines for microservices and infrastructure.

Run comprehensive SEO audits on entire sites — technical crawl, content quality, schema, Core Web Vitals, backlinks, local/maps presence, e-commerce, hreflang, sitemaps, and GEO/AI search visibility — then generate scored action plans and content briefs, all from Claude Code.

Write, review, and refactor SwiftUI code for iOS/macOS with guidance on state management, view performance, animations, API migration, and Instruments trace analysis.

Audit and optimize paid advertising campaigns across Google, Meta, YouTube, LinkedIn, TikTok, Microsoft, Apple, and Amazon Ads with 250+ automated checks, weighted scoring, AI creative generation, and deep-dive attribution analysis.

Autonomously optimize code files by measurable metrics through iterative experiments: set up target file, eval command, and loop intervals (10min-monthly); AI edits code, commits to git branches, evaluates with Python, keeps improvements. Resume, run manually, or check dashboard status.

Query Claude, Cursor, or other AI agents for expert GSAP guidance to build performant animations, timelines, ScrollTrigger effects, and plugin integrations in React, Next.js, Vue, Nuxt, Svelte, or vanilla JS, following framework best practices and 60fps optimizations.

Develop production-grade Go applications with AI-assisted skills covering project layout, concurrency, profiling, observability, testing, CI/CD, and idiomatic coding patterns across the full development lifecycle.

Migrate Lodash code to es-toolkit in JavaScript and TypeScript projects by replacing imports and comparing APIs to shrink bundle sizes, get function recommendations matching your needs or code with imports examples and docs, and follow tailored setup guides for Node.js Bun Deno and browsers to optimize performance.

Diagnose Swift concurrency issues, refactor callback-based code to async/await, and guide Swift 6 migration with best practices for tasks, actors, Sendable, and data race prevention.

Build performant Unity games with JEngine hot-update framework by chaining fluent async tasks as coroutine alternatives, pooling objects thread-safely to slash GC pressure, awaiting async modal dialogs for user input, extending editor with themed UIElements UIs, and coding zero-GC patterns like cooldowns and timers using modern C#.

Analyze slow SQL queries and receive optimized rewrites, index recommendations, execution plan insights, anti-pattern fixes, and performance estimates for PostgreSQL, MySQL, and SQLite databases.

Analyze your codebase and infrastructure for performance bottlenecks across frontend, backend, and architecture. Get prioritized optimization recommendations, impact estimates, quick wins, phased implementation roadmaps, and code examples to improve speed and efficiency.

Backtest crypto and stock trading strategies on historical data to compute performance metrics like Sharpe and Sortino ratios, maximum drawdowns, equity curves, and optimize parameters via grid search.

Audit Claude Code and Codex sessions for context window waste, recover 5-25% token overhead through config cleanup and compaction, and monitor token usage trends with a dashboard that shows quality scores, session history, and cost savings from recommended fixes.

Audit Armeria-based Java projects for event loop blocking by discovering patterns, scanning operations, tracing calls, and generating fix plans without code changes. Pinpoint latency spike causes for pre-release validation.

Optimize Ethereum and L2 transaction gas fees by fetching real-time prices, estimating DeFi costs, predicting patterns, identifying optimal timing windows, and recommending cheaper sidechain routes like Polygon for maximum savings.

Optimize LLM prompts for OpenAI and Anthropic by automatically detecting redundancy, simplifying instructions, and rewriting to reduce token usage, lower costs, and improve performance.

Detect memory leaks in running Node.js, Python, and JVM apps by analyzing event listeners, closures, unbounded caches, and retained references. Scan codebases for patterns like unremoved listeners, uncancelled timers, circular references, and DOM holds, generating markdown reports with severity ratings, code locations, snippets, fixes, and prevention strategies.

Design, execute, and analyze load, stress, spike, soak, and endurance tests on APIs, web apps, and databases using k6, Artillery, JMeter, Locust, and autocannon. Identify bottlenecks, review metrics, and verify SLAs to optimize performance.

Audit and optimize web projects for Lighthouse scores, Core Web Vitals, WCAG 2.2 accessibility, technical SEO, performance bottlenecks, security best practices, and code quality using specialized agent skills that apply fixes with code examples.

Diagnose network latency issues using curl, ping, and traceroute to optimize API request patterns through parallelization, batching, and connection pooling. Analyze your codebase for latency bottlenecks like serial execution and timeouts, then generate markdown reports with request inventories and targeted optimization recommendations.

Set up distributed tracing for microservices using OpenTelemetry with Jaeger or Zipkin backends. Automate SDK integration, service instrumentation, context propagation, span creation, trace sampling, collection, and dashboard deployment for end-to-end request visibility and performance analysis.

Monitor error rates across HTTP endpoints, databases, APIs, jobs, exceptions, and client-side issues. Set up alerting with custom thresholds, error budgets, dashboards, and integrations to Sentry, Rollbar, or CloudWatch for application reliability and SRE practices.

Generate k6, Artillery, wrk, or Gatling scripts for API load, stress, and soak tests to validate performance under configurable loads. Run tests locally to measure response times, throughput, error rates, scalability, and identify bottlenecks.

Interpret EXPLAIN plans and query metrics from PostgreSQL, MySQL, and MongoDB to detect bottlenecks like sequential scans, missing indexes, and inefficient joins. Receive targeted SQL optimization recommendations with expected performance impacts.

Scan codebases to detect CPU hotspots, intensive operations, blocking calls, and algorithmic inefficiencies. Generate detailed optimization reports with before/after code examples, performance estimates, and targeted recommendations to boost application speed in bash, Python, and Java projects.

Design and implement partitioning strategies for PostgreSQL and MySQL tables using range, list, hash, and composite methods to handle massive datasets. Automate schema design, maintenance routines, query optimization, and data retention policies for improved performance.

Monitor CPU, memory, disk I/O, network usage, DB connections, and processes on Linux systems to identify bottlenecks, then generate monitoring code, dashboard configs, alerts, and right-sizing recommendations for resource optimization and cost reduction.

Analyze PostgreSQL, MySQL, and MongoDB query workloads to detect missing indexes causing sequential scans, identify unused indexes, recommend optimal configurations, estimate performance impacts, and generate SQL scripts for index creation and drops.

Master Cursor IDE AI workflows using 30 guided skills: install and authenticate, configure custom models and rules, optimize indexing and performance, automate Composer for multi-file refactoring and scaffolding, troubleshoot errors, manage teams with SSO, and audit compliance.

Monitor Ethereum and L2 mempools like BSC, Polygon, Arbitrum in real-time to detect MEV opportunities including sandwich attacks, arbitrage, liquidations; analyze pending transactions, DEX swaps; optimize gas prices via Python scripts and specialized agents.

Implement multi-level API caching strategies using Redis for server-side storage, CDNs for edge caching, and HTTP headers for browser control, with TTL settings, tag-based invalidation, cache-aside patterns, and stale-while-revalidate to optimize performance across Node, Python, and Java backends.

Delegate coding tasks to expert AI agents specialized in Python, Go, Rust, Java, JavaScript, PHP, Ruby/Rails, C/C++, SQL, and TypeScript. They proactively write idiomatic code, refactor for performance, implement advanced features like concurrency and generics, add tests with pytest or RSpec, optimize queries/schemas, and handle builds like Cargo.toml or CMake.

Wrangle, profile, clean, transform, and analyze tabular data (CSV, TSV, Excel, JSONL, Parquet) using 51 qsv skill-based commands — including SQL queries, joins, validation, ontology inference, charting, performance acceleration, and reproducible logging.

Define SLIs with measurement methods like availability, latency, and error rates; set SLO targets and error budgets; generate bash monitoring code, dashboard configs, and alerts to track SLAs and service reliability health.

Profile Node.js, Python, and Java application performance by analyzing CPU usage, memory allocation, execution hotspots, and bottlenecks. Generate markdown reports with detailed breakdowns, patterns, and actionable optimization recommendations including code fixes.

Analyze caching implementations for Redis, Memcached, and in-memory stores to detect inefficiencies in hit rates, TTLs, key designs, and invalidation policies, then generate optimization reports with actionable code examples to resolve performance bottlenecks.

Implement multi-tier database caching using Redis for L2 distributed cache, in-memory L1 cache, and CDN layers with cache-aside and write-through patterns, TTLs, and invalidation strategies to reduce database load and boost read performance for PostgreSQL and MySQL setups.

Audit database connections, calculate optimal pool sizes, configure app-level pooling parameters, and deploy PgBouncer or ProxySQL for PostgreSQL and MySQL to prevent exhaustion and boost throughput. Implement best practices with code examples for Node.js, Python, and Java.

Generate and run load tests with k6, JMeter, or Artillery to validate web app and API performance under stress, spike, soak, and scalability scenarios. Detect bottlenecks, set thresholds, and integrate into CI/CD pipelines for automated validation.

Implement Real User Monitoring (RUM) in web apps to capture actual user performance data like Core Web Vitals, page loads, and custom events. Integrate with Google Analytics, Datadog, or New Relic for dashboards, alerts, segmentation, custom metrics, and privacy-compliant setups.

Instrument APIs, database queries, external services, frontend, and jobs to track response times with P50/P95/P99 percentiles. Monitor SLOs via dashboards, set alerts for bottlenecks, and apply provided optimization strategies to improve application performance.

Analyze infrastructure capacity by evaluating CPU, memory, storage, and network utilization to forecast growth trends, identify bottlenecks, project future needs, and receive scaling recommendations with cost estimates and monitoring setups.

Define performance budgets for web app metrics like page loads, bundle sizes, API responses, and Lighthouse scores, then validate them in CI/CD pipelines to detect regressions. Auto-generates configs, scripts, dashboards, alerts, and remediation steps.

Generate APM monitoring dashboards for Grafana, Datadog, and New Relic covering golden signals, request metrics, resource utilization, database and cache metrics, errors, and KPIs. Outputs JSON or YAML configurations including queries, visualizations, panels, alerts, and setup instructions.

Detect performance bottlenecks in CPU, memory, I/O, database queries, locks, and resources for slow applications. Generate detailed reports with severity ratings, root causes, impact analysis, code-based remediations, monitoring recommendations, and action priorities to optimize efficiently.

Analyze application logs to detect slow requests, recurring errors, resource anomalies, slow queries, and traffic patterns. Receive performance summaries, optimization suggestions, logging setup guides, aggregation configs, dashboard queries, and alert recommendations for troubleshooting and monitoring.

Build API monitoring systems with Prometheus metrics, Grafana dashboards, health checks, alerts, synthetic probes, and SLO tracking to ensure performance and uptime for Node.js, Python, and Java REST APIs.

Automate performance regression detection in CI/CD pipelines by generating test suites, baselines, thresholds, reporting, and PR integrations. Statistically compare response times, throughput, resource usage against baselines to validate builds and spot trends early.

Optimize Python deep learning models using Adam, SGD optimizers, learning rate schedulers, and regularization to improve accuracy and reduce training time. Generate production-ready AI/ML code from context analysis, including validation, error handling, performance metrics, insights, artifacts, and documentation.

Optimize ML model hyperparameters using grid, random, or Bayesian search. Generate and execute validated Python code with scikit-learn or Optuna on datasets like Iris for models such as Random Forest or Gradient Boosting, retrieve performance metrics, save tuned artifacts, and generate documentation.

Analyze system throughput for requests, data processing, queues, and resources using natural language queries to identify bottlenecks, evaluate scaling strategies, and generate optimization reports with code improvements and expected performance gains.

Centralize performance metrics from apps, systems, databases, caches, and services into Prometheus, StatsD, or CloudWatch using unified naming. Generate instrumentation code, Prometheus configs, Grafana dashboards, retention policies, and alerts for comprehensive monitoring workflows.

Set up synthetic monitoring for proactive app uptime checks, transaction flows, API health, multi-location tests, and SSL certificates using Pingdom, Datadog, or New Relic. Generates bash configs, test scripts, alerts, dashboards, and incident response playbooks.

Benchmark Xcode clean and incremental builds for iOS/macOS apps, analyze SPM dependencies, compile hotspots, and project settings to pinpoint slowdowns, then apply prioritized fixes like settings tweaks and source optimizations, re-benchmarking to confirm wall-clock gains.

Profile database queries to detect performance issues like N+1 queries, missing indexes, full table scans, and inefficient joins, generating reports with query inventories, actionable recommendations, CREATE INDEX SQL statements, and before/after examples for quick optimizations.

Delegate frontend development tasks to this agent for building responsive UIs and components in React, Vue, or Angular; implementing state management; fixing responsive design and accessibility issues; and optimizing performance with techniques like virtualization and memoization.

Benchmark Clojure code performance with Criterium, automatically managing JVM warmup and GC effects for accurate results, including statistical analysis with confidence intervals, outlier detection, and visualization via bench macros, plans, and viewers.

Query Google Search Console data via natural language to detect keyword cannibalization, identify quick-win SEO opportunities (pages 11-20 with high impressions), audit indexing status with prioritized fix recommendations, and generate weekly performance reports with trend alerts.

Provides 48 domain-specific skills and 9 agents for Godot 4.x game development in GDScript and C#, covering 2D/3D systems, animation, AI, UI, multiplayer, performance optimization, and editor tooling.

Run slash commands to audit full-stack performance, optimize Webpack/Vite/Gradle builds and React bundle sizes via code splitting and caching, implement Node/Express caching layers and service workers, configure Cloudflare/AWS CDNs, and simulate system loads for bottleneck fixes and capacity planning.

Agentically audit, optimize, and manage Power BI semantic models in Microsoft Fabric: trace dependencies across workspaces for impact analysis, review quality and performance against best practices, standardize TMDL naming conventions, author and validate Power Query M expressions, and orchestrate full/incremental refreshes via REST APIs and CLI.

Connect to Power BI Desktop's local Analysis Services instance via TOM and ADOMD.NET to enumerate models, run DAX queries, edit metadata, trace queries, and capture live DAX queries from visuals for real-time performance summaries, timings, and CPU usage—no MCP server needed.

Optimize SQL queries and analyze execution plans in plain English for PostgreSQL, MySQL, SQLite, and SQL Server. Identify costs and bottlenecks, get index suggestions and rewrites, then compare before/after performance using EXPLAIN ANALYZE.

Build optimized Docker images from context using best practices for caching, security, and minimal size, or optimize existing Dockerfiles for faster builds and smaller footprints. Includes automated analysis, smoke tests, vulnerability scans, size/layer comparisons, and detailed reports.

Use slash commands to set up performance monitoring with New Relic or Datadog APM in Node.js apps, including instrumentation and custom metrics, and deploy full observability stacks with Prometheus metrics, Jaeger or Zipkin tracing, ELK or Fluentd logging, alerting, and Grafana or Kibana dashboards.

Design MongoDB schemas with best patterns and anti-patterns, generate and optimize queries from natural language using schema and indexes, tune client connections across Node.js Python Java Go drivers, implement Atlas full-text vector hybrid search for RAG, provision stream processing pipelines with Kafka S3 Lambda, and configure MCP servers via Docker or Atlas API.

Review and refactor React, Next.js, and React Native code using Vercel engineering best practices for performance optimization, component composition patterns, mobile app efficiency, smooth view transitions, and web UI design/accessibility audits.

Autonomously optimize LLM serving infrastructure — profile torch traces, benchmark SGLang/vLLM/TensorRT-LLM, simulate capacity and compute, and run RLCR loops that patch code to match or beat competitor performance. Also includes human-like PR review and incident triage for production serving.

Design optimized PostgreSQL schemas from business requirements with entity modeling and SQL DDL, generate Node.js migration frameworks with zero-downtime strategies and rollbacks, and optimize performance for PostgreSQL/MySQL by analyzing slow queries, indexes, execution plans, and resource usage.

Profile codebases in JavaScript, Python, and Go to uncover performance bottlenecks, resource leaks, scalability issues, and anti-patterns in databases, memory, async code, frontend, and networks with quantified impact reports. Then automatically optimize hotspots by applying caching, batching, algorithmic improvements, and async patterns to files, functions, or modules.

Profile API endpoints to measure latencies and detect bottlenecks like N+1 queries or missing indexes, then run benchmarks on functions and modules with vitest or pytest for ops/sec, memory usage, comparisons, and prioritized optimization suggestions with impact estimates.

Scan your project's stylesheets and templates to detect unused CSS selectors, variables, and duplicates with confidence scores and potential bundle savings. Then consolidate by merging redundant rules, unifying properties, grouping media queries, and extracting utilities—reducing file sizes while preserving exact visual output and reporting metrics.

Accelerate website creation and optimization with 103 structured skills spanning research, brand strategy, design, content, SEO, analytics, performance, security, and deployment—each providing expert-level prompts for tasks like auditing accessibility, fixing Core Web Vitals, conducting competitive analysis, running experiments, and managing incident response.

Scaffold React/Next.js projects with TypeScript and Tailwind, generate tested components and hooks, analyze bundles to optimize performance, and apply advanced patterns with accessibility best practices.

Run a phased performance investigation workflow that establishes baselines, maps code paths, profiles hotspots with flame graphs, generates and tests hypotheses via benchmarks, logs evidence, and synthesizes recommendations with decisions for Node/JS, Python, Rust, Go, Java projects.

Run functional tests on API endpoints across happy path, validation, auth, edge cases, and idempotency scenarios using curl/fetch, plus staged load tests to measure throughput, latency, errors, and breaking points. Generate pass/fail summary tables and metrics with recommendations.

Profile code bottlenecks and bundle bloat, apply targeted optimizations using Amdahl's Law, measure before/after runtime performance and size reductions, and review documented trade-offs.

Optimize PostgreSQL and MySQL query performance by running EXPLAIN ANALYZE to identify issues, locks, and patterns, generating structured reports with improvement estimates and suggestions, then applying index recommendations via safe concurrent migrations with redundancy checks.

Run Lighthouse audits on target URLs to diagnose performance, accessibility, best practices, SEO, and PWA issues with Core Web Vitals scores and reports. Automatically apply prioritized fixes, verify improvements by re-running audits, and track score changes.

Run load and stress tests against API endpoints or web pages to capture metrics like requests/sec, latency percentiles, errors, and bottlenecks. Generate timestamped Markdown reports with throughput analysis, slowest endpoints, trends, SLA comparisons, and optimization recommendations.

Systematically debug bugs with root cause analysis: gather symptoms, trace execution paths via git logs, test hypotheses, implement fixes, and add regression tests. Trace requests through codebase to generate sequence diagrams highlighting failures, bottlenecks, and async flows.

Benchmark REST and GraphQL API endpoints with interactive load tests using warmup requests and concurrency to measure response times, throughput, errors, and payload sizes. Generate markdown performance reports including stats summaries, histograms, endpoint rankings, SLA checks, error analysis, regressions, and recommendations.

Analyze JavaScript and TypeScript bundle sizes in webpack and Vite projects to identify top modules, duplicates, and tree-shaking issues, then apply optimizations via config suggestions, named imports, and rebuilds with before-after size reports.

Detect memory leaks and profile heap usage in Node.js, Python, Java, Go, and browser apps by capturing snapshots, measuring growth rates with GC, tracing references, identifying consumers, suggesting fixes, and verifying resolutions.

Develop cross-platform Rust GUI apps with Makepad 2.0. Generate app boilerplates with Cargo.toml and hot reload, script UIs using Splash DSL for state, events, layouts, and themes, implement animations, shaders, and vector graphics, migrate from v1.x, optimize performance via batching and GC, and troubleshoot rendering bugs, zero-height issues, and WASM builds.

Connect remotely to Sentry via MCP for error tracking, performance analysis, issue triaging, stack trace examination, event querying, and management of projects, releases, and teams directly in agent workflows. Requires Sentry auth token.

Delegate frontend development tasks to a specialized agent that builds responsive UIs with React, Vue, or Angular components, implements state management, fixes responsive and accessibility issues, and optimizes performance for web apps.