Testing plugins

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

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.

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.

Empowers Claude with full-stack development expertise across multiple languages, frameworks, and cloud platforms, enabling code generation, debugging, architecture design, DevOps automation, testing, security audits, and project management workflows.

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 a strict test-driven development workflow with automated red-green-refactor cycles, test generation, code review, and coverage checks across multiple languages and frameworks.

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.

Automate browser interactions from the command line or AI agents: navigate pages, fill forms, take screenshots, scrape data, and test web applications using a fast, Rust-based CLI.

Develop production-grade, portable shell scripts with defensive programming, POSIX compliance, automated testing via Bats, and static analysis with ShellCheck—enabling reliable automation across multiple Unix-like environments.

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.

Automate browsers and run end-to-end tests with Playwright directly in Claude. Interact with web pages by clicking elements, filling forms, taking screenshots, generating traces, and executing testing workflows locally via npx subprocess.

Enforces high-agency, exhaustive problem-solving on AI agents using corporate PUA pressure tactics (P7-P10 engineer roles, PIP rhetoric, mama nagging, tsukkomi) with autonomous iterative development loops, agent team management, KPI tracking, and self-evolution metrics.

Provides 753 structured cybersecurity skills covering web security, penetration testing, digital forensics, incident response, threat intelligence, cloud security, and malware analysis. Each skill includes step-by-step procedures, tool commands, and detection rules for SOC analysts, penetration testers, and incident responders.

Run over 40 SEO analysis agents and skills from Claude Code—crawl any site, audit technical SEO, analyze backlinks and content quality (E-E-A-T), optimize for AI search (GEO), validate schema and sitemaps, track drift over time, and generate competitive briefs or strategic plans—without leaving the terminal.

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.

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.

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.

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, components, and user flows; migrate Cypress/Selenium suites; analyze test coverage; diagnose and fix flaky failures; sync results to TestRail; and run cross-browser tests on BrowserStack.

Send and receive Telegram messages, manage chats, and control bots directly from Claude Code.

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.

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.

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

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.

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.

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.

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.

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.

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

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.

Automatically reviews and fixes Claude Code skills through iterative refinement loops until they meet quality standards, with commands to control the improvement cycle and cancel sessions while preserving changes.

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.

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.

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

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.

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.

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.

Build production .NET backends with Akka.NET actors, Aspire orchestration, EF Core patterns, concurrency primitives, and Kubernetes clustering; run integration tests via TestContainers/Playwright; optimize performance/databases; analyze CRAP scores, benchmarks, and concurrency bugs using 61 skills and 11 agents.

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.

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

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.

Build and deploy Vizro dashboards end-to-end via a enforced 2-phase workflow: gather requirements, design layouts and visualizations in YAML specs, implement Python code from examples and schemas, then run Playwright E2E tests with browser automation.

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.

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.

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.

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.

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.

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.

Test web apps for cross-browser compatibility using Playwright locally across Chromium, Gecko, WebKit, and mobile viewports, or on real devices via BrowserStack, Sauce Labs, LambdaTest, Kobiton. Run interactive tests, scan JS/CSS risks, and generate reports with browser matrices.

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.

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.

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.

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

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Enforce a structured, repeatable AI-assisted SDLC workflow with memory, verification, and multi-agent coordination. Orchestrate agents through 8-phase feature development, enforce TDD, review code for security and quality, document codebases, debug systematically, and store reusable knowledge — all with evidence-based verification of results.

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.

Enforces Test-Driven Development by detecting your test framework, installing a reporter, and blocking file edits that don't follow TDD workflow.

Wrangling tabular data in CSV, TSV, Excel, JSONL, Parquet using qsv's 51 fast CLI commands via skills, agents, and MCP server. Profile stats, run SQL queries on Polars engine, join datasets, clean/validate/normalize, convert formats, generate charts/ontologies/reports, access BLS economic data, log reproducible sessions.

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.

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.

Generate UX research artifacts like personas, empathy maps, journey maps, interview scripts, usability test plans, and diary studies. Analyze qualitative data from interviews, card sorts, and observations into affinity diagrams, themes, jobs-to-be-done, insights, and prioritized opportunities. Run full research cycles or targeted syntheses.

Run full-spectrum SEO and GEO workflows from Claude: keyword research, content optimization for AI citations, technical audits, schema markup generation, rank tracking, backlink analysis, and campaign memory across sessions.

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.

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.

Accelerate AI-assisted development with 108 battle-tested Claude Code configs for coding standards, testing, security, deployment, and automation across Python, TypeScript, Go, Java, Swift, and more. Includes skills, commands, agents, and hooks for TDD, code review, API design, database migrations, and workflow orchestration.

Automate comprehensive project management: audit health and permissions, generate architecture/user docs and roadmaps, handle git workflows/PRs/releases, test UX/onboarding/responsiveness via browser, consult multi-AI models, and post team updates with feedback triage.

Classify issues, bugs, and security findings into S1-Critical to S4-Low severity levels with rationale, impact assessment, workarounds, and action recommendations. Score and rewrite marketplace plugin prompts, skills, and commands for improved clarity, safety, effectiveness, completeness, and conciseness.

Port existing Semgrep rules to target languages by generating YAML rule files and annotated tests, with applicability analysis and test-driven validation to expand coverage in polyglot codebases.

Generate original PNG and PDF visual art from textual design philosophies, producing museum-quality posters, art pieces, designs, and other static visual works on relevant creation requests.

Generate distinctive production-grade frontend UIs for components, pages, or full apps using React, Vue, HTML, CSS, and JavaScript, featuring bold aesthetics, unique typography, custom motion, and layouts that avoid generic AI-generated styles.

Audit local repositories for code health by analyzing complexity metrics, git churn, and test coverage gaps. Generate detailed reports with overviews, critical issues, warnings, prioritized refactor recommendations, and actionable steps to address technical debt hotspots.

Automate browser workflows with persistent page state to navigate websites, fill forms, capture screenshots, extract data, test web apps, handle logins, and execute multi-step tasks without losing context.