Performance plugins

Implement Next.js Cache Components and Partial Prerendering (PPR) using guided patterns for 'use cache' directives, cacheLife(), cacheTag(), revalidateTag() to control caching, invalidation, static/dynamic optimization, and parameter permutation rendering. Auto-activates when cacheComponents: true is set.

Launch a local Chrome DevTools MCP server to automate browser tasks via CLI, debug web pages with DOM/network inspection, profile performance metrics like LCP and memory leaks, and audit accessibility using Lighthouse—all integrated for AI-driven workflows in your IDE.

Prototype and build optimized 2D/3D indie games in Godot and Unity by generating GDScript patterns for signals state machines scenes, C# scripts with URP/HDRP pipelines asset management profiling, principles for sprites tilemaps physics shaders lighting LOD core loops player psychology balancing progression, plus p5.js HTML/JS generative art sketches.

Unlock bundled expert skills in Claude Code to build full-stack Next.js apps with App Router and Server Actions, select and implement performant Node.js backends with Hono or NestJS, apply React optimization rules, and master advanced TypeScript for monorepos and migrations.

Build production-grade React and Next.js web apps with guided expertise in modern patterns, Tailwind v4 configs, distinctive designs, form friction reduction, performance rules, and SEO diagnostics. Streamline frontend development from components to audits.

Develop production-ready Odoo ERP systems end-to-end: scaffold custom modules with ORM patterns, deploy via Docker Compose with Nginx and PostgreSQL, configure eCommerce payments and CRM workflows, tune performance via queries and DB optimization, and enforce security rules.

Build production observability stacks with Prometheus, Grafana, OpenTelemetry, and DataDog; define SLIs, SLOs, and error budgets; run SRE incident response and blameless postmortems; diagnose performance bottlenecks; implement distributed tracing for microservices to maintain reliability.

Develop high-performance, concurrent systems applications in modern C++, Go, and Rust using idiomatic patterns like RAII, smart pointers, goroutines, channels, ownership, lifetimes, and async. Generate CMake builds, tests, benchmarks, profile performance, debug races, and apply cross-language memory-safe resource management to prevent leaks and errors.

Design scalable database architectures, build interactive D3.js visualizations in React/Vue/Svelte, set up A/B tests with metrics validation, audit analytics tracking for data quality, apply Postgres best practices, and optimize complex SQL queries across cloud databases like Snowflake and BigQuery.

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.

Conduct full-site SEO audits by crawling up to 500 pages, fetching live data from Google APIs, DataForSEO, Moz; analyze technical issues, Core Web Vitals, schema markup, backlinks, E-E-A-T content, local SEO, AI search visibility; generate health scores, prioritized action plans, content briefs, sitemaps, hreflang, image optimizations, strategic roadmaps, and PDF reports across industries.

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.

Review, refactor, and implement SwiftUI code for iOS/macOS apps with expert guidance on state management, view composition, performance optimization including iOS 26+ Liquid Glass adoption, and Instruments trace analysis for hangs, hitches, and hotspots.

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

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.

Fine-tune LLMs with Tinker API by diagnosing training issues like slow steps, hanging sessions, vLLM mismatches, errors, and deployments; conduct post-training research replicating papers via SFT, RL, DPO, distillation experiments with run monitoring, hyperparameter tuning, and log analysis.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

Audit Claude Code and multi-agent setups for token waste and ghost tokens, generate optimization plans with dollar savings estimates, monitor usage trends via interactive dashboards, receive personalized coaching on efficient architectures, perform quick health checks, and automate token management on key events.

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.

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.

Run comprehensive SEO/GEO workflows in Claude: audit technical/on-page elements, research high-value keywords, analyze competitors and backlinks, optimize content for AI citations, generate schema markup and reports, track rankings, and integrate with APIs like Ahrefs, Semrush, Vercel for monitoring and data pulls.

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.

Incrementally migrate brownfield native iOS/Android apps to React Native using host integration tools, automate upgrades with rn-diff-purge diffs and config handling, optimize performance across FPS bundle size memory and jank, build simulator APK artifacts in GitHub Actions CI, and manage PRs merges branching with gh CLI.

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.

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.

Query Google Search Console SEO data using natural language in Claude Code to audit indexing status, detect keyword cannibalization, identify quick-win optimization opportunities from search analytics, and generate weekly performance reports with trends and recommendations.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Optimize Claude Code sessions by detecting/removing codebase bloat, dead code, and AI-generated hygiene issues; manage token budgets/context windows with MECW principles and subagent delegation; monitor CPU/GPU usage before intensive tasks; automate safe git-backed cleanups and audits.

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.

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.

Delegate building of native iOS/Android apps in Swift/Kotlin or cross-platform React Native/Flutter apps to an AI agent that implements performant video feeds, push notifications, biometric authentication, smooth UIs, and platform-specific integrations with optimizations for memory and scrolling.

Run local web performance audits via Chrome DevTools Protocol to measure Core Web Vitals like LCP and CLS, identify render-blocking resources, network chains, layout shifts, caching gaps, and accessibility issues, optimizing Lighthouse scores and page loads.

Delegate building of native iOS/Android apps with Swift/Kotlin, React Native/Flutter cross-platform features, and mobile performance optimizations like smooth video feeds, push notifications, biometrics, and platform integrations to this specialized agent.

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.

Connect your MCP agent to Sentry for error tracking and performance monitoring: analyze issues, stack traces, events, and traces; triage errors; query observability data; manage projects, releases, and teams remotely using authentication tokens.

Profile Python performance bottlenecks with cProfile/py-spy, analyze pytest test suites for quality/coverage, check async code for issues/patterns, lint/fix with ruff, optimize algorithms/memory, generate unit/integration tests, and package/publish projects using uv/pyproject.toml.

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.

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.

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.