Testing plugins

Automate comprehensive PR reviews with specialized agents that analyze code quality, test coverage, error handling, type design, comments, and simplification, producing a categorized issues summary with critical findings, suggestions, strengths, and an action plan.

Iteratively create custom Claude Code skills from scratch, refine existing ones via drafting and description optimization, run test evaluations, and benchmark performance with quantitative metrics and variance analysis.

Audit CLAUDE.md files across repositories by discovering them with find, evaluating quality against rubrics, generating reports, and applying targeted improvements after approval. Capture learnings from Claude Code sessions to propose concise updates to CLAUDE.md or .claude.local.md files with user approval.

Accelerate full-stack development with 66 specialized skills covering 12 languages, frontend/backend frameworks, infrastructure, DevOps, security, and testing, plus Jira/Confluence project management commands for epic planning, discovery, and retrospectives.

Automates end-to-end feature development: explores codebase to map dependencies, patterns, and execution paths; designs architectures with blueprints, data flows, and build sequences; implements code changes; reviews for bugs, security vulnerabilities, and quality issues using high-confidence filtering.

Generate Nature-style scientific manuscripts, figures, response letters, patent drafts, and presentations from research materials. Conduct multi-source literature searches, citation management, paper reading with Chinese-English side-by-side rendering, and simulated peer review.

Delegate expert-level code reviews, security audits, penetration tests, QA automation, accessibility compliance checks, performance optimizations, chaos engineering, and compliance validations to specialized sub-agents across codebases, infrastructure, and systems.

Enforce strict red-green-refactor TDD cycles: generate failing tests, implement minimal passing code, then refactor while keeping tests green. Includes AI-powered code review for security and quality.

Implement a complete QA and testing workflow: set up A/B tests with hard gates, automate browser testing with Playwright/Puppeteer, enforce code review checklists and TDD, debug systematically, and fix failing tests using pytest patterns.

Control a browser from the command line for AI-driven testing and automation — navigate pages, click elements, fill forms, capture screenshots, extract data, and automate Electron apps.

Write production-grade shell scripts with defensive programming patterns, unit tests via Bats, and static analysis via ShellCheck, enabling robust CI/CD pipelines and cross-platform automation.

Run end-to-end browser tests and automate web interactions using Playwright, allowing Claude to click elements, fill forms, take screenshots, and scrape content locally.

Enforces a lazy, minimal-code philosophy across your codebase by scanning for over-engineering, dead code, unnecessary abstractions, and stdlib replacements, then producing ranked cleanup lists and diff reviews. Tracks shortcuts as a debt ledger and offers intensity modes to guide simpler solutions.

Provides structured guidance for executing cybersecurity operations across penetration testing, incident response, threat hunting, cloud security, and malware analysis, with step-by-step procedures and tool usage.

Provides an opt-in productivity coaching system for Claude Code that enforces structured troubleshooting, evidence-based delivery, and multi-role agent orchestration. Activates automated retry loops, quality verification, and workplace-style process cues to drive task completion after repeated failures or passive behavior.

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.

Serve as an adversarial thinking partner for executives: stress-test business plans via pre-mortems and bear-case modeling, prepare for board meetings with key metrics and tough questions, navigate hard decisions using reversibility tests and stakeholder maps, conduct precise post-mortems with 5 Whys, and deploy a devil's advocate agent to uncover plan risks with mitigations.

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.

Install 124 ready-to-use Claude Code skills to automate 50+ third-party services including CRMs (HubSpot, Salesforce), PM tools (Jira, Asana), analytics (GA4, Mixpanel), cloud storage (Google Drive, Dropbox), GitHub/Vercel deploys, doc/PDF/image processing, React artifact building, design generation, and dev productivity tasks via Rube MCP/Composio integrations.

Generate Playwright tests from specs, migrate Cypress/Selenium suites, run on BrowserStack, sync with TestRail, analyze coverage, and diagnose flaky failures — all within your existing workflow.

Conduct full product discovery cycles in your IDE: brainstorm ideas and experiments for new/existing products from PM/designer/engineer views, identify/prioritize assumptions and features, triage requests, generate interview scripts, summarize transcripts, and design metrics dashboards.

Run a localhost iMessage-style web chat interface for Claude Code, supporting file uploads, message editing, and tool testing without tokens or access control.

Direct AI coding agents to create or update promptfoo evaluation suites with configs, prompts, tests, deterministic assertions, and provider setups following best practices. Streamline LLM eval coverage, regression debugging, and new eval matrix generation in JavaScript or Python projects using OpenAI or Anthropic models.

Implement Trail of Bits handbook security testing workflows: fuzz Rust, Python, C/C++, Ruby code with AFL++, libFuzzer, cargo-fuzz, Atheris; instrument AddressSanitizer; run static analysis via Semgrep, CodeQL; generate coverage reports, dictionaries, and bypass obstacles for vulnerability detection.

Develop and troubleshoot Ginkgo/Gomega test suites in Go, enabling spec authoring, table-driven tests, filtering, parallel execution, flake handling, async timeouts, CI setup, and JSON-based failure diagnosis.

Generate editorial-quality technical and product diagrams (architecture, flowchart, sequence, etc.) as standalone HTML files with inline SVG, skinnable to match your brand.

Automatically generate production-ready unit tests from source code files or snippets in JavaScript/TypeScript (using Jest, Vitest, or Mocha), Python (pytest), Java (JUnit 5), and Go. Auto-detects frameworks, covers happy paths, edge cases, boundaries, errors, and provides mocks for robust testing.

Build multi-language code graphs to map call graphs, attack surfaces, blast radius, taint propagation, privilege boundaries, and complexity hotspots for security audits. Visualize architecture with Mermaid diagrams, compare snapshots across git commits for evolution analysis, triage mutation testing survivors, generate crypto test vectors, diagram protocols, and project SARIF findings onto graphs.

Runs Mooncake pre-PR validation locally to catch typos, formatting, build and test failures before pushing, using a single shell script that mirrors the CI pipeline's reproducible checks.

Generate E2E test suites in JavaScript and automate testing for iOS/Android mobile apps on simulators/emulators using Appium, Detox, XCUITest, Espresso, or Maestro. Validate UI interactions, gestures, navigation, permissions, and platform behaviors.

Generate 35 structured engineering documents — including incident postmortems, architecture decision records, code review checklists, PR descriptions, changelogs, runbooks, test strategies, threat models, SLO definitions, and migration plans — directly from rough notes, logs, or git history within Claude Code.

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.

Generate and execute end-to-end browser tests for full user workflows spanning frontend and backend using Playwright, Cypress, or Selenium. Create tests with page objects, scenarios, and assertions, then run them to validate complete user journeys in browsers.

Configure and optimize mewt/muton mutation testing campaigns by scoping targets, tuning timeouts, and streamlining long-running tests for Rust, Go, TypeScript, and JavaScript codebases.

Reviews hires and terminations for jurisdiction-specific risk flags, classifies workers against the controlling state test, tracks leave deadlines before they're missed, runs internal investigations, and drafts policies with state supplements where the law differs.

Build and manage PortalJS data portals: recommend an architecture, scaffold a portal, add datasets (CSV/TSV/JSON/GeoJSON), create charts (recharts) and interactive maps (Leaflet), connect a CKAN backend, harvest datasets from open-data platforms, infer data schemas, audit data quality, and deploy to PortalJS Arc hosting.

Automatically audits and iteratively improves Claude Code skills until they meet quality standards, with ability to cancel improvement cycles while preserving changes

Automate OWASP Top 10 vulnerability scans and penetration testing on JavaScript, Python, and Java codebases using Semgrep, ESLint-security, Bandit, and dependency audits. Delegate comprehensive security audits to a specialized agent covering injections, XSS, CSRF, authentication flaws, access control, and misconfigurations.

Automate overnight software development by configuring Git hooks for TDD enforcement with tests and lints, then run Claude autonomously for 6-8 hours to build features that pass all checks by morning.

Detect UI visual regressions by capturing screenshots of components or pages with Playwright or Cypress, comparing against baselines across responsive breakpoints, generating pixel diffs, analyzing changes, and producing markdown reports with recommendations. Integrates with Percy, Chromatic, BackstopJS, and CI workflows.

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.

Multi-agent orchestration system with MCP tools and Claude Code plugin agents. 51 specialized agents for development workflows, code quality, deployment, research, and more.

Generate OpenAPI specs and Pact consumer contracts from API code, designs, or schemas to enable consumer-driven contract testing, documentation, code generation, verification tests, and CI/CD setup.

Plan sprints, write technical specs, and coordinate product launches with structured templates for A/B testing, go-to-market planning, presentation auditing, and retrospective analysis.

Evaluate machine learning models using metrics like accuracy, precision, recall, and F1-score to perform performance analysis, validation, model comparison, and optimization. Generate production-ready AI/ML code that includes validation, error handling, performance metrics, saved artifacts, and documentation.

Generate fast (<5min) smoke test suites in Jest-style JavaScript for critical paths like system health, authentication, and core features, then run them post-deployment via Playwright, curl, Bash scripts, or CI/CD to verify UI, APIs, and functionality.

Audit web pages and components for WCAG 2.1/2.2 accessibility compliance using axe-core, Playwright, Pa11y, Lighthouse, and more. Detect ARIA errors, keyboard navigation issues, color contrast violations, and screen reader incompatibilities, then generate markdown reports with prioritized fixes and code examples.

Analyze test coverage reports from Jest/nyc, pytest, Go test, and JaCoCo across JavaScript, Python, Go, and Java projects to identify untested code paths, branch gaps, low-coverage files, enforce thresholds, and generate detailed reports with targeted test recommendations.

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.

Generate test reports by parsing JUnit XML, Jest JSON, pytest results, and coverage data into Markdown/HTML formats with metrics, failures, slowest tests, trends, and CI annotations. Aggregate results across frameworks for summaries and exports in HTML, PDF, or JSON.

Validate API responses against OpenAPI and JSON schemas to ensure contract compliance, detect schema drift, and verify data integrity. Generate JSON Schema definitions, Ajv validators, Express middleware, tests, docs, and monitoring directly in Node.js, Python, or Java workflows.

Track regression tests across code releases by mapping git commits to pytest or Jest tests, tagging markers for suites, flagging coverage gaps, generating pass/fail reports with flaky detection, viewing history, and enforcing runs in CI/CD pipelines.

Run interactive penetration tests on web apps and codebases: scan HTTP security headers for CSP/HSTS issues, audit npm/pip dependencies for vulnerabilities, analyze code for secrets/injections with bandit, get severity-prioritized findings, fix suggestions, and JSON reports.

Implement property-based testing strategies across multiple languages and smart contracts to verify invariants like serialization roundtrips, idempotence, parsing, validation, normalization, and algorithms for stronger coverage than example-based tests.

Build and publish Chrome extensions with Manifest V3 while staying current with modern web development best practices, performance optimization, and new browser APIs

Build Vizro dashboards end-to-end: design layouts and visualizations, implement with Python and YAML, then automate end-to-end testing with Playwright.

Implement production-grade .NET patterns and practices for Akka.NET actor systems, ASP.NET Core, EF Core, Blazor, .NET Aspire, testing with xUnit/Playwright/TestContainers, CI/CD optimization, API design, and performance profiling via specialized Claude Code skills and agents.

Engineer production-ready ADK agents and multi-agent systems in Python, Java, or Go, generating clean code structures, unit tests, safe tools, and deployment automation for Vertex AI.

Generate read-only Markdown discrepancy reports validating messaging consistency—including tone, terminology, versions, and structure—across HTML-based websites (WordPress, Hugo, Next.js, React, Vue, etc.), GitHub repositories, and local documentation, with severity levels and fix suggestions.

Provision and manage isolated test environments using Docker Compose and Testcontainers for databases, caches, queues like PostgreSQL, MySQL, Redis, DynamoDB. Generate docker-compose files, env vars, seed data scripts, startup scripts, and cleanup code to enable reliable, reproducible testing without local setup conflicts.

Perform comprehensive SEO and Generative Engine Optimization (GEO) analysis, content optimization, and monitoring directly from Claude, pulling data from major SEO platforms (Ahrefs, Semrush, etc.) and integrating with cloud services (Cloudflare, Vercel), collaboration tools (Slack, Notion), and CMSs (Webflow, HubSpot).

Deploy specialized AI agents to synthesize research from academic papers, web sources, and GitHub repos with citations; generate API docs, OpenAPI specs, and SDKs; transcribe, analyze, and optimize podcasts; modernize legacy code across React, Python, Java; build and link knowledge graphs; orchestrate multi-agent pipelines for complex tasks.

Orchestrate a full BMAD agile workflow with role-based AI agents (PO, Architect, SM, Dev, QA) to build projects from descriptions. Handles repo scanning, interactive requirements and architecture design, sprint planning, automated coding with tests, QA validation, code reviews, and user approval gates for production-ready delivery.

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.

Orchestrate AI coding agents through a repeatable engineering workflow covering requirements, design, implementation, testing, code review, and security — with persistent memory and evidence-based verification.

Instruct Claude Code to automate browser tasks with Playwright: it auto-detects dev servers, launches a visible browser, runs E2E tests, fills forms, takes screenshots, validates responsive design and UX, handles login flows, checks links, and generates clean scripts in /tmp.

Automate development workflows by walking through code files line-by-line in VSCode or Vim, logging timestamped work sessions with file changes in daily Markdown, generating detailed issue specs staged in Git, engaging in adaptive Socratic quizzes for learning, and delegating UI validation tasks to a browser agent using Chrome DevTools.

Generate and execute comprehensive test suites for REST and GraphQL APIs directly from OpenAPI specs, automating request generation, schema/response validation, CRUD coverage, auth handling, error/performance checks, idempotency tests, with reporting in Jest, pytest, Supertest, or REST-assured.

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.

Design and execute chaos engineering experiments to inject failures like network latency, service crashes, resource exhaustion into Kubernetes clusters and Docker containers, validating distributed system resilience and recovery using tools like Chaos Mesh and AWS FIS.

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.

Run integration test suites for APIs, databases, services, queues, and files using real Dockerized dependencies without mocks. Automates full workflow: environment setup, database seeding, service orchestration, test execution with coverage reporting, and teardown cleanup. Select suites and configure environments via CLI flags.

Orchestrate complex test workflows across Jest, Vitest, pytest, Playwright, and Cypress with parallel execution, test sharding, dependency management, flakey retries, affected test selection, and result aggregation in GitHub Actions or GitLab CI. Generate optimized configs for CI/CD pipelines.

Generate realistic test data for users, products, orders, technical fields, and custom schemas to populate fixtures, factories, seeds, edge cases, and databases in JS/TS/Python/Ruby apps using Faker.js, Fishery, pytest fixtures, and factory patterns.

Create and manage snapshot tests for UI components and data using Jest, Vitest, or pytest to catch regressions. Analyze test failures with intelligent diff reviews, selectively update snapshots for intentional changes, validate and organize snapshot files, then generate detailed analysis reports.

Split CSV datasets into stratified training, validation, and test sets using custom ratios for ML workflows, generating production-ready Python code with validation, error handling, performance metrics, artifact saving, and automatic documentation.

Generate and run mock API servers from OpenAPI specifications to simulate stateful CRUD operations with realistic Faker.js data, latency delays, error conditions, and request recording—ideal for frontend testing and backend prototyping without a live server.

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

Perform consumer-driven contract testing with Pact (JavaScript, Python, JVM) and OpenAPI validation for REST, GraphQL, gRPC APIs to detect breaking changes, generate tests, and produce detailed reports integrable into CI/CD pipelines.

Fuzz test REST and GraphQL APIs using OpenAPI specs to detect crashes, vulnerabilities, edge cases, and unexpected behaviors with tools like Schemathesis, RESTler, OWASP ZAP. Generate test suites, security reports, and reproducible payloads for input validation and security auditing.

Run mutation testing on JavaScript, Python, Java, Go, C#, or Ruby codebases to evaluate test suite quality. Introduce code mutants with tools like Stryker, mutmut, PITest, or go-mutesting, check detection rates, identify coverage gaps, and generate reports with survival scores and improvement suggestions.

Test load balancing strategies by validating traffic distribution, health checks, failover, session persistence, and SSL on live NGINX, HAProxy, AWS ALB/NLB, GCP, and Kubernetes Ingress setups. Generate Jest test suites to verify these behaviors across backends.

Conduct professional security audits on code, infrastructure, and configurations. Identify OWASP Top 10 vulnerabilities, verify compliance with HIPAA, PCI-DSS, GDPR, and SOC 2 standards, and perform cryptography reviews to evaluate and strengthen your security posture.

Automate database testing workflows by generating test suites with data factories, transaction wrappers for automatic rollback, schema validation, assertions, cleanup, fixtures, migrations, integrity checks, and performance monitoring across PostgreSQL, MySQL, MongoDB, SQLite, Redis using Prisma, Drizzle, Jest, Pytest.

Generate test doubles—mocks, stubs, spies, fakes—for unit testing by analyzing code dependencies. Produces implementations, fixtures, example tests, and rationale. Works across JavaScript (Jest, Vitest, Sinon), Python (pytest, unittest.mock), Go (gomock), and more frameworks.

Generate realistic, relationally consistent test data and idempotent seed scripts by analyzing database schemas, respecting foreign keys, constraints, and data types with Faker libraries for dev/test environments across JS, Python, C#, Prisma, Node, and TypeScript.

Enforce strict TDD workflow: write minimal failing tests first for complex logic or public APIs, verify red phase failure, implement green-passing code without internal mocks, then refactor safely. Supports unit and integration tests with Jest.

Automate iOS simulator interactions — taps, swipes, multi-finger gestures, hardware buttons, keyboard input, and frame capture — entirely from the command line without opening Xcode, enabling scripted UI flows, smoke tests, and visual state verification.

Write, optimize, and publish blog content with AI-powered research, SEO analysis, multilingual translation, and AI citation readiness. Integrates Google APIs for performance data, generates schema markup, images, audio narration, and repurposes content across platforms.

Validate Claude Code plugin directories against the official Anthropic spec and Intent Solutions enterprise standards. Run structural checks on plugin.json, files, and permissions, plus content grading for SKILL.md and commands to ensure compliance during building, auditing, or marketplace preparation.

Write expressive, correct Gomega assertions in Go tests using Expect/Ω notation, synchronous and asynchronous (Eventually/Consistently) patterns, the full built-in matcher catalog, composite matchers for nested structs, custom matcher authoring, and sub-libraries for HTTP, streaming I/O, goroutine leak detection, and performance measurement.

Author, review, and optimize YARA-X detection rules for malware analysis using guided best practices for naming conventions, string selection, performance tuning, legacy rule migration, and false positive mitigation, with built-in linting and quality analysis.

Enforces Test-Driven Development by detecting the test framework, installing a reporter, and outputting test results. Blocks file writes with forbidden terms and enforces semantic rules via bash guards and LLM prompt checks.

Configure VSCode extensions to test APIs with httpYac including auth scripts and CI/CD workflows, monitor multiple dev server ports like Vite and Next.js in real-time, and deploy static sites via SFTP to Nginx servers with secure setups.

Refactor React, TypeScript, and JavaScript code to enforce frontend best practices: improve cohesion by grouping related files and constants, reduce coupling via composition, ensure predictability with unified returns and no side effects, and enhance readability by simplifying conditions and ternaries. Review git branch diffs against these principles.