Testing plugins for Claude Code

Chrome DevTools for agents exposes Chrome browser automation, debugging, and performance analysis capabilities via an MCP server, using Puppeteer for reliable automation and Chrome DevTools for tracing and network inspection. The plugin lets AI coding assistants take screenshots, analyze performance traces, inspect network requests, and check console messages from a live Chrome instance.

agent-browser is a browser automation CLI that enables AI agents to interact with websites programmatically, including navigation, form filling, screenshot capture, data extraction, and task automation. It supports web apps, Electron desktop applications, and runs on Vercel Sandbox microVMs and AWS Bedrock AgentCore cloud browsers.

Localhost iMessage-style web chat interface for testing Claude Code without external services, supporting message replies, edits, and file uploads/downloads. The plugin provides a single-browser testing surface with no persistent history or authentication, designed for development and debugging of the channel contract.

This MCP server enables Claude to automate browser interactions using Playwright, supporting actions like taking screenshots, filling forms, and clicking elements on web pages. It provides end-to-end testing capabilities for automated browser workflows without requiring any external API keys.

This Playwright testing toolkit generates production-grade tests from specifications, fixes flaky failures, and migrates test suites from Cypress or Selenium—all via 3 specialized agents, 10 skills, and 55+ ready-to-use templates. Optional TestRail and BrowserStack integrations (manually enabled) enable test-case syncing and cross-browser reporting.

This standalone Agent Skill automates browser interactions and testing using Playwright, enabling test web pages and work with Playwright test files through CLI integration. It integrates directly with the Agent Skills runtime without requiring external API keys or dependencies.

This is a standalone Playwright CLI skill for coding agents that automates browser interactions, page testing, and web scraping through token-efficient command-line invocations rather than schema-heavy tool definitions. It includes two skills: one for general Playwright CLI browser automation and another for development workflows like dependency rolling and repository maintenance in the playwright-cli repository.

This is a standalone Agent Skill repo that provides three skills for evaluating and debugging Apify MCP server tools: bug-triage, creating-mcp-agent-evals (for Langfuse MCP agent evals of Apify tool families), and dig. The skill integrates with five MCP servers including the Apify MCP server, Figma, Storybook, and localhost to support tool evaluation and troubleshooting workflows.

dev-browser is a browser automation skill that lets coding agents control Chrome with JavaScript scripts, maintaining persistent named tabs across multiple calls for stateful workflows. The skill provides an accessibility-tree-based interface, real Puppeteer API support, and options to launch a new isolated Chrome profile or attach to an existing browser.

TestDino plugin connects Claude Code to Playwright test runs, CI/CD results, and manual testing workflows through a remote MCP server, enabling inspection of test failures, debugging of flaky tests, and creation of test cases in natural language. It supports test run analysis, case debugging, manual test management, release tracking, and audits without leaving the editor.

An official Flutter/Dart plugin that bundles 25 skills and an MCP server to teach AI agents domain expertise and best-practice workflows for building cross-platform applications from a single codebase. The skills cover testing, UI development, architecture, localization, routing, and API integration for mobile, web, desktop, and embedded projects.

This MCP server helps developers debug REST API failures by loading OpenAPI specs, ingesting HTTP logs, analyzing errors with root cause analysis, and generating reproducible test commands like cURL or fetch. The plugin includes a guided /debug-api command and an api-expert agent that provides severity assessment, fix suggestions, and support for common HTTP status codes.

Project Health Auditor is an MCP Server plugin that analyzes local repositories for code health through four tools: listing files with glob patterns, calculating cyclomatic complexity and health scores, identifying frequently-changed files via git churn analysis, and mapping test coverage gaps. It combines complexity metrics, change frequency, and test coverage to provide multi-dimensional insights into codebase health without requiring external API keys.

TDD Guard enforces Test-Driven Development principles by intercepting file edits and writes in Claude Code to block operations that skip tests or over-implement. It auto-detects your test framework and validates changes against TDD rules using hooks that run on tool use, session start, and user input.

brooks-lint performs AI code reviews against six decay-risk dimensions synthesized from twelve classic engineering books, annotating findings with citations, severity levels, and remedies. It offers six analysis modes (PR review, architecture audit, tech debt assessment, test quality, health dashboard, auto-fix) grounded in proven software engineering principles.

This Agent Skill teaches developers how to set up, architect, and write end-to-end UI tests for Flutter apps using Patrol, an open-source testing framework that handles native OS interactions beyond Flutter's standard integration_test capabilities. Three focused skills cover initial Patrol setup in Android, organizing test suites with LeanCode's modular architecture pattern, and writing individual Patrol E2E tests with proper widget keys and native dialog handling.

This plugin provides web performance audits by integrating Core Web Vitals metrics and Chrome DevTools analysis into Claude workflows. It includes a skill and MCP server for analyzing page performance and generating optimization recommendations.

Reticle is a Claude Code plugin that installs a skill and registers an MCP server enabling agents to visually inspect, interact with, and assert against a running web application from within the development environment. It provides capabilities to look at the app's current state, perform actions on it, observe changes, and validate behavior against expectations.

protect-tests is a PreToolUse hook that prevents agents from making test suites pass by deleting, renaming, or skip-disabling tests instead of fixing code. It detects and blocks removal patterns across pytest, unittest, jest/mocha/vitest, Go, JUnit/TestNG, NUnit/MSTest, RSpec, and Rust, with three configurable safety levels while always allowing new tests and legitimate test edits.

Allium is a specification language and Claude Code plugin that maintains a formal behavioral spec alongside code, using agents to elicit requirements forward from intent or distill them backward from existing code, then generates tests and catches design gaps through CLI validation. It closes the agentic coding loop by providing a persistent, formally-verifiable contract between spec, tests, and implementation that survives across sessions.

This plugin bundles 13 agentic skills for Qt C++ and QML development, including code review, documentation generation, testing, and UI design workflows, with a live Qt API documentation MCP server for contextual lookups. The skills combine deterministic linting with AI-powered deep analysis across memory safety, thread handling, performance, and QML binding correctness.

AgentOps provides DevOps discipline for AI coding agents through behavior-driven planning, shared domain language, and independent validation using a Plan-Implement-Validate loop. It includes 30 reusable skills, 4 agents, and tool-call guards to help agents produce consistent, well-tested work aligned with stated intent.

EvanFlow is a TDD-driven orchestration system with 16 skills and 2 custom subagents that guides software development from brainstorm through implementation via checkpoints (design approval, plan approval, post-iteration review), ensuring you stay in control without auto-commits. The loop runs vertical-slice TDD per task, supports parallel coder/overseer review for independent units, and stops short of every git operation to await your direction.

mcp-devices provides mobile device automation CLI functionality for Android, iOS, HarmonyOS, Aurora OS, and Desktop platforms through an MCP server integration. It enables developers to automate interactions and control across multiple mobile operating systems without requiring external API keys.

This Claude Code plugin integrates CodSpeed, a performance measurement and benchmarking platform, providing capabilities to measure code performance with <1% variance using CPU simulation and detect performance regressions. It exposes CodSpeed functionality through an MCP server connection, enabling performance optimization analysis directly within Claude Code.

This Claude Code plugin integrates the Antigravity CLI (Gemini) as a collaborating sub-agent, routing deterministic, high-volume work (scaffolding, test generation, migrations, web/Vertex AI Search) to Gemini while Claude handles requirements, architecture, verification, and review. Hybrid agentic engineering reduces token costs by routing cheaper bulk work to Gemini while keeping the hard judgement calls on Claude.

This plugin implements a two-loop skill pipeline that catches failures during Claude Code sessions through an inner loop of planning, intent-framing, context-surfacing, verification, and self-healing, while an outer loop learns from recurring patterns to promote permanent rules and regression tests. It hooks into session lifecycle and tool-use events to provide active runtime recovery, including automatic remediation when commands, tests, builds, or external services fail mid-task.

This plugin provides a specialized Playwright agent with MCP server integration for automating browser interactions and control workflows. It includes two skills and one MCP server to support best-practice browser automation patterns.

Superpowers Symfony is a skill library with 44 expert skills, 7 specialized agents, and 13 commands providing version-accurate Symfony expertise for coding agents, covering API Platform v4, Doctrine ORM 3, TDD with Pest & PHPUnit, Symfony Messenger, security/voters, and DDD/hexagonal architecture patterns. It integrates with Claude Code, Codex CLI, Grok Build, OpenCode, Cursor, Windsurf, GitHub Copilot, Gemini CLI, and aider through a SessionStart hook that runs runtime detection to adapt guidance to the target Symfony version and environment.

xclaude-plugin is a modular iOS development automation suite with 8 workflow-specific MCP servers (600–3500 tokens each) providing 23 tools for Xcode, Simulator, and IDB—enabling selective activation to keep context lean. It includes 8 procedural skills for xcode-workflows, simulator-workflows, ui-automation-workflows, accessibility-testing, ios-testing-patterns, crash-debugging, performance-profiling, and state-management.

Caliper is a lightweight evaluation harness for agent skills that measures success rates by running specs repeatedly against Claude Code, Codex, Pi, or Hermes. It supports three types of checks—LLM-judged expectations, Python assertions, and skill activation assertions—and can ablate skills to measure their marginal contribution.

A Claude Code plugin delivering 15 best-practices skills and a Flutter reviewer agent for accelerated Dart/Flutter development, including accessibility, animations, testing, BLoC, theming, security, and an autonomous quality-gate loop that drives code to green. The plugin requires the Very Good CLI and Dart toolchain, enforces standards via pre/post hooks, and includes a specialized reviewer agent for security and accessibility auditing.

The VGV AI Flutter Plugin is a Claude Code plugin with 15 best-practices skills covering Flutter and Dart development (accessibility, animations, BLoC, testing, theming, navigation, security, internationalization, layered architecture, license compliance, UI packages, SDK upgrades, and more) plus an autonomous quality-gate loop that drives code analysis, formatting, testing, and coverage to green. It runs locally via bash, dart, and the very_good CLI without requiring API keys or external paid services.

cc10x is a specialized routing harness for Claude Code that distributes requests across eight specialist subagents (build, debug, review, plan, QA, orient, triage, codebase health) with gated workflows, persistent artifacts, and memory preservation. The plugin coordinates multiple agents through hooks and guardrails to ensure fail-closed operation and honest test reporting with fresh-context verification.

This Claude Code plugin enables an autonomous review loop where Claude and code collaborate with adversarial pushback to plan features or audit code interactively in a single window. It provides 6 commands and a stop hook for managing the review cycle.

The atdd plugin enforces Acceptance Test Driven Development methodology by translating domain-language acceptance criteria into executable Gherkin specifications and generating a project-specific test pipeline with dual acceptance and unit test streams. It integrates with the broader Disciplined Agentic Engineering (DAE) framework to maintain deterministic guardrails and audit trails throughout the feature development lifecycle.

NLPM scores, checks, fixes, and tests natural-language artifacts (skills, agents, commands, rules) across Claude Code, Codex CLI, and Antigravity with tier-aware validation and manifest-vs-disk consistency detection. It provides eight slash commands for linting NL artifacts, a standalone Python validator for CI/pre-commit pipelines, and a self-evolving GitHub Actions auditor that harvests teaching examples from clean repos.

This plugin provides a Playwright MCP server that integrates browser automation and QA testing capabilities, exposing tools to navigate pages, take screenshots, interact with elements, and fill forms across Chromium, Firefox, and WebKit. It requires npx to run the Playwright-based MCP server for automated testing and web interaction workflows.

Superpowers Optimized is an agentic development framework for Claude Code that adds automatic 3-tier workflow routing, TDD enforcement, 10 proactive safety hooks, and cross-session memory to enforce disciplined coding practices. It features built-in security review with OWASP checklists, adversarial red-teaming, and systematic debugging across 24 specialized skills.

EvalView is a snapshot testing framework that records AI agent behavior (tool calls, parameters, order) and detects regressions via baseline diffing, supporting LangGraph, CrewAI, and multiple LLM providers. It integrates with CI/CD pipelines to gate PRs on behavioral changes and works offline for deterministic tool-sequence diffs.

Surfpool is a complete development environment for Solana programs that replaces solana-test-validator with mainnet forking, cheatcodes, and Infrastructure as Code capabilities. It provides the fastest way to develop and test Solana smart contracts with Surfpool Studio included.

This Claude Code plugin verifies changes work by driving the real system the way a user does, using acceptance criteria derived from your plan rather than the implementation. It boots your full stack, runs browser and API tests against real infrastructure, and generates a detailed report with evidence for every check.

ALDC is an AI-native development toolkit for Microsoft Dynamics 365 Business Central offering 10 agents, 15 knowledge skills, and TDD-driven workflows for extension-only development with code review, event-driven architecture patterns, and human-in-the-loop gates. It includes specialized agents for architecture, development, test-driven delivery, pre-sales estimation, and agent building, plus MCP servers for AL symbol resolution and documentation lookup.

accesslint provides five web accessibility skills for Claude Code to audit WCAG 2.2 conformance, scan pages with rule engines, and run keyboard and screen-reader checks. It includes an MCP server and uses npx to perform hands-on accessibility testing, fixing violations, and catching regressions in CI pipelines.

metro-mcp is an MCP server for debugging and automating React Native/Expo apps via Metro's Chrome DevTools Protocol, offering tools for console logging, network inspection, component tree analysis, UI automation, and test recording without requiring app code changes. It supports iOS Simulator and Android devices, provides a CDP proxy for simultaneous Chrome DevTools access, and includes plugins for Redux inspection, React Navigation state, performance profiling, and deep link testing.

MLflow Skills equips coding agents with observability, debugging, and evaluation capabilities for GenAI applications through tracing, trace analysis, and quality measurement. The plugin includes an optional UserPromptSubmit hook that auto-suggests relevant skills when MLflow-related patterns are detected in prompts.

Subtext integrates Fullstory session replay into Claude Code, allowing agents to review recorded user sessions for debugging, reproduce bugs, and manage privacy rules for captured data. The plugin connects via MCP servers to Fullstory's hosted service, enabling read-only session analysis plus write capabilities for privacy rule management.

Claude Universe provides five integrated systems—Navigate, Diagnose, Shield, Survey, and Timewarp—that enable systematic code analysis for PR readiness, test authoring, security review, architecture tracing, and code evolution detection. It combines 6 MCP servers for deterministic pattern matching and dependency analysis with 20 Claude-guided commands and 6 autonomous agents that work across any language.

CodeScene Code Health analysis plugin for Claude Code provides AI-friendly tools to review, refactor, and safeguard code quality through Code Health scores, hotspot detection, and ownership routing. It integrates via MCP with support for OAuth, personal access tokens, and on-prem instances, offering both standalone analysis and cloud/on-prem project-level insights.

Forge is a native Claude Code plugin that automates spec-driven development through a five-phase autonomous loop: brainstorming acceptance criteria, planning task DAGs, executing tests-first in parallel git worktrees, reviewing and verifying code, and backpropagating spec gaps. State persists on disk in .forge/ to survive context resets and crashes, allowing a single one-line idea to produce reviewed, tested, and committed code without manual intervention.

This plugin provides full API lifecycle management within Claude Code, including collection syncing, client code generation, API discovery, testing, mock servers, documentation, and security audits—all powered by the Postman MCP Server. It includes an agent that analyzes APIs for AI agent readiness across 8 pillars and covers OWASP Top 10 security checks.

BioNexus is a pre-submission review layer that validates epistemic claims in AI-assisted multi-donor single-cell differential expression analyses, locating evidence gaps and recommending repairs before manuscript submission. It separates computational permission from claim ceilings, permitting valid computations while capping claims to what the evidence actually warrants using context-conditioned rules derived from established statistical and biological principles.

GitGud periodically assigns manual coding challenges during Claude Code and Cursor sessions to keep developer skills sharp, featuring gamification through streaks, achievements, and a configurable skip system. The plugin hooks into prompt submission to categorize tasks by context (security, API, database, debugging, testing, architecture, frontend, or general functions) and stores persistent progress locally in `~/.gitgud/`.

React Native HiFi provides a comprehensive agent workflow for React Native and Expo development, featuring 39 skills that guide agents through design refinement, TDD-driven implementation plans, subagent-driven development, and specialized patterns for native UI, testing, and debugging. It integrates production-grade techniques from Software Mansion and Callstack, emphasizing red/green TDD, code review workflows, and autonomous multi-agent collaboration for extended development sessions.

The fuse-php plugin provides an expert agent and six specialized skills for modern framework-agnostic PHP development (PHP 8.5/8.4), covering libraries, Symfony components, Slim apps, and CLI tools with PER Coding Style 3.0, PHPStan static analysis, and SOLID principles. It activates automatically when a composer.json is present without an artisan file, deliberately excluding Laravel projects which are handled by the fuse-laravel plugin.

fuse-react is a Claude Code plugin offering an expert React 19 developer agent with skills for modern React patterns (React 19 hooks, TanStack Router/Form), state management (Zustand, Jotai), component frameworks (shadcn/ui), testing (Vitest, Testing Library), and internationalization (react-i18next), all built around SOLID principles and modular architecture. It activates automatically when working with React projects and provides guidance on file-based routing, type-safe forms with Zod validation, and comprehensive testing practices.

Expert Swift 6 and SwiftUI development plugin covering all Apple platforms with specialized skills for architecture, concurrency, data persistence, and testing. The plugin includes an intelligent agent that activates relevant expertise when you mention iOS development, navigation patterns, async/await, performance optimization, or platform-specific features.

This Claude Code plugin enforces quality gates for 1C:Enterprise (BSL) development by blocking session completion until code-quality checks pass, analyzing changes across three axes (volume, code archetypes, complexity) to determine review depth. It produces human-readable findings and machine-readable evidence trails showing what was checked, what was skipped, and coverage across static analysis, development standards, SOLID/GRASP architecture, metadata XML integrity, and file hygiene.

SFAgent Tools is a Claude Code plugin that automatically generates and executes comprehensive test scenarios for Salesforce Agentforce agents, running headless conversations, validating behavior against business rules, and producing scored reports with improvement recommendations. It reads an agent's configuration, designs test cases for topics and edge cases (including guardrail testing), conducts real multi-turn conversations, and delivers structured evaluation results without manual YAML setup.

The Opik plugin automatically traces Claude Code sessions and nested agent calls to Opik, an open-source LLM observability platform by Comet, capturing tool use, thoughts, and responses as spans. It provides built-in skills for instrumentation, diagnosis, testing, evaluation, and optimization of AI applications, with support for frameworks like OpenAI, Anthropic, LangChain, and CrewAI.

This Claude Code plugin provides three skills for ROS 2 Jazzy development on Ubuntu 24.04: package creation/testing with verified builds, live runtime diagnostics for publisher/callback/TF issues, and micro-ROS guidance. It runs executable workflows and checks directly in the development environment with no external API dependencies.

pulser is a SKILL.md linter that diagnoses Claude Code skills against 8 rules derived from Anthropic's published principles, classifies skill types, generates prescriptions, and runs eval tests for regressions. It runs conversationally in Claude Code or from the terminal, with auto-fix capabilities and a hospital-style TUI monitor.

This Claude Code plugin enforces Go language coding standards and best practices while preventing accidental modifications to generated Go files marked with the standard "Code generated" header. It provides guidance on Go conventions, table-style tests, and language features through a PreToolUse hook that blocks edits to auto-generated code.

This plugin detects newly added type ignores and lint suppressions across multiple languages (TypeScript, Python, Go, Rust, Ruby, etc.), then automatically fixes the underlying type errors or replaces unfixable ignores with explanatory TODO comments. It runs automatically via a PostToolUse hook when Claude adds an ignore, and can also be invoked directly with the `/fix` skill for codebase-wide cleanup.

This Claude Code plugin provides a Java quality toolkit with three integrated agents covering security (OWASP compliance), performance optimization (N+1 queries, memory, threading), and testing frameworks (JUnit 5, Mockito, Testcontainers) for Java 8+ projects. It operates through shell commands and hooks to analyze and improve code quality during development workflows.

Postman for Agents provides 13 skills to bootstrap Postman setups, mock APIs before implementation, run collection and governance checks, monitor live endpoints, deploy and debug Postman Flows, and publish generated API documentation directly from your coding agent. The plugin runs shell commands and includes an MCP server integration that connects to Postman's hosted infrastructure for tool calls.

This Claude Code plugin automatically validates that tool outputs match the claims Claude makes about them, catching discrepancies like misquoted code and incorrect file references. It operates as a post-tool-use hook that inspects the results of Claude's tool calls to ensure accuracy and consistency.

This Claude Code plugin connects to the Kobiton mobile testing platform, enabling you to manage devices, upload apps, run automation sessions, and view test results directly from your AI coding assistant. It integrates with multiple AI assistants including Claude Code, GitHub Copilot CLI, Gemini CLI, Codex CLI, and Cursor, and provides skills for interactive device testing and automation test execution.

tailtest automatically generates and runs test scenarios whenever Claude Code edits a file, using production-shaped rules (R1-R15) and your existing test runner—no setup or prompting needed. It surfaces test results back to Claude in the same turn via hook-based integration, with optional adversarial mode to hunt edge cases across Python, TypeScript, JavaScript, Go, Ruby, PHP, Java, Kotlin, C#, and Rust.

Design Library is a Claude Code plugin bundling 58 brand design systems (Stripe, Linear, Vercel, Figma, Google, Anthropic, and more), 7 curated design skills covering UI/UX, web guidelines, accessibility (WCAG 2.2), motion design, visual taste, and Lighthouse/Core Web Vitals audits, plus a bundled Playwright MCP for in-browser UI verification. The plugin auto-detects your project type and activates relevant skills via slash commands and natural language integration.

This standalone Agent Skill repo provides 10 skills covering code review, testing, deployment, and quality checks through babysit, dlc, git-ops, perf, pr-check, pr-validity, quality, security, test, and update-review-checklist capabilities. The skills are designed to integrate into development workflows without requiring external API keys or tool dependencies.

Meticulous agent skills enable Claude Code and other AI assistants to review visual regression test runs, investigate replays, debug diffs, and run tests on the Meticulous automated testing platform. The plugin includes seven domain-specific skills covering test review, test execution, iterative development, session simulation, and CLI utilities, with automatic connection to the hosted Meticulous MCP server.

Iris is an open-source MCP server that scores agent output for quality, safety, and cost using 13 built-in evaluation rules, PII detection, prompt injection detection, and real-time cost visibility with a web dashboard. It works transparently with any MCP-compatible agent (Claude Desktop, Cursor, VS Code, etc.) by logging hierarchical trace trees, flagging safety failures, and enforcing budget thresholds without requiring code changes.

The claude-crap plugin enforces test-driven development by wrapping Write/Edit/Bash tool calls with PreToolUse and PostToolUse gates that verify code quality metrics (CRAP index, Technical Debt Ratio, tree-sitter AST) and SARIF 2.1.0 reports before allowing code writes. It prevents functional code from being written until adequate test coverage exists, backed by 4 skills, 1 MCP server, and hook handlers for SessionStart, PostToolUse, PreToolUse, Stop, and SubagentStop events.

This Claude Code plugin implements a persistent-memory and runtime-discipline layer that remembers corrections, grounds edits in verified facts, and transforms fixes into reusable instincts through the Mulahazah engine, built on 7 Laws of AI Agent Discipline. It ships with 28 bundled skills, 14 hooks, 4 agents (code-reviewer, security-auditor, test-engineer), 29 commands, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.

An AI-native E2E browser test runner that lets you write tests in plain JSON without code, powered by 17 MCP tools, 3 agents, and 4 slash commands. It supports parallel execution across multiple Chrome drivers (browserless, CDP, Lightpanda, Obscura, Steel), 28+ built-in actions, visual verification, network debugging, and a real-time dashboard.

Frank is a Claude Code plugin that enforces evidence-based agent replies by requiring concrete verdicts with proof and verification receipts after code edits. It uses local hooks to observe PostToolUse and session events, comparing final agent messages against a ledger of verification commands to prevent unsupported claims.

Ripplo enforces end-to-end validation of agent-built apps by guiding the agent to automatically generate and maintain user journey workflows as typed, state-aware sequences. It uses hooks to block work until workflows pass, and provides interactive replays to prove exactly what happened during each workflow execution.

This plugin provides 9 agent skills for the Truesight AI quality platform, enabling workflows to score inputs, build live evaluations, analyze errors, and manage the review loop through natural language commands. It connects via MCP server to api.truesight.goodeyelabs.com and includes specialized skills for synthetic data generation, trace evaluation, error analysis, and custom annotation interfaces.

dx-aem provides AEM-specific agents and skills for component verification, dialog inspection, screenshot capture, and QA automation across Adobe Experience Manager projects. It bundles AEM MCP and Playwright MCP servers to enable JCR content queries, component dialogs, page management, and browser automation—all integrated into the dx-core development workflow plugin.

llmprobe is a CLI tool for synthetic monitoring of LLM inference endpoints that measures TTFT, latency, throughput, and error rates across OpenAI, Anthropic, Google, Azure OpenAI, AWS Bedrock, and OpenAI-compatible servers. It runs as a single binary with zero external SDKs and can be deployed as a one-off health check, continuous monitor, or CI gate using the included MCP server.

sonmat is a Claude Code verification plugin that injects structured doubt and reasoning checks (guard/inspect/witness/punch/devil/scribe) into agent workflows and subagents. It uses markdown discipline blocks, automated hooks at session start, and persistence layers to surface verification reasoning and prevent silent failures.

An expert assistant plugin for PactFlow and Pact contract testing, featuring consumer-driven contract validation, provider verification, and specialized agents for reviewing and generating pact tests. The plugin includes OpenAPI spec parsing capabilities and integrates shell-based tools for configuration checking and deployment validation.

This plugin ships the gameface-devtools-mcp MCP server, enabling Claude Code agents to evaluate JavaScript, take screenshots, inspect and manipulate the DOM, and set breakpoints in any running Coherent Gameface UI via Chrome DevTools Protocol. It includes two skills that teach agents how Gameface differs from a browser and provides field-verified procedures for reliably driving Gameface UIs.

Green Keeper automatically fixes failing tests and type errors with minimal changes while enforcing a "no fake-green" rule that prevents weakening tests, silencing errors, or cheating with type-widening. It provides `/green` and `/cover` commands plus a Stop hook that blocks you from leaving red that your turn introduced, running entirely locally with zero external dependencies.

Nopekit is a Claude Code plugin for exploring and validating physical designs—hardware, enclosures, PCBs, boats, thermal systems, and more—by extracting design claims and gating them with validators that can fail and report what is verified versus assumed. It uses the Grounding by Falsification approach to wrap AI-generated proposals with trusted checks (math, physics, simulations) so you can track evidence and keep designs grounded as they evolve.

quiz-me gates code changes by requiring developers to pass an interactive quiz where Claude tests their understanding of the root cause and fix before implementing changes. The plugin uses hooks and a skill to investigate issues, generate quiz questions, and validate developer knowledge before proceeding.

This standalone Agent Skill wraps xcodebuild and swift CLI tools to automate building, testing, and archiving Swift packages and Xcode projects for Apple platforms (iOS, macOS, tvOS, watchOS, visionOS). It discovers available schemes and targets, manages simulator destinations, and integrates with Xcode workflows without requiring external API keys or services.

sniff is an autonomous QA scanner that opens your running app in a real browser, simulates user interactions, and detects 12 classes of bugs (broken pages/links, console/network errors, broken forms, state loss, placeholder data, loading/error states, responsive and accessibility issues) with reproduction steps and fixes. It requires no API keys and runs locally via npx, generating terminal, HTML, and JSON reports with severity levels and confidence scores.

Supervisor is a 27-agent quality-control layer for Claude Code that researches externally verifiable claims, delegates work to specialized experts, runs tests, and enforces a final release gate before delivery. It includes independent reviewers, anti-hallucination verification, adversarial red-teaming, and coding/frontend specialists to catch outdated docs, fabricated APIs, broken code, and unsupported claims before they reach users.

V-Bounce is an AI-native SDLC orchestrator that coordinates 12 specialized agents through a unified software development lifecycle including requirements analysis, design, unified TDD implementation, code review, and deployment with per-phase quality gates and state management. The agent-first architecture uses explicit input/output contracts, tech-aware context injection, and multi-layer quality assurance across feature, bugfix, hotfix, and change request workflows.

This Claude Code plugin provides a verification gate for AI-generated work by anchoring goals into versioned run files and spawning independent validators to prove correctness before allowing closure. It operates via slash commands (`/a:run` and `/a:setup`) with a bundled CLI tool that runs over Bash, requiring no external APIs or MCP servers.

This Claude Code plugin generates A/B testing infrastructure and analysis tools using an MCP server and a single skill. It requires npx for execution and supports tiered usage from 50 free daily requests up to unlimited enterprise access.

This plugin generates WCAG compliance audit reports to help ensure web accessibility standards are met. It includes an MCP server and skill that runs accessibility checks using standard tooling.

This plugin generates accessibility tests following WCAG standards, automating test creation for compliance verification. It includes 1 skill and 1 MCP server, requiring only npx as an external tool with no third-party API keys needed.

api-forge generates comprehensive API test suites from OpenAPI specs, creates mock servers for development and integration testing, and benchmarks endpoint performance with features like response time and throughput measurement. Advanced contract testing for catching breaking changes across microservices is available in the Pro tier.

Bearpaws enforces adaptive engineering discipline for Claude Code by automatically escalating risk-based proof requirements—pinned tests, failing-first approach, and independent code review—for high-impact changes while keeping routine work lightweight. It includes 15 reusable skills for TDD, debugging, planning, and parallel execution, plus a Stop hook that blocks incomplete elevated-risk replies until a risk receipt and review are present.

The browser plugin provides unified browser automation through a lightweight agent-browser for exploration and Retina recording via Playwright on a shared Chrome session. It integrates 2 agents and 3 skills to enable high-fidelity browser interaction and visual documentation.

claude-damn is a composable skill library and opinionated harness for Claude Code that ships 61 skills built from modifier families (super/duper/cat/tdd), expert-review workflows, cost tracking, checkpoint lifecycle management, and a PreToolUse hook that guards against inline multiline scripts. It layers on top of the superpowers plugin and provides granular permission guards, CLAUDE.md project rules, and support for isolated git worktrees and parallel subagent execution.

This Claude Code plugin provides testing and deployment tools for iPhone Duo apps, including duo-lint for fold-aware linting, simulator tests, and a /duo-audit command for comprehensive app audits. It integrates via a PostToolUse hook to catch fold-related issues during development workflows.

Hats is a BDD-driven AI development team plugin that orchestrates five specialized roles (Manager, Designer, CTO, QA, Developer) in a sequential workflow, using Gherkin specs and role-based file permissions to guide implementation from planning through testing and code delivery. The plugin enforces role isolation through hooks and bash-audit guards, manages task workflows with state gates, and maintains a shared knowledge base across team handoffs.

Maps what a code change touches and what reaches it—callers, routes, scheduled tasks, queued jobs, event listeners, test coverage, data contracts—by scanning the diff and verifying references with a read-only analyst agent. Produces a factual impact map in markdown and JSON, with no severity judgment or verdict.

karellen-jdb-mcp is an MCP server that enables Claude Code to attach to running JVMs and debug using JDB with breakpoints, expression evaluation, thread inspection, and class introspection. The plugin includes an exception detection hook that suggests JDB when Java stack traces appear, a guided `/karellen-jdb-mcp:jdb-debug` skill, and an autonomous `jdb-investigator` agent for investigating Java exceptions and deadlocks.

LLM App Hardener is a repo-native toolchain that scaffolds eval suites, red-teams for prompt injection, hardens structured-output reliability, and audits token cost by riding promptfoo/DeepEval/Pydantic rather than replacing them. It detects your LLM SDK and framework first, then applies patterns grounded in real file:line evidence across prompts, schemas, and call sites.

This plugin enforces a verification gate that prevents Claude Code from finishing a turn after code edits until tests, builds, or lints have passed. It automatically detects verification commands (npm scripts, pytest, Go, Cargo, Maven, Gradle) and blocks agent completion if no verification has run since the last edit or if the latest check failed.

qa-cube is a QA test-session engine that orchestrates manual and automated testing end-to-end, with a manager and subagents reading tracker tasks, planning test rounds, filing findings, and writing autotests in your project's declared language. It stores sessions, generates business-language reports for tracker integration, and conducts retrospectives that improve its own instructions.

This MCP server acts as a WebSocket proxy that captures Reactotron debugging data from React and React Native apps, exposing tools to read logs, inspect state, monitor network requests, and run custom commands. The proxy forwards traffic to the Reactotron desktop app while making all captured messages available to Claude and other AI assistants through MCP tools and resources.

A Claude Code plugin that detects regression patterns in code changes by scanning repository history for undone fixes, re-introduced reverted code, loosened tests, and missing partner files. An agent reviewer reads each identified fix or revert commit with full diffs to validate findings, with the scan running only when relevant history exists.

A plugin that keeps codebases healthy by injecting nine skills at meaningful moments—orientation, docstrings, file size, documentation freshness, test coverage, commit messages, and pre-commit verification. It uses a SessionStart hook to bootstrap the agent with discipline rules that auto-trigger during substantive changes rather than on every keystroke.

Turns code-review findings into executable tests by launching a test-writer agent per finding that writes minimal tests in the repository's own conventions, runs them, and reports whether they reproduce the defect or cover new behavior. A hook confines the writer to test files only, preventing it from modifying source code.

This plugin provides a WCAG-EM accessibility audit workflow that guides users through scoping, evaluating, reporting, remediating, and retesting web content with conformance scoring. It integrates six skills and a phase-gate system to systematize the accessibility compliance process from assessment to remediation.

Agentiqa is an AI-powered testing plugin that explores web and mobile apps like a real user to find visual bugs, logical issues, UX problems, and accessibility violations with reproduction steps and media artifacts. It runs both as an interactive agent skill in Claude Code or Cursor and as a non-interactive CI step with saved test plans.

Emperor Time is a language-agnostic, host-agnostic coding skill that guides AI agents through a rigorous six-phase SDLC workflow (dowse, require, design, build, verify, deliver), ensuring every token spent produces verified value. It runs natively in Claude Code and Kimi CLI via the Agent Skills format, with adapters for Codex CLI, Copilot CLI, opencode, Ollama, and open-weight models.

The endform plugin integrates Endform's Playwright test execution service into Claude Code, allowing agents to run test suites in parallel up to 10x faster and identify failing, flaky, or slow tests. The plugin provides skills and an MCP server to help debug and quarantine problematic tests directly within the agent workflow.

flutter-marionette enables runtime interaction with live Flutter debug apps through the Marionette MCP server for AI-driven UI exploration, smoke testing, and debugging without writing test files. The plugin includes setup guides, widget configuration references, and manages the MCP connection to the Flutter VM Service.

This plugin provides a skill for scaffolding GitHub Actions, writing BATS tests, and preparing Marketplace releases with TDD workflow and signed commit patterns. It enables developers to create action.yaml configurations, run shell-based tests, and manage versioning for GitHub Actions distributions.

This Claude Code plugin provides three Go development skills—implementing, testing, and code reviewing—with automatic go tool permissions deployed via the SessionStart hook. It requires bash and focuses on TDD practices using standard Go testing libraries.

MPP Inspector gives Claude full visibility into HTTP 402 payment challenges, endpoint discovery, pricing comparison, and payment flow validation for Machine Payments Protocol endpoints directly from the editor. It exposes five MCP tools, slash commands, and a built-in skill covering challenge parsing, payment methods (Tempo, Stripe, Lightning, Solana, Card), and receipt validation.

Phyll walks through your AI-built app as a first-time user would, collecting screenshots and interaction data to identify UX anti-patterns like excessive form fields, template defaults, and accessibility issues, then generates a detailed report with fixes. The plugin runs in Claude Code using your own plan with no additional AI token charges, and includes a source scanner, browser, and review engine.

PRISMA is a verification method for Claude Code agent work, implemented via five skills and eleven hooks that enforce mechanical gates across five lanes of review before code can be pushed. The system uses independent verification routes to test claims without allowing the agent to grade itself, requiring only shell tools like jq and python with no external services.

This Claude Code plugin provides three skills for Python development: implementing concise code to specification, writing tests with pytest and Hypothesis, and conducting focused code reviews. It deploys uv permissions via a SessionStart hook to enable tool access when uv is detected.

This Claude Code plugin implements a comprehensive QA methodology for browser functional testing, enabling the qa-engineer agent to design test plans, execute tests via Playwright, and automatically codify reproducible test scripts with structured evidence validation. All artifacts (test files, junitxml reports, catalog indexes) are locked into the session directory via qa-flow.sh, with mechanical enforcement through Stop/PreToolUse/PostToolUse hooks that prevent incomplete test execution.

The receipts-check plugin gives Claude a `prove-fix` skill that validates test coverage by running tests twice—once with the fix and once with code reverted—to ensure added or edited tests actually fail without the change and pass with it. It supports pytest, vitest, and jest, requires only Node.js 20+ and git, and offers an optional Stop hook to prevent Claude from finishing until changed tests demonstrate proof of the fix.

This Claude Code plugin provides three Rust-focused skills: implementing concise Rust code to specification, writing tests using TDD practices with cargo test and property-based testing, and performing focused code reviews. It automatically deploys cargo permissions via the SessionStart hook when Rust is detected.

spec-flow is a multi-agent pipeline for Claude Code that enforces spec-driven development by gating feature shipping on test execution proof that every requirement is covered, using an external verification loop that runs lint, tests, and requirement traceability checks outside the model. The workflow progresses through free-text requirements, signed-off specs, milestone-based plans, reviews, and staged implementations, with hooks that block advancement until all gates pass.

TDAD is an Agent Skill that teaches AI coding agents to use test-driven development by building a code-test dependency graph and running only the impacted tests before submitting patches. Evaluated on SWE-bench Verified, it reduced AI-introduced test regressions by 70% compared to baseline, supporting Python, JavaScript/TypeScript, Go, Java, Rust, and Dart.

This plugin runs your project's test coverage analysis and gates it against a configurable threshold, with support for pytest-cov, nyc/c8, and Go's built-in coverage tools. A PostToolUse hook offers non-blocking re-check nudges after source edits, while the /coverage-gate command provides explicit PASS/FAIL reporting for CI integration.

test-guardian runs your project's fast test suite automatically after Claude edits files, surfacing regressions immediately with a non-blocking pass/fail signal. It auto-detects your toolchain (npm, pytest, make, go test) and provides both automatic PostToolUse hooks and a manual `/test-guardian` command.

TestMesh is an MCP server + 9 skills for writing and running end-to-end integration tests across HTTP, databases, Kafka, gRPC, WebSocket, and more using YAML-based test definitions. It provides a CLI tool and dashboard for executing multi-protocol tests locally or in CI/CD pipelines with variable extraction, assertions, and real-time monitoring.

Provides three skills for TypeScript/React development: implementing concise code to specifications, writing TDD tests with vitest and @testing-library/react, and performing focused code reviews. Deploys npm/vitest permissions and testing conventions via SessionStart hook.

This Claude Code plugin provides a `/verify` command and automatic Stop hook that run a project's tests, linting, and build checks before changes are sent for review. It auto-detects Node.js (npm), Python (pytest/ruff), and Makefile toolchains, then reports a clear PASS/FAIL summary to enforce the "verify before review" discipline.

Aether WCAG Scanner finds accessibility violations on live URLs by rendering pages in Playwright across desktop, tablet, and mobile viewports and pairing each violation with corpus-backed fixes tied to WCAG 2.1 AA success criteria. It uses axe-core for deterministic measurement and the Allchemy Labs hosted insights engine to ground fix suggestions in WCAG techniques, with all scanning running locally and API access optional for enhanced fix generation.

Agent Protocols is a Claude Code plugin providing 25 structured engineering workflows that enforce specification, testing, review, and deployment gates across the full software development lifecycle. It includes 8 agent personas and 25 skills that encode best practices as deterministic protocols agents follow, preventing common shortcuts like skipped tests or ignored edge cases.

aloop packages two-stage agile planning (interactive, human-gated) and two-phase TDD execution (autonomous, hook-enforced) with artifact validation, context-symbol structure checks, per-task transcripts, and planning retrospectives. It orchestrates 15 agents across planning and execution phases, enforcing determinism through hooks rather than model behavior, with worktree isolation per task and mid-sprint replanning on hard limits.

andon walks a repository's value stream stage-by-stage, proposing fixes for discovered gaps and proving each fix against its contract via seven evidence-grounded strategies before advancing—implementing the andon cord principle to halt rather than pass broken handoffs. The plugin includes 5 skills, 4 agents for adversarial tribunal verification, and a PreToolUse hook that enforces three non-negotiable stop conditions: red verdicts block advance, proposals exceeding authorization level block advance, and Tier 1 structural contradictions are never overridable.

atlias is a harness for AI coding agents that validates whether claimed work is actually complete by checking for test runs, syntax errors, unwired code, infinite loops, and destructive commands. It runs as a sub-harness inside Claude Code and other IDEs, or standalone as a terminal agent driving various LLM engines with a tool loop optimized for weaker models.

Bitfab provides LLM evaluation tools for Claude Code through an MCP server, enabling trace inspection, grader management, and diagnostics during development sessions. The plugin integrates via SessionStart hooks and shell command execution to deliver real-time evaluation capabilities.

Blunt Cake is a Claude Code agent skill that performs code reviews in 8 modes (Standard Roast, Panel Roast, Skill Roast, Eval Mode, Diff Roast, Batter Battle, Roast-a-thon, and Roast Challenge) with 6 selectable personalities (Chef, Disappointed Grandma, Passive-Aggressive PR Reviewer, Simon Cowell, Snoop Dogg, Pirate) plus custom personality creator. Every review includes real findings, actionable fixes with auto-fix capability, and shareable roast cards delivered with comedic flair.

CHA enforces a release-gate loop where coding agents hunt for defects, a separate second-eye reviewer briefs on findings, and every claim is adjudicated by execution before a fix lands. The system registers mutants for each fix and requires gates to be green before shipping, with a measured track record of catching 61–67% false claims that code review alone would miss.

check-code is a PostToolUse hook that lints only the lines Claude just edited in Python and shell files using ruff and shellcheck, then feeds findings back immediately so they can be fixed in the same turn. It respects the repository's existing linter configuration, supports adding custom linters via JSON, and produces no output or cost when edits are clean.

This Claude Code plugin extends Odoo development workflows with state management, test environment provisioning, and drift-detection agents. It provides declarative infrastructure-as-code capabilities for Odoo configuration, isolated testing via Testcontainers, and autonomous agents for configuration synchronization.

DevOKs browser tool integrates Chrome DevTools via MCP connection and provides visual diff validation skills for inspecting and comparing browser states. It runs 1 agent with 2 skills and connects to a local MCP server for Chrome automation.

This Claude Code plugin provides three skills for Django development: inspection of migrations, OpenAPI contract validation, and read-only querying of the test database via a Postgres MCP server. It enables code review and testing workflows directly within Claude without requiring external API keys.

drift-guard reads your installed React, Next.js, and Tailwind versions from lockfiles and blocks agent edits that use patterns correct for older versions but broken or deprecated in yours, with one-line fixes suggested. It runs deterministically with no LLM or network, ships as a Claude Code plugin with a PostToolUse hook, and also works as a CLI, Cursor/Codex hook, or Copilot instructions file.

first-pass is a Claude Code plugin that enforces comprehensive code review practices by having agents answer ten pre-mortem questions about changes, running a fresh-context review via a separate "breaker" agent, and proving work with tests and CI checks before marking anything done. It also catches bug patterns across a codebase by reproducing issues, finding similar code, and adding checks to prevent recurrence.

Forge spawns Builder and Breaker agents in an adversarial loop to harden code: the Builder implements features while the Breaker writes failing tests until no further issues can be found. The Breaker's adversarial tests—covering crashes, security, boundaries, race conditions, and resource leaks—become a permanent test suite in your repository.

This plugin provides seven agent skills for authoring, running, and managing end-to-end test workflows using getlark.ai, including workflow creation, execution, validation, and management capabilities. It integrates with Claude Code and other agents via Vercel's skills ecosystem, requiring a getlark.ai account and API key.

goalpost enforces /goal completion by converting goals into specs with checkable criteria, requiring all checks to pass and a fresh-eyes audit before allowing the goal to finish. It protects existing tests from editing, catches repeated errors, and restores the spec after context compaction.

Goodfellow is a Claude Code plugin that guides changes from idea through a multi-stage development lifecycle with adversarial review at each gate, testing verification, and persistent knowledge that carries across runs. It enforces tests that must fail before passing, defers major findings as tracked loops, and builds a knowledge base to improve future reviews and plans.

greenlight enforces Behavior-Driven Development workflows in Claude Code by requiring human approval of rules and test scenarios before any code is written, with cryptographic locks ensuring the AI cannot bypass or alter approved specs. It integrates test-first development with gating mechanisms, running tests to verify they fail for the right reasons before generating code that must pass those locked tests.

This Claude Code plugin provides two hooks that constrain agent behavior: protect-paths.sh prevents the agent from editing specified files (like tests or raw data), and stop-until-green.sh blocks agent termination until a configured command succeeds, feeding failures back as input for correction. The plugin uses external shell scripts and configuration files to enforce guardrails on autonomous agent work.

Heimdall analyzes video bug-report recordings by extracting frames adaptively (interval sampling, scene detection, or keyframes depending on duration), transcribing audio via whisper-cpp, and correlating them to produce a structured bug report with steps-to-reproduce and error messages. The plugin runs frame extraction and analysis in a subagent to keep the main context lean while delivering timestamped, actionable insights from video evidence.

Impeccable provides 24 code quality and design commands (polish, audit, critique, harden, etc.) along with 4 design agents and anti-pattern detection hooks that run on SessionStart, PostToolUse, and Stop events. The plugin integrates directly with the impeccable tool and executes shell commands to analyze and improve code quality.

The integration-branch-qa Claude Code plugin lets you test multiple approved PRs simultaneously on a shared local integration branch with a queue, interactive checklist, and merge gate that prevents conflicts. A guard hook blocks risky git operations (switch, reset, force-push) while QA testing is underway, keeping the main checkout safe while agents work in worktrees.

iOS-kit provides three agents (reviewer, researcher, verifier) and five skills for iOS development workflows, including playbooks for features, bug fixes, and dependency upgrades that automate testing, simulator launches, and code review. The plugin integrates SwiftLint and SwiftFormat linting on Swift file edits and reads project configuration from a `CLAUDE.md` template to guide code generation and verification.

The iris Claude Code plugin gives Claude a reliable camera for capturing screenshots of live websites with full-page, element-level, mobile/desktop preset, dark mode, and batch capabilities via a CLI and bundled MCP server. It includes skills for `/screenshot`, `/responsive-audit`, and `/visual-diff` along with a `@visual-reviewer` subagent for proactive visual QA after UI changes.

This Stop hook enforces that code changes pass the project's build and unit tests before an agent turn ends, using deterministic fingerprinting to skip re-validation of already-passing states. It requires no LLM judgment—success is determined solely by exit codes from the project's own build and test commands.

Knos adds a Stop hook that verifies test checks pass before the agent can stop, and provides an MCP server for creating GitHub issue bounties paid in test USDC on Solana devnet. The plugin attests check results via GitHub-signed workflow runs and verifies them on Solana's blockchain.

This plugin provides access to Chrome DevTools Protocol (CDP) for browser automation and testing within Claude Code, enabling automated screenshot capture, page navigation, JavaScript execution, and network monitoring. It wraps the chrome-devtools-mcp npm package and requires npx but no external API keys.

This Claude Code plugin automatically sets up Playwright MCP and installs Chromium browser on first session start, enabling browser automation tasks like web scraping, E2E testing, and screenshots. The plugin detects compatible Playwright versions, handles idempotent installation, and provides tools to navigate pages, fill forms, click elements, and capture snapshots.

memorydetective is a Claude Code plugin that runs an MCP server with 42 tools for analyzing iOS memory leaks, performance issues, and MetricKit diagnostics from .memgraph, .trace, and .mxdiagnostic files, classifying retain cycles against a 36-pattern catalog covering SwiftUI, Combine, Concurrency, UIKit, Core Animation, Core Data, SwiftData, and other frameworks. It includes a `/perf-investigate` skill that routes you through symptom triage, seven investigation slash commands, and tight integration with Swift source via SourceKit-LSP to suggest framework-specific fixes.

This Claude Code plugin integrates Nuxt, Vue, and Vitest development tools with multi-device preview, visual audit capabilities, and a Playwright MCP server for comprehensive web application testing and development workflows.

Orbty-eazy is a comprehensive software development workflow library for Claude Code that enforces test-driven development, systematic debugging, and collaborative agent patterns through 24 composable skills triggered automatically during coding tasks. It guides agents from design refinement through implementation planning and subagent-driven execution, with built-in code review, git workflows, and verification steps.

This Claude Code plugin uses hooks to intercept tool usage and integrates PHP development tools like PHPUnit and PHPStan for code analysis and testing workflows. It processes PHP and related files through shell commands (grep, jq) to enable pre- and post-execution tool inspection.

An agent skill that forces Claude Code and other coding agents to verify their claims about tests, builds, and fixes by actually running the checks and quoting the output. Without proof of execution, all claims are stamped UNVERIFIED with the command needed to verify them.

pile-nuxt provides 6 skills and an MCP server for Playwright-based testing, multi-device preview, and integrated development with Nuxt and Vue using Vitest. It enables web developers to manage testing, preview, and build workflows directly within Claude Code.

This MCP server plugin gives Claude full browser automation capabilities via Playwright, enabling navigation, form filling, screenshots, scraping, and JavaScript execution in a live browser context. It provides tools for multi-step UI testing, web scraping, and end-to-end workflow automation without requiring additional configuration.

A pytest Stop hook that runs tests when Claude Code agents finish, blocking completion up to twice if tests fail and then marking the result as "NOT verified" if still broken. No model calls, no external APIs—just validates against your repo's existing pytest suite with git tracking and test-edit detection.

Ranger automates browser-based verification of UI features during Claude Code development by running tests in a real Chromium instance and collecting results on a feature review dashboard. It integrates via hooks and a skill command to guide the coding agent through feature specification, implementation, verification, and team review cycles.

Remakecraft is a Claude Code plugin that reads an app's behavior from black-box evidence (screenshots, recordings, docs) and generates a detailed spec and conformance tests, then orchestrates up to 5 parallel agent-driven rewrites in native stacks while a logged hook-wall prevents access to original source material. It measures parity across all tests including sealed ones, achieving 99.7% pass rates on measured runs like Brushling (Paint in Rust) and 97.9% on bundled examples.

This plugin enforces a falsification-first investigation workflow that converts assertions into labeled hypotheses, predicts outcomes before measuring, runs controlled experiments, and gates findings through adversarial REFUTE-first verification. Verdicts persist in a hypothesis ledger to prevent re-attacking killed ideas, with multi-agent campaigns for investigations, invention, and peer review all built on a methodology-first architecture.

A Stop hook that enforces code review by blocking turn completion until fresh-context reviewer agents have read the diff, verified findings against the files, and the loop converges. It uses 5 agents and 2 skills to run independent reviews with failure scenarios, dismissals backed by proof, and honest convergence reporting rather than false "clean" status.

A Stop hook that verifies agents have actually run and passed matching test, build, or lint commands before claiming success, reading the session transcript to find evidence. If no matching command with exit code 0 ran after the last code edit, the hook blocks the stop and tells the agent which claim lacks a receipt, asking it to run the check or admit it didn't.

since-cutoff identifies Python dependency APIs that changed after a coding model's training cutoff and measures which ones the model misuses, then generates verified AGENTS.md notes to correct those mistakes. It includes an MCP server to surface API diffs to agents and integrates with GitHub Actions and pre-commit hooks for CI workflows.

A spec-driven single-pass development pipeline that replaces developer-reviewer loops with deterministic gates, progressing from architect planning through spec-writer test definitions, developer implementation, and three verification gates (verify/test, spec integrity, single review) before commit. It validates an alternative to the git-workflow plugin by eliminating multi-turn review overhead and re-contextualizing validation through failing spec tests fixed upfront and a one-shot code review.

Speed-run is a token-efficient code generation pipeline that leverages Cerebras hosted LLM for fast first-pass generation, with Claude handling architecture and surgical fixes via three skills: turbo (direct codegen), showdown (parallel competition), and any-percent (parallel exploration). The plugin includes an MCP server, git worktree support, and test-driven development orchestration to reduce token costs by 60-70% compared to standard Claude workflows.

A Claude Code plugin that runs on turn-end to block completion if JavaScript/TypeScript typecheck or related tests fail, forcing Claude to continue working on the issues. It groups changed files by package.json, runs typecheck and test commands per project, and caches results by content hash to minimize overhead.

Stunt Double is a standalone Agent Skill that deploys AI user personas to validate user journeys and find UX friction points before real users encounter them. The skill provides five agents to create actor personas, run design reviews, execute QA suites, validate workflows, and triage feedback—all integrated with Claude through MCP at a hosted endpoint.

SuperBased adds screenshot capture, OCR, screen recording, visual regression testing, voice dictation, and full GUI automation with humanization to Claude Code via 72 MCP tools. It enables Claude to see and interact with the desktop, with features like proactive screen monitoring, CAPTCHA solving, token-efficient text compression, and post-test auto-capture.

TestPilot generates test cases using evolvable Agent State with generator prompts stored as skills, schema validation and design gates managed through hooks, and deterministic scoring handled by an external MCP tool to prevent model self-scoring. The plugin includes 10 test-generation skills, 2 hooks for PreToolUse and Stop events, and 1 MCP server that runs shell commands through Node.js.

A Claude Code plugin that enforces disciplined AI agent behavior through a verification router with 12 skill modules, mandatory prompt classification, and automated test gates. It uses re-injection and compaction techniques to maintain code quality and safety across tool use, session initialization, and user prompt submission.

UI-Evaluator is a Claude Code plugin that audits and fixes web UIs against verifiable standards including WCAG 2.2 AA accessibility, usability, craft quality, and absence of generic AI patterns. It runs isolated evaluator subagents that perform deterministic browser checks, heuristic evaluations, and cognitive walkthroughs, then fixes issues one at a time with verification.

Verdict is a Claude Code QA agent that tracks test findings across runs (baseline → delta), classifying failures as real defects, stale expectations, brittle tests, environment issues, or flaky tests quarantined with expiry dates. It produces evidence-cited release verdicts (pass | pass with risks | blocked | fail) with findings ranked by regression status and severity, while maintaining an auditable, read-only state ledger that the agent cannot modify.

zeugnis audits AI-generated code for four characteristic failure modes: hallucinated dependencies, weak test assertions, structural contract drift between type hints/docstrings and actual usage, and unbounded agent retry loops, with independent verification of every finding. The plugin provides five narrowly-scoped skills, eight total skills including dependency/assertion/contract/agentic-reliability audits plus preflight checks and a bounded self-optimization cycle, all running on Python 3.9+ with stdlib only.

addlightness removes AI-generated code bloat—unused imports, dead branches, redundant control flow—while verifying behavior equivalence and benchmarking performance gains with statistical rigor. The plugin measures weight, trims across three ordered passes (mechanical, semantic, style), gates every edit against an equivalence check, and reports before/after metrics with Welch significance testing.

An offline, read-only MCP server that verifies claims about AI systems against supplied evidence bytes and replays agent-evidence conformance vectors. It provides nine tools including verify_claim, run_vectors, and check_artifact_digest for agent builders, auditors, and platform engineers to validate evidence instead of trusting reports.

A Claude Code plugin that adds guardrails for Next.js apps, enforcing separation of concerns, preventing hand edits to generated API clients, and validating accessibility, internationalization (i18n), and SEO. It installs gate scripts, lint configs, reviewer agents, and audit commands that run on your machine without external network calls.

Anti-Stuck for Flutter prevents Claude Code sessions from competing for the same mobile device or emulator by maintaining a shared device ledger and enforcing fair access through queuing and automatic wake-on-free notifications. It also guards against hanging Marionette MCP calls, enforces time limits on builds and tests, and cleans up orphaned flutter_tester processes.

This Claude Code plugin provides an MCP server that integrates Artillery 2.x load testing into Claude, exposing full command flags, Fargate deployment support, raw-text parser, and project launcher capabilities. Users can define and execute load tests directly within Claude workflows using Artillery's configuration and execution features.

BDK is a dev kit plugin packaging 13 agents, 29 skills, and 6 hooks for language-agnostic code review, testing, planning, design, and documentation workflows. It integrates with GitHub for PR reviews and delegates environment setup to project-local configuration files.

Belay is a Claude Code plugin that flips the traditional AI assistance model by having you write the code while it coaches, runs tests, and tracks skill progression through three modes: unearned (you code, it reviews), earned (it codes, you review), and mastered (it works quietly). Skills are unlocked through a logbook system that requires witnessed test runs and human validation of your understanding before delegation is granted.

callbluff is a Claude Code plugin with 11 hooks that intercepts agent claims by checking for broken code, weakened tests, unmeasured performance claims, and unverified completion statements. It uses python3 to run static analysis and shell execution checks before the agent declares work done.

cast provides Claude with multiple logged-in Chrome browser profiles, one per test user, enabling multi-user app testing where Claude can orchestrate interactions across users simultaneously. Each profile maintains persistent logins and SSO credentials, allowing Claude to verify user-to-user workflows like messaging, approvals, and marketplace interactions.

cast provides Claude Code with multiple persistent Chrome profiles, each logged in as a different test user, so Claude can simulate multi-user scenarios like chat interactions and approval workflows. It manages browser windows per person with SSO support, saving login state and browser history per profile between sessions.

claim-check provides a Stop hook that analyzes final assistant messages to report what the session transcript can and cannot show about claimed test results, commits, or file edits—without confirming or refuting any claim. It also includes an opt-in pytest runner and checker that can issue `supported` or `contradicted` verdicts when a precisely scoped claim is matched against a pytest receipt.

claim-check verifies Claude's claims about test results, build success, and lint/type checks by examining the actual commands that ran in the session transcript. It reports matches and mismatches at the end of each turn without blocking, supporting both English and Korean.

claude-cam is a Claude Code plugin that enables Claude to analyze real-time camera feeds from your phone, including hardware states, screen content, and LED indicators while devices operate. It includes frame-by-frame analysis of high-speed video to inspect device behavior and visual feedback.

This plugin provides three adversarial verification subagents for Claude Code: bot-deploy-verifier catches silent skipped restarts after service redeployments, claim-auditor detects probability stacking and statistical errors in Markdown reports, and remote-agent-dispatcher safely spawns long-running agents on remote hosts via SSH. A PostToolUse hook auto-fires claim-auditor on every *.report.md write to enforce report quality without manual intervention.

Spawns parallel reviewer agents to examine code diffs and presents findings interactively with selectable fixes, then dispatches fixer agent teams to remediate approved issues in a loop until clean. Integrates with the PR Review Toolkit to provide specialist review agents and uses agent teams for coordinated parallel remediation.

cpp26-guard enforces C++26 code modernization patterns by detecting hand-written copies of definitions (enums, lookups, flag parsers) and advisory C++26 idioms through two skills and pre/post-write hooks. It uses static analysis with python3-based lints, reflection-aware reference code, and GCC 16.2 evidence tables, all configured via .claude/cpp26-guard.json with allowance files for exceptions.

Five evidence-backed C++ convention skills (designated-init, no-needless-copies, cppreference, units, no-magic-numbers) combined with a PreToolUse hook that scans new C++ code for copy smells and bare numbers before writing. Compiler fixtures validate rules against GCC and Clang, and the cppreference skill caches pages for offline lookup.

Craveira is an AI-first development framework for Claude Code that automatically scales the intensity of AI review based on change risk: low-risk changes like stylesheet edits bypass agents entirely, while high-risk changes like authorization or payment logic trigger mandatory security review, architecture review, and testing with multiple agent tiers. It includes 6 reusable agent definitions, pre-push hooks for linting and testing, a tier-declaration gate enforced via PreToolUse, and token-cost containment rules to prevent expensive agent fan-out on low-risk tasks.

cross-model-advisor adds a review gate to Claude Code that deploys advisors from other model families (OpenAI, Gemini, xAI, OpenRouter, Kimi, Copilot) to inspect git diffs and findings whenever Claude finishes a turn with file changes. Advisors review read-only and can send Claude back to address concerns or evidence-backed findings depending on the configured gate mode (block or report).

This official Flutter/Dart plugin provides 26 Agent Skills and a Dart MCP server to help Claude build natively compiled applications for mobile, web, desktop, and embedded platforms from a single Dart/Flutter codebase. Skills cover testing, UI patterns, state management, routing, localization, and networking—teaching the agent best practices for reliable Flutter development.

This QA plugin scans Markdown client deliverables against a team rulebook, recomputing metrics and separating blockers from warnings while leaving the draft unmodified. It validates findings against rule definitions and metric formulas, then issues a ready-to-send verdict based on evidence and severity.

This Agent Skill analyzes test suites to detect which ones lack negative test cases (intentional failure scenarios), reporting on suite coverage and scoring the detector against hand-labeled benchmarks. It identifies missing negative controls that would catch broken code, distinguishing between suites testing only happy paths versus those with proper negative assertions.

DoD-Guard enforces a Definition of Done as an executable barrier in Claude Code by combining deterministic detectors, adversarial subagents, lifecycle hooks, and audit commands to prevent incomplete code from being marked complete. It catches stubs, TODOs, empty functions, tautological tests, and unverified claims across Python, JavaScript, TypeScript, Go, Rust, and other languages through five reinforcing layers.

dod-lite is a Definition-of-Done auditor hook that observes pre-authored script and AI-graded checks at every session Stop and records per-turn reports without providing feedback to the session. It is purpose-built as an instrument for optimizer arm sessions and operates silently to preserve experimental integrity.

fakechat is a localhost iMessage-style web interface for testing Claude Code's channel contract, allowing you to send and receive messages, upload files, and edit messages in a browser without external dependencies. It includes an MCP server implementation and provides tools for sending replies and editing messages in real-time.

forge is a continuous engineering loop for Claude Code that triages requests into questions, small tasks with test-driven harnesses, or large tasks with parallel subagents, spec validation, and a deterministic judge that ratchets toward measurable goals. It integrates with Jira, Google Docs, PDFs, and Figma for goal extraction, uses Jev for routing and pre-sorting, and provides per-repo self-learning from run evidence and corrections.

gatekit is a Claude Code plugin that enforces gate-based workflows to validate specifications and builds through interview and mockup phases. It uses hooks and Python-based tools to verify implementation against requirements and evidence.

gimme-the-lint is a polyglot linting engine that enforces only new violations while baselines existing problems, supporting ESLint, Biome, Ruff, golangci-lint, Clippy, tflint, ansible-lint, squawk, buf, spectral, tsc, mypy, and SQLAlchemy/Pydantic contract drift detection across JavaScript/TypeScript, Python, Go, Rust, Terraform, and Ansible projects. It auto-discovers linters per app in monorepos using manifest files and language conventions, with fingerprint-based violation tracking that survives code movements and integrates into Claude Code, Git hooks, CLI, and GitHub Actions.

greenwashing is a Claude Code plugin that enforces real test passage by running tests when code changes and blocking turn completion if tests fail, skipped tests are added, or tests contain no assertions. It also detects mutations in code by intentionally breaking changes to verify test coverage catches the breakage.

This plugin provides a hidden acceptance testing framework with a build route, a validator agent that exercises the app as a user would, and a guard hook that prevents scenario builders from running scenarios. It enables teams to test acceptance criteria without exposing internal validation logic.

This skill audits user flows and code against 12 categories of failure modes—from UX and security to concurrency and payment integrity—then implements fixes in severity order after explicit user confirmation. It triggers on requests to find edge cases, stress-test features, or audit payment/auth/checkout flows, and gates all changes behind a mandatory review step.

A Claude Code plugin providing a comprehensive skills library for Java development, including 7 skills covering development practices, testing, concurrency, observability, Maven, and Git workflows, plus 2 agents for code review and upgrade planning. The plugin automatically detects Maven/Gradle projects and surfaces relevant skills via a SessionStart hook.

jev-gates provides nine escalating quality gates for Claude Code that check edits against rules, scope, and intent; validate change requests for completeness; and verify that claims at completion time (tests passed, work done) match what actually happened. Each gate runs asynchronously through hooks and returns a probability score rather than blocking, letting you set your own risk tolerance.

jevmate is a decision-making layer that uses Jev, a calibrated smaller model, to rank files, identify affected tests, and score diffs by risk—so Claude reads only what matters and judges only the uncertain cases. It integrates into Claude Code as a plugin with slash commands, hooks that trim output and catch safety concerns, and displays savings metrics in the session header.

kit is a Claude Code plugin that orchestrates multi-agent feature builds driven by human-approved specs: a planner breaks the spec into tasks, a test author writes acceptance tests, builders implement task-by-task, and reviewers validate across behavior, code, security, and UX dimensions before the system commits the work and generates a report. The system enforces architectural consistency, runs checks on files and code boundaries, and maintains decision records so subsequent features build on established patterns.

kit-ship-check reads test, lint, and type-check commands from CLAUDE.md (or package.json / Makefile / pyproject.toml) and runs each one, displaying results in a PASS/FAIL table. It also adds a Stop hook that reminds you to run the check before committing.

lawha opens React frontends in a real browser at six screen widths, light/dark modes, LTR/RTL, and reduced motion, then audits layout, tap targets, accessibility (axe), animations, RTL CSS hazards, and visual design (alignment, spacing, type scale, contrast). It indexes the project's design system (Tailwind tokens, shadcn, TanStack routes) and proposes fixes, or builds pages from Figma designs and design directions, measuring pixel-perfect fidelity against the specs.

loop-testing is an autonomous QA agent that exercises finished applications (CLI, API, Web, library) like a real user in a sandbox, discovering and fixing low-risk bugs with regression tests while routing judgment calls through multi-model consensus and looping until convergence. It runs fully hands-off, pausing only for keys, network permissions, security concerns, or blockers.

This Claude Code plugin provides 4 skills for investigating bugs, generating root cause analyses (RCAs), and integrating the Luciq mobile observability SDK into iOS, Android, Flutter, React Native, and KMP projects. It connects to the Luciq API to enable mobile app debugging and monitoring capabilities.

mcp-core bundles 15 keyless MCP servers covering browser automation and debugging, code analysis, document conversion, mobile device control, and UI tools—all functional immediately after installation with no API keys required. The integrated skill automatically directs Claude to the appropriate server for each task, including Playwright for E2E testing, ast-grep for structural code search, mobile device control, PDF/Excel/YouTube conversion, and 200k+ icon search.

Moonbrick is a Claude Code plugin that equips AI with Roblox development infrastructure: Rojo file syncing for real-time editing, strict Luau type checking, debug hooks for automated playtesting and unit testing, and pre-built game systems (VFX, UI, secure remotes, player data). It bundles game templates, design-first workflows with screenshot review, and API documentation to help Claude build cohesive, production-ready Roblox games in fewer iterations.

mutation-gate enhances Claude Code's testing by automatically running mutation tests whenever Claude writes or runs tests, injecting small bugs into the code and strengthening tests until they catch all mutants. It supports established mutation tools for JavaScript, Python, Rust, Go, Java, C#, and Scala, with LLM-powered mutation generation for other languages.

The ng plugin scaffolds, reviews, tests, and migrates Angular applications with 6 commands and 2 agents, enforcing a production-proven project structure based on Angular 20. It provides auto-triggered skills for code generation, testing, NgRx patterns, RxJS, migrations, and performance optimization.

nitbot runs adversarial code review using a blind Reviewer sub-agent and a Skeptic that attempts to refute every finding, augmented by the project's own linters, type checkers, and tests filtered to changed lines via zero-token scripts. It routes reviews through quick or full mode based on computed risk scores, integrates with GitHub for PR targets and CI status, and provides guardrail hooks at pre/post tool use and session end.

This plugin implements a quality gate for the Open Knowledge Format toolchain, checking spec conformance with a vendored checker, applying house rules through okflint manifest, and detecting staleness. It includes diagnostic tools to identify missing dependencies and self-tests that verify all gates continue to function correctly.

optimizer is an A/B testing harness that launches paired control/test sessions of Claude Code plugins with identical configurations, then fuses session logs and quality verdicts into comparative analysis across five pillars: quality, input tokens, output tokens, turns, and autonomy. It maintains a hypothesis ledger and regression series to track whether a plugin beats the status-quo baseline, accumulating evidence-backed findings run-over-run.

paprika3D is a Claude Code plugin and MCP server that enables coding agents to visually inspect, test, and optimize three.js, React Three Fiber, and WebGL pages they write by running them in headless Chrome with deterministic playback. It provides tools to see rendered scenes as data, measure performance against device budgets, diagnose loading failures, and suggest optimizations like LOD and instancing without changing visual output.

php-harmony is a Claude Code plugin providing comprehensive PHP development support with code quality enforcement, Doctrine ORM patterns, Symfony conventions, automated testing guidance, and security auditing through 3 agents and 5 reusable skills. It includes 5 user commands, automated hooks for debug detection and code formatting, and works with Symfony 6/7 and any Composer-based PHP project.

playbench automates the game-dev loop for AI coding agents by running bot playtests after each feature, performing balance sweeps on real builds, and enforcing release gates to block undisclosed AI art and placeholder content. It integrates with Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and other agents through 11 reusable skills covering design, build, playtest, balance, iterate, log, and ship workflows.

Playmark is a Godot addon integrated with Claude Code that lets developers mark issues during gameplay by freezing the frame, pinning a location, and writing a note; Claude receives the frame, last five seconds of video, logs, and code under the mark to propose fixes that apply in-game with visual feedback.

This MCP server enables Claude to automate browser interactions including taking screenshots, filling forms, clicking elements, and navigating web pages. It integrates browser automation capabilities powered by Playwright, a cross-platform testing framework by Microsoft.

product-qa is a senior QA engineer skill that runs automated post-build testing passes (test execution, failure-path test generation, and release verdicts) and provides risk-ranked test strategies, PR review, and structured bug investigation. It includes domain-specific checks for web, mobile, API, jobs, AI, and financial products with stack hints for Flutter, NestJS, Supabase, BullMQ, and Nigerian payment providers.

This bilingual plugin provides structured product review analysis for PRDs, UX designs, and workflows by identifying logic defects, interaction risks, and missing edge cases. The plugin uses an agent-based approach with local skill execution and shell utilities to produce audit reports with actionable insights.

Blocks a Claude Code agent from claiming tests pass, builds succeed, or code is deployed unless those commands actually ran and succeeded in the current session's transcript. The plugin validates claims by detecting matching commands after the last relevant edit and rejects unsupported or stale evidence.

Proxymail-qa provides disposable email inboxes for testing authentication flows like sign-ups, login codes, magic links, and password resets, with agents creating test addresses and extracting verification codes or links directly. The plugin includes an MCP server and a skill that guides agents through end-to-end sign-up testing without requiring an API key.

A collection of three developer-facing skills for code quality: pr-review-fix automates applying GitHub review comments to local files, test-gap-finder identifies untested code paths in diffs and generates test stubs, and dead-code-hunter scans for unused exports and functions with line-level reporting.

pudding is a Claude Code plugin that intercepts agent turn endings to verify that claims like "it works" are backed by saved evidence—screenshots for UI changes, test results for logic, or API responses for backend work—rather than passing test commands alone. It checks the claim type and required evidence kind, and can warn or block turns when the evidence doesn't match what was claimed.

A self-contained QA automation plugin that orchestrates the entire testing loop—analyzing stories, authoring and approving test cases, publishing to Azure DevOps, generating API and UI automation in Playwright + TypeScript, and filing bugs from failing runs. It teaches and reviews the framework while keeping you in control at every tracker write with human-gated confirmations and no external dependencies.

The qa-engineering plugin orchestrates the entire QA lifecycle: analyzing stories, authoring and approving test cases, publishing them to Azure DevOps, generating Playwright+TypeScript automation for APIs and UIs, and filing bugs from failing runs—with human approval gates at every tracker write. It includes built-in QA teaching and framework review, ships no product data (credentials and URLs stay local in git-ignored config), and self-contains all 12 native skills without external plugin dependencies.

QA-Pilot enforces evidence-first feature testing by requiring every executed test case to produce mandatory Playwright traces and deploy SHAs before publishing verdicts to ClickUp or local files. It manages the full pipeline from test generation through QA review, with strict gatekeeping rules that reject verdicts missing evidence, from non-production environments, from unapproved cases, or that violate declared write policies.

QA Warden is a Claude Code plugin that transforms plain-language specs into deterministic Playwright E2E test suites, with AI authoring specs and triaging failures while nightly replays run at $0 LLM cost. The plugin enforces assertion integrity through a PreToolUse hook that prevents the healer from modifying assertions, maintains reusable page objects, and requires human approval gates before code generation.

quality-ratchet is a linting hook that runs after tool use to report only the quality issues introduced by an edit, preventing regressions in code quality. It executes python_quality_ratchet.py via shell to compare pre- and post-edit states and surface new lint violations.

This plugin provides a comprehensive standard for Hotwire in Rails apps, covering Turbo Drive, Frames, Streams, broadcasts, Stimulus, and Turbo 8 morphing with guidance on choosing the right tool for each UI pattern. It ships a detailed skill with reference documentation, an audit script, and a hotwire-builder agent that constructs interactive UI and fixes Hotwire behavior while checking against best practices.

This plugin provides a standardized Minitest testing framework for Rails apps, including a comprehensive skill with test kinds, fixtures, helpers, and performance guidelines. It includes a minitest-runner agent that writes, diagnoses, and runs tests, along with suite audit tooling to identify gaps and smells in existing test suites.

This plugin provides a comprehensive standard for organizing, writing, testing, and integrating ViewComponent libraries in Rails apps, covering Turbo Streams, Stimulus controllers, forms, and broadcasting patterns. It includes a component-builder agent that scaffolds new components with previews and tests, plus library audit and upgrade capabilities via shell scripts.

A production-oriented Agent Skill for designing, implementing, reviewing, refactoring, and optimizing React web codebases with full React 19 and React 18 coverage. It provides framework-aware guidance across components, state, effects, async patterns, rendering, performance, accessibility, security, and testing while respecting repository contracts and avoiding dogmatic architecture patterns.

Ritoko records browser automation workflows by observing an agent perform a task once, then replays the workflow with new batch data while verifying results and pausing uncertain submissions for review. It stores run history in SQLite and integrates with Claude Code and Codex CLI via an MCP server, requiring Node 24+ and Google Chrome.

Ritual is a Claude Code plugin that captures mistakes during a session and converts them into reusable rules, guards, and tests that prevent the same errors from recurring. It ships with 53 field lessons across project categories, detector questions for different code domains, and a guard system that blocks previously-failed commands while suggesting alternatives.

RKstack enforces disciplined AI development through a multi-phase workflow (brainstorming, planning, TDD, code review, shipping) with stack detection and safety hooks that prevent destructive commands. The plugin automatically adapts to your project, performs dual-review cycles, runs systematic debugging, and gates verification steps based on detected tech (web projects get screenshot/responsive checks, Supabase projects verify data via MCP).

A production-oriented Agent Skill for designing, implementing, reviewing, refactoring, testing, securing, optimizing, and operating small-to-medium Rust codebases with non-dogmatic guidance that preserves repository contracts and favors minimal, sound changes. The skill includes focused references on architecture, async/concurrency, performance, security, testing, and tooling that the agent accesses only when the task requires them.

The sdlc plugin enforces a structured software development workflow across nine gates where tests are written and frozen before implementation, and the implementing agent cannot modify those tests. It coordinates this process through 11 agents and 3 skills while monitoring tool usage via hooks.

This plugin automates spec-driven development by accepting a design document, generating tests, building code, and opening pull requests automatically. It enforces that features only ship when real tests pass, with state persisted to disk across sessions.

StackPilot guides coding agents through a complete workflow: design, spec, plan, test-driven development, review, and verification using host-native tools. It installs as a Claude Code plugin with automatic routing that dispatches feature requests into appropriate gates (methodology, planning, TDD, QA) and runs autonomous sprints via Claude Code's Agent tool.

This standalone Agent Skill enables full component development workflows from Figma designs to tested React components, with capabilities for converting Figma designs to JSX/Astro code using Tailwind CSS and generating Vitest Browser Mode tests with intelligent component classification. The skill operates as a cohesive system for design-to-implementation automation without requiring external API keys or paid services.

This standalone Agent Skill enables full component development workflows from Figma designs to tested React components, with capabilities to convert Figma designs to JSX/Astro components using Tailwind CSS and generate Vitest Browser Mode tests. It provides intelligent component classification for testing (Simple/Complex) and integrates with the Figma MCP server for design-to-code conversion.

Super-Kit is a modular Claude Code plugin that provides 19 specialized AI agents (planner, coder, tester, reviewer, debugger, and others), 69 dynamic skills, and an MCP server for semantic context search and workflow automation. It enables large language models to load knowledge on-demand through structured files rather than relying on bloated static system prompts, with built-in tools for listing assets, loading agent/skill instructions, and executing validation workflows.

switchyard queues heavy test and build runs across multiple Claude Code sessions on one machine, preventing CPU/memory collisions by enforcing exclusive locks and distributing resources. Commands are recognized and routed transparently via PATH shims, with the session notified when queued runs complete.

Tandem is a Claude Code project-management plugin that replaces ad-hoc chat planning with a governed markdown-based pipeline from North Star through production release, enforcing gates like Definition of Ready/Done and mandatory Story↔Testplan pairing. It provides 32 skills and automatic governance hooks (linting, Command Center generation, autopilot execution) directly in the repo without external tools.

TestChimp is a QA platform for coding agents that runs policy-backed test workflows with coverage signals, in-repo test plans, and verified tests for release governance. It integrates via an MCP server at mcp.testchimp.io and provides commands for test authoring, execution, coverage instrumentation, and QA automation across PR pipelines.

This Claude Code plugin auto-generates test files for new code by detecting your test framework (RSpec, pytest, Jest, Vitest, PHPUnit, Go testing, ExUnit, Rust) and scaffolding tests with edge cases and happy-path scenarios. It includes a PostToolUse hook that reminds you when source files lack corresponding tests, a slash command for on-demand test generation, and an agent for deep analysis of existing test patterns.

Testosaurus turns beta-tester feedback into tested draft PRs by connecting Claude Code to a feedback widget that groups reports into issues with AI analysis, then automatically fixes top issues on branches and opens PRs. The plugin provides four commands to set up the widget, triage issues by impact, apply fixes with test verification, and record shipped results—all requiring a Triage scope API key from testosaurus.dev.

This plugin runs clang-tidy on every C++ file the agent edits, automatically checking code quality and consistency. It can also convert recurring agent mistakes into custom clang-tidy checks to prevent similar issues in the future.

TRACE (Test Requirements Against Code & Execution) is an agent skill that helps validate test requirements against actual code and execution by managing canonical artifacts via a Python helper script. It integrates with Claude Code, Codex, Copilot CLI, and Gemini CLI through a single `trace` skill declaration.

This plugin connects Claude Code to the Trunk Flaky Tests MCP server, providing AI-powered root cause analysis and fix suggestions for flaky tests in your test suite. It includes two MCP tools, three slash commands, and two skills that automatically activate when debugging or setting up CI pipelines for test uploads.

A standalone Agent Skill that guides implementation, review, refactoring, testing, and auditing of small-to-medium TypeScript codebases with pragmatic production standards. It provides reference-based workflows for security, performance, async patterns, compatibility, and dependency management without imposing dogmatic architectural constraints.

This plugin provides two skills for UI testing: **buggy** writes ADO Test Case work items in Acme CRM house style via bundled Azure DevOps MCP, while **tester** authors UI test cases and generates/parses runnable Playwright + TypeScript specs without external writes. Both skills are triggered by pasting tickets or stories and requesting test cases or script generation.

UXMachine opens your site in a real browser at multiple viewports and returns verifiable observations about visual state, measurements, and how to verify changes. The plugin provides an MCP connector and a Claude Code skill that prompts your agent to measure pages before completing tasks.

This Claude Code plugin integrates VeracityAPI's content verification MCP server to analyze text, images, audio, URLs, and batch content for pre-publish review, moderation, and quality assurance workflows. It provides commands for text verification, source triage, balance checking, and returns deterministic risk signals (`allow`, `revise`, `human_review`, `reject`) to guide content routing decisions.

This Claude Code plugin installs the VerifyAX MCP server, enabling conversational access to agent registration, scenario generation, simulation execution, and evaluation result analysis. Users simply describe what they want (e.g., "register an agent and run an interview eval"), and Claude selects the appropriate tools to execute the task.

This Claude Code plugin extracts frames from screen recordings and analyzes them to diagnose UI/rendering bugs like stutter, hangs, whiteouts, flicker, and black screens, or document visual characteristics like palette and pacing. It requires ffmpeg and ffprobe to be installed separately and provides explicit opt-in control over external tool usage.

vvkit is a Claude Code plugin that ships portable agent practices — design, planning, delegation, verification, debugging, review, and testing — as reusable skills and hooks that update once for all projects. Companion stack plugins (Swift, Go, Backend) instantiate these disciplines with language-specific tooling and conventions that teammates get automatically when the project enables them.

vvkit-swift provides Swift and Xcode instantiations of vvkit disciplines including testing, concurrency, style, logging, and builds, with an integrated Swift reviewer. The plugin includes one agent, five skills, and a PostToolUse hook that runs shell commands with swiftlint.

VVUQ4AI verifies AI-generated STEM claims against curated knowledge bases, IEEE standards, and mathematical checks by connecting Claude to the VVUQ service via MCP. The plugin flags inaccuracies in physics constants, formulas, and technical specifications with real values and error margins.

Web Vitals Auditor is a Claude Code plugin that runs Lighthouse audits to identify Core Web Vitals regressions and generates ranked fix lists for JavaScript bundles, images, and fonts. It provides desktop and mobile performance baselines with actionable recommendations for the highest-impact optimizations first.

The plugin orchestrates a multi-agent crew that automates guided delivery by detecting your project structure, enforcing test-first development, running builds and checks, and holding execution until test evidence confirms completion. It integrates with your development workflow through lifecycle hooks and shell execution to verify work meets quality standards before proceeding.

Ponytail enforces a "lazy senior dev" philosophy within Claude Code by automatically steering solutions toward the simplest, most pragmatic implementation—preferring stdlib, minimal abstractions, and YAGNI principles. The plugin includes 6 skills that analyze code context, validate security, and catch dependency mismatches to keep output focused, tested, and production-ready.

PR Review Toolkit bundles six specialized agents that analyze different aspects of code quality: comment accuracy, test coverage, error handling, type design, general code compliance, and code simplification. Each agent can be triggered individually with natural language requests or used together for comprehensive pull request review.

ruflo-browser provides session-as-skill browser automation using Playwright, capturing each session as a replayable RVF cognitive container with trajectory, screenshots, and findings indexed in AgentDB and protected by AIDefence PII/injection gates. It exposes 10 skills and 23 MCP tools for recording, replaying, extracting, testing, and managing browser sessions with selector memory and cookie vaulting.

This plugin detects test coverage gaps, analyzes coverage across codebases, and generates automated test scaffolding to improve test coverage with London School (mock-first) patterns. It integrates with the SPARC Refinement phase to enforce ≥80% coverage on new code and coordinates background test gap analysis via the testgaps worker.

An editorial bundle of 10 reusable skills from Agentic Awesome Skills for quality assurance and test automation workflows in Claude Code. The bundle provides ready-made capabilities for QA testing scenarios without requiring external API keys or tools.

This plugin audits web interfaces for WCAG accessibility compliance, validating screen reader compatibility, keyboard navigation, and inclusive design patterns. It provides both automated testing commands and agent-driven compliance analysis without requiring external dependencies.

This Claude Code plugin automates API testing, mocking HTTP requests, and generating OpenAPI documentation to validate your API contracts and behavior. It integrates observability setup and monitoring capabilities to help track API performance and issues in development and testing environments.

This plugin provides schema validation, data quality monitoring, and streaming validation pipelines for backend APIs. It includes an agent-based validation system designed to handle input validation tasks for API endpoints and data quality assurance workflows.

This Claude Code plugin provides end-to-end feature orchestration across testing, security, performance, and deployment stages through a single command and four integrated agents. It consolidates quality assurance workflows without requiring external API keys or third-party services.

This plugin provides performance analysis, test coverage review, and AI-powered code quality assessment through two integrated agents and commands. It analyzes code performance metrics and test coverage without requiring external APIs or tools.

A three-layer quality evaluation framework for Claude Code plugins using static analysis, LLM-based semantic evaluation, and Monte Carlo statistical testing to assess reliability and correctness. It provides CLI commands for scoring individual plugins, full certification with badges, and comparative head-to-head analysis.

Ship-mate orchestrates a full feature development pipeline from story to shipped code, routing work through specialized AI agents (orchestrator, architect, developer, PR reviewer, QA) and automated Playwright testing. It transforms a story file into reviewed, tested, and deployment-ready code by automating the entire development workflow.

This plugin implements test-driven development workflows with automated red-green-refactor cycles and integrated code review processes. It provides commands and agents to enforce TDD methodology throughout the development lifecycle.

Automates unit and integration testing for Python and JavaScript codebases with integrated debugging capabilities. The plugin provides 1 command and 2 agents to help write, run, and troubleshoot tests within your development workflow.

Solves competition mathematics problems (IMO, Putnam, USAMO) using context-isolated adversarial verification that catches self-verification bias by testing proofs with specific failure patterns. Calibrates abstention over false claims and produces clean LaTeX/PDF output after verification passes.

This plugin bundles 6 specialized agents for pull request review, each focusing on a distinct aspect: code comments, test coverage, error handling, type design, code quality, and simplification. They analyze PRs individually or in combination to provide comprehensive code quality feedback with actionable, severity-ranked findings.

This plugin provides end-to-end chaos engineering discipline through three Python tools for designing experiments with hypothesis-driven testing, calculating blast radius against error budgets, and generating blameless postmortems. It includes reference documentation on chaos principles and attack taxonomy, experiment templates, and an interactive slash command to guide users through the full chaos engineering workflow.

This Claude Code plugin provides three data quality assessment tools that audit datasets for completeness, consistency, accuracy, and validity using pure Python: a data profiler with DQS scoring, a missing value analyzer with MCAR/MAR/MNAR classification, and a multi-method outlier detector. All functionality relies on Python standard library only, requiring no external API keys or services.

prompt-governance is a Claude Code plugin providing a skill for managing prompts at scale in production, including versioning, A/B testing, prompt registries, regression prevention, and evaluation pipelines. It enables teams to systematically control and optimize prompts without external dependencies.

This plugin provides statistical hypothesis testing and A/B experiment analysis through 3 Python tools using only the standard library, covering Z-tests, t-tests, chi-square tests, effect size calculations, power analysis, and Wilson score confidence intervals. It enables users to run sample size calculations and determine confidence intervals for experimental design and validation.

This plugin teaches AI coding agents to create promptfoo eval suites with deterministic assertions, provider configurations, and testing best practices. It provides a skill for generating and validating evaluation frameworks that help ensure consistent prompt and model performance.

DeepEval is an open-source LLM evaluation framework that provides metrics and tools for unit testing AI applications, agents, RAG pipelines, and chatbots using LLM-as-a-judge evaluation and locally-running NLP models. The plugin adds three skills to enable DeepEval evaluations, tracing, datasets, and integration with the Confident AI observability platform directly into Claude Code workflows.

An Agent Skill that enables coding agents to write and execute custom Playwright browser automation scripts on the fly, from simple page tests to complex multi-step flows with real-time visibility. The skill provides dev-server detection, portable script execution, and smart cleanup while letting Claude autonomously decide when to apply it based on automation needs.

This Claude Code plugin performs automated accessibility compliance testing against WCAG 2.1/2.2, ARIA standards, and other accessibility frameworks via the /a11y-scan command. It validates keyboard navigation, screen reader compatibility, color contrast, and generates fix recommendations and test scenarios for identified accessibility issues.

This plugin provides automated AI ethics and fairness validation through a command-line interface, implementing best practices and error handling for evaluating ML models. It requires Python 3.8+ and standard ML libraries, with no external API dependencies.

This plugin generates API contracts for consumer-driven contract testing using Pact, enabling teams to define and validate API interactions between services. It provides a single command to create contract definitions that enforce API compatibility across consumers and providers.

The api-fuzzer plugin performs fuzz testing on APIs by generating malformed inputs, edge cases, and security-focused payloads including SQL injection and XSS detection. It requires no external dependencies or API keys and operates through a simple `/fuzz-api` command.

This plugin enables load testing of APIs using k6, Gatling, or Artillery—three popular open-source performance testing frameworks. Users invoke a single command (/run-load-test) to configure and execute load tests against their APIs for performance validation.

Creates mock API servers directly from OpenAPI specifications, enabling developers to test client code against realistic endpoints without hitting production infrastructure. Features include stateful responses, configurable latency, error simulation, and procedurally generated test data.

This plugin validates API responses against JSON Schema, OpenAPI specs, and custom rules through a single command interface. It contains one command and one skill for automated schema validation without requiring external API keys or services.

This Claude Code plugin validates API schemas against multiple standards including JSON Schema, Joi, Yup, and Zod. It provides a /validate-schemas command that developers can use to ensure their API definitions conform to the specified validation framework.

This Claude Code plugin automatically generates comprehensive test suites for REST and GraphQL APIs, including authentication flows, CRUD operations, and contract validation against OpenAPI specs. It creates ready-to-run tests with fixtures, factories, and helpers that cover success paths, error scenarios, and security validation.

This Claude Code plugin connects to the Kobiton mobile testing platform, providing 5 skills to manage devices, upload apps, run automation sessions, and view test results directly from AI coding assistants. It integrates with Claude Code, GitHub Copilot CLI, Gemini CLI, Codex CLI, and Cursor, requiring only a Kobiton account and OAuth authentication.

This plugin analyzes application performance across CPU, memory, I/O, and database layers to identify bottlenecks and prioritize them by severity. It provides root cause analysis, remediation strategies with code examples, and prevention recommendations to resolve performance issues.

Cross-browser compatibility testing using Playwright for local development and four cloud platforms (BrowserStack, Sauce Labs, LambdaTest, Kobiton) for real-device validation across Chrome, Firefox, Safari, and Edge. Includes screenshot comparison, CSS/JS API scanning, accessibility audits, and CI/CD integration examples.

The chaos-engineering-toolkit agent helps design and validate resilience testing strategies through controlled failure injection, latency simulation, and system resilience experiments. It automatically activates when discussing system resilience, chaos experiments, or recovery mechanisms, and supports multiple chaos testing platforms including Chaos Mesh, Gremlin, AWS FIS, and Toxiproxy.

CLI UX Tester provides expert UX evaluation for command-line interfaces and developer APIs using an 11-criteria scoring framework and parallel evaluation agents. It executes real commands, captures output, generates comprehensive reports with remediation plans, and tracks patterns across projects using persistent memory.

Code-cleanup is a Claude Code plugin with 11 specialized agents that systematically identify and remediate code quality issues across dead code, type safety, security, performance, and dependency management. It uses confidence scoring and build verification gates to safely auto-apply low-risk fixes while flagging high-risk changes for human review.

This Claude Code plugin validates API contracts using Pact consumer-driven testing, OpenAPI validation, and breaking change detection across REST, GraphQL, and gRPC protocols. It integrates with CI/CD pipelines to automate contract verification and manage API evolution.

The cpu-usage-monitor plugin provides CPU hotspot detection, algorithmic complexity analysis, and blocking operation identification within Claude Code. It offers optimization suggestions for loops, regex patterns, and other performance bottlenecks.

The database-deadlock-detector plugin identifies and helps resolve database deadlocks across multiple database systems using best practices. It provides production-ready implementations with comprehensive documentation for analyzing and preventing deadlock scenarios.

Database Test Manager provides utilities for testing database operations including test data generation, transaction rollback, and schema validation across PostgreSQL, MySQL, SQLite, and MongoDB. The plugin integrates with popular ORMs like Prisma, TypeORM, Sequelize, and SQLAlchemy to streamline database test workflows.

This plugin generates realistic test data and database seed scripts with support for faker data, relational integrity, configurable volumes, and multi-language generation. It provides a single `/seed-data` command to quickly populate development and testing environments with functional datasets.

This plugin provides automated deep learning optimization workflows that implement best practices for model performance and error handling. It integrates directly into Claude Code via a single command-line interface.

This plugin generates end-to-end browser tests using Playwright, Cypress, or Selenium, supporting multi-framework automation with Page Object Models and cross-browser execution. It enables users to create complete user workflow tests with features like visual testing, mobile emulation, and network interception.

This plugin automates integration test execution with comprehensive environment setup, database seeding, service orchestration, and cleanup to prevent test pollution. It supports multiple test types (API, database, microservices, queues, etc.) and provides detailed reporting including pass/fail counts, coverage metrics, and execution times.

This plugin provides two internal validation skills for Intent Solutions' marketplace: audit-tests (a 7-layer test-suite auditor) and validate-skillmd (a 4-tier SKILL.md validator). These are dogfood tools used to run quality gates on the labs.intentsolutions.io marketplace during nightly evaluation runs.

Load Balancer Tester simulates and validates load balancing strategies including traffic distribution, failover behavior, and health checks. It provides tools to verify sticky session handling and test resilience of load balancing configurations.

This plugin generates and provides execution instructions for load tests using tools like k6, JMeter, or Artillery to validate application performance. It supports multiple test scenario types, performance thresholds, and includes CI/CD integration guidance.

The memory-leak-detector plugin scans application code to identify potential memory leaks including event listeners, closures, timers, cache growth, circular references, and DOM reference issues. It provides detailed analysis of memory usage patterns and fix recommendations for detected problems.

This Claude Code plugin automates testing for iOS and Android mobile apps using frameworks like Appium, Detox, XCUITest, and Espresso, generating end-to-end test suites with gesture handling and performance metrics. It supports both native and React Native applications across simulators, emulators, and real devices, including integration with cloud device farms like AWS Device Farm and BrowserStack Mobile.

The model-evaluation-suite plugin provides comprehensive model evaluation with multiple metrics through an automated workflow command. It implements best practices for performance optimization and error handling using standard ML libraries.

The mutation-test-runner plugin validates test suite quality by automatically introducing code mutations (arithmetic, logical, and conditional changes) and verifying whether existing tests catch these synthetic bugs. It provides mutation score calculations and survivor analysis to identify gaps in test coverage across frameworks like Stryker, PITest, mutmut, and Mutant.

This plugin enables Claude to autonomously develop features overnight by using Git pre-commit hooks that enforce test-driven development and block commits until all tests pass. Claude iterates automatically on failing tests, debugging and fixing code until it reaches production-ready quality while you sleep.

Performance Budget Validator creates and validates performance budgets across multiple metrics including load times, bundle sizes, and API latency, with built-in Lighthouse score tracking and CI/CD integration. The plugin includes violation alerting and remediation workflows to prevent performance regressions.

The performance-regression-detector plugin identifies performance regressions early in CI/CD pipelines through baseline comparison testing and statistical significance analysis. It integrates with your build process to detect threshold violations, analyze trends, and automatically comment on pull requests when issues are found.

This Claude Code plugin provides an intelligent agent for designing and analyzing load tests, stress tests, spike tests, and endurance tests with automatic bottleneck identification and performance recommendations. It generates test scripts for popular tools like k6, JMeter, Gatling, Locust, and Artillery while collecting and interpreting response time, throughput, resource utilization, and system metrics.

This plugin tracks and runs regression tests before deployments, identifying which tests are affected by code changes and detecting flaky tests. It provides test history trends and optimized test selection to ensure new changes don't break existing functionality.

This Claude Code plugin automates security vulnerability testing across OWASP Top 10 categories including SQL injection, XSS, CSRF, authentication, and authorization flaws, generating detailed severity-rated security reports with PoC and remediation guidance. It operates as a single agent with embedded skills that activates when users discuss security testing scenarios.

This plugin adds an audit-skill to Claude Code that runs the free skillcrossroads CLI to grade skills, subagents, slash commands, and plugins with evidence-cited scorecards and automated fix suggestions. Keyless scans score deterministically; optionally setting ANTHROPIC_API_KEY upgrades triggering logic to an LLM judge and enables three additional checks.

The smoke-test-runner plugin provides quick validation suites to verify critical functionality after deployments, running complete test passes in under 5 minutes. It performs health checks, authentication tests, core feature validation, and integration checks with clear pass/fail results and rollback recommendations.

Manages and updates snapshot tests by performing intelligent diff analysis to distinguish intentional changes from regressions, with selective update capabilities across Jest, Vitest, Playwright, and Storybook frameworks. The plugin can validate snapshot quality, organize snapshot files, and recommend whether to update, review, or preserve specific snapshots.

This Claude Code plugin sets up comprehensive synthetic monitoring for applications, enabling proactive performance tracking across uptime, transactions, API endpoints, and SSL certificates. It includes multi-location testing, alert configuration, and incident response playbooks.

The test-coverage-analyzer plugin analyzes code coverage metrics across multiple dimensions (lines, branches, functions, statements) and identifies untested code to generate comprehensive coverage reports. It supports coverage trends, threshold enforcement, and visual coverage maps to help track and improve test coverage over time.

This plugin generates realistic test data across multiple domains including users, products, orders, and custom schemas, with support for bulk generation, locale variations, and deterministic seeding for reproducible testing. It handles realistic personal data, business data, and technical identifiers without requiring external API keys or services.

Generates mocks, stubs, spies, and fakes for unit testing across Jest, Sinon, unittest.mock, Mockito, Moq, and RSpec frameworks. The plugin analyzes code dependencies to recommend appropriate test double types and provides complete examples with test fixtures following framework conventions.

Manages isolated test environments using Docker Compose and Testcontainers with automatic health checks and cleanup. Provides environment variable management and service orchestration for testing workflows.

This plugin orchestrates complex test workflows with dependency management, parallel execution, and intelligent test selection to optimize CI/CD pipelines. It includes features for smart test selection based on code changes, retry strategies for flaky tests, and resource optimization.

This Claude Code plugin generates comprehensive test reports from multiple test frameworks with coverage metrics, trends, and historical comparisons. It exports reports in HTML, PDF, and JSON formats for stakeholder communication and failure analysis.

The unit-test-generator plugin automatically creates comprehensive unit tests from source code with intelligent framework detection, supporting Jest, pytest, JUnit, RSpec, and seven other testing frameworks across eight programming languages. It generates test suites with proper mocking, edge case coverage, and best-practice structure following Arrange-Act-Assert patterns.

Visual regression testing plugin that compares screenshots against baselines to detect unintended UI changes across Percy, Chromatic, and BackstopJS. The plugin integrates with Playwright, Puppeteer, and Cypress to capture and analyze visual diffs across multiple viewport sizes with CI/CD pipeline support.

This plugin guides designers through design validation by providing skills and commands for prototyping strategies, usability testing, heuristic evaluation, and A/B experiments. It covers the full range of testing approaches from parallel concept exploration and click tests to accessibility testing and quantitative A/B experiments.

A debugging specialist agent that diagnoses errors, test failures, and unexpected behavior in your code. It can be invoked proactively whenever issues arise to help identify and resolve problems.

This plugin provides a rigorous performance investigation workflow that establishes baselines, runs controlled sequential benchmarks, and performs profiling to identify hotspots. It consolidates findings into evidence-backed recommendations with structured logging and version-specific baselines.

This agent automatically writes new tests, runs existing test suites, analyzes failures, and fixes issues after code modifications. It ensures comprehensive test coverage and maintains suite health throughout the development lifecycle.

This plugin provides a security testing skill based on the WooYun business logic vulnerability methodology, drawing from analysis of 22,132 real vulnerability cases across 6 domains and 33 vulnerability classes. It equips developers with a structured approach to identify and test for common business logic flaws in applications.

This skill provides 29 production-ready scripts for iOS app testing, building, and automation on Apple simulators, covering semantic UI navigation, build automation, accessibility testing, and simulator lifecycle management. It requires no external API keys or third-party services and integrates directly with Xcode's simulator infrastructure.

This plugin audits test suites to identify and remove redundant tests that merely restate code logic rather than catching real bugs. It helps maintain focused, high-quality test coverage by filtering out unnecessary assertions.

This plugin provides browser automation skills for AI agents to programmatically navigate web pages, fill forms, and interact with web applications. It exposes two skills that enable agents to perform end-to-end testing and web automation tasks without external service dependencies.

The api-tester agent provides comprehensive API testing capabilities including performance, load, and contract testing to ensure APIs are robust and meet specifications before deployment. It functions as a standalone testing agent without external dependencies or third-party service requirements.

This plugin acts as a universal quality control orchestrator that dynamically discovers and coordinates with available sub-agents to perform comprehensive multi-dimensional quality assessment, security validation, and deployment readiness verification across any project type. It provides enterprise-grade quality standards validation regardless of programming language or development framework.

This plugin takes a GitHub issue number as input, analyzes the issue context, implements a solution, and validates the fix through testing to ensure proper integration. It automates the end-to-end workflow of addressing issues without requiring external API keys or tools.

Bullpen is a Claude Code plugin that bundles ten opinionated coding skills (skeptic, closer, attacker, fact-checker, interrogator, stop-digging, doorman, historian, chameleon, explainer) that enforce senior engineering discipline—pushing back on bad assumptions, verifying code works, catching security flaws, and ensuring reviewable commits. Each skill can be invoked by name at varying intensity levels (lite, full, ultra) to make AI agents code with senior-engineer rigor and judgment.

This Claude Code plugin provides comprehensive performance testing, profiling, and optimization recommendations by measuring application speed and identifying bottlenecks. It delivers actionable optimization strategies to help developers improve application performance.

The PR Review Toolkit bundles 6 specialized agents that each analyze a specific aspect of code quality: comments, test coverage, error handling, type design, general code review, and code simplification. Each agent provides structured, actionable feedback with severity scoring and specific recommendations for improvement.

slicewise enforces a disciplined development loop where every commit unit receives dual-model review with reconciliation and a full test gate before you manually decide what to commit. The plugin is stack-agnostic via optional config and auto-detection, providing a skill, read-only reviewer agent, and explicit `/slicewise` command entry point.

Analyzes test results and synthesizes test data to identify trends and generate quality metrics reports that drive improvements. The agent transforms raw test data into actionable insights for quality assurance and monitoring.

The test-writer-fixer agent automates test creation, execution, and failure analysis after code modifications to maintain comprehensive test coverage and suite health. It proactively detects test failures from code changes and fixes them while preserving test integrity.

A Flutter/Dart unit test specialist agent that systematically increases test coverage through automated workflows, strict validation, and Git management aligned with Aurigo corporate standards. The plugin automates comprehensive test suite creation and coverage improvement with no external dependencies required.

A debugging agent that identifies and resolves errors, test failures, and unexpected behavior in code. It proactively analyzes issues and provides diagnostic guidance without requiring external tools or API integrations.

This plugin generates comprehensive test suites for individual files by analyzing their content and structure. It provides a command-line interface to create thorough test coverage tailored to specific code files.

Blast Radius is a local Claude Code plugin that analyzes reverse import impact and identifies related test candidates within a repository by tracking file dependencies. It stores analysis state locally per working directory and session, with no network calls or automatic code modifications.

Verify Board is a local Claude Code plugin that tracks revision-aware verification results (PASS, FAIL, STALE, UNKNOWN) for code changes using Git metadata and explicit command-based checks. It stores verification state isolated by working directory and session, with no external network calls or model inference, and provides terminal-usable reports via /verify commands.

This lightweight plugin provides 12 reusable skills covering coding best practices, testing principles, and design guidelines for seamless integration into existing developer workflows. No recipe workflows or agents are included—it's designed as a pure skill library for users who manage their own automation.

This Claude Code plugin automatically generates 2–3 multiple-choice and short-answer questions after Claude completes a task that modifies code or content, helping users verify understanding of the changes. Questions can be saved as spaced-repetition cards to an explain-this deck, and the quiz runs in a forked model call that reuses the main thread's prompt cache to minimize token costs.

Canary is a QA harness for Claude Code that automates browser testing by reading code diffs, identifying affected UI flows, and executing them in real browser instances using Playwright within a QuickJS WASM sandbox. Every run generates both a detailed session report (with traces, videos, console logs, and network data) and a reusable Playwright script for CI replay without inference costs.

Parseltongue provides specialized Python development patterns for testing with pytest and TDD, performance profiling with cProfile and memory analysis, asyncio concurrency patterns, and packaging configuration using pyproject.toml and uv. It includes four agents and three commands that integrate with standard Python tools like ruff, mypy, and support frameworks including FastAPI, Django, and SQLAlchemy.

The debugging-code skill teaches Claude how to interactively debug source code by setting breakpoints, stepping through execution, inspecting variables, and evaluating expressions using the Debug Adapter Protocol. It includes both a Claude Code skill and a dap CLI tool that works with Python, Go, Node.js, Rust, C, C++, and supports remote debugging and process attachment.

Quality Gate measures JavaScript and TypeScript code complexity, function coverage, and CRAP scores by analyzing the AST and V8 coverage data, failing when per-function CRAP exceeds 5. It runs as a local command-line tool without requiring external services or modifying the project configuration.

han-coding provides 11 specialist skills for writing, reviewing, testing, investigating, and standardizing code through BDD-framed test-driven development, refactoring under test, comprehensive code review, and architecture analysis. It dispatches parallel agents for each coding dimension and requires han-core and han-communication dependencies.

This plugin provides a skill for verifying API contracts between services using consumer-driven contracts, schema validation, and tools like Pact. It helps test microservices communication and prevent breaking changes through OpenAPI specification validation.

This skill provides expert guidance for testing REST APIs and GraphQL endpoints using Supertest (TypeScript) and httpx/pytest (Python), covering request/response validation, authentication, error handling, and schema validation. It helps developers write comprehensive API tests with patterns for HTTP methods, headers, authentication flows, file uploads, and error assertions.

This skill provides comprehensive guidance for using Cloudflare Browser Rendering with Puppeteer and Playwright to automate headless Chrome on Cloudflare Workers for screenshots, PDFs, web scraping, and error handling. It includes auto-trigger keywords, configuration templates, known issues prevention patterns, and performance optimization strategies like session reuse and incognito contexts.

Conducts systematic 7-phase frontend design reviews covering interaction flows, responsiveness, visual polish, accessibility (WCAG 2.1 AA), robustness, code health, and console errors using browser automation. Automatically triggers on PR design checks, UI audits, accessibility concerns, responsive issues, and contrast problems to provide evidence-based feedback prioritized by impact.

This skill generates comprehensive Jest unit test suites for JavaScript/TypeScript code, including proper mocking patterns, async/timer handling, and React component testing with coverage targets. It automates test file structure following best practices with describe blocks, setup/teardown, snapshots, and dependency mocking.

This plugin provides debugging assistance for mobile apps on iOS, Android, and cross-platform frameworks, helping diagnose crashes, memory leaks, performance issues, and network problems. It guides users through tools like Xcode Instruments, Android Profiler, React Native Debugger, and native bridge error resolution.

This plugin provides a single skill for mobile app testing covering unit tests, UI automation, and performance testing across test infrastructure and end-to-end scenarios. It assists with test framework setup, device farm configuration, flaky test resolution, and platform-specific test errors.

This skill provides expert guidance on mutation testing for TypeScript/JavaScript projects (via Stryker and its Vitest or Bun runners) and Python projects (via mutmut), helping developers identify weak tests by introducing deliberate code mutations and analyzing test resilience. It helps validate test effectiveness and improve test quality by identifying assertions that don't catch intentional code changes.

This skill provides comprehensive guidance for Pinia v3, Vue's official state management library, covering store creation with defineStore, getters, actions, SSR hydration, testing strategies, and Vuex migration patterns. It addresses common issues like reactivity loss from destructuring, circular store dependencies, and HMR configuration to help developers build scalable Vue 3 applications.

A Claude Code skill for browser automation and end-to-end testing with Playwright, featuring auto-detection of dev servers, clean test script generation, and cross-browser testing capabilities. It includes a helper library for common tasks like safe clicks/typing, screenshot management, and cookie banner handling, executable via a universal JavaScript/TypeScript runner.

This skill provides a systematic methodology for tracing bugs backward through the call stack to identify the original trigger instead of fixing symptoms where errors appear. It guides developers through a five-step process—observing symptoms, finding immediate causes, tracing the call chain upward, and locating where invalid data originated—with practical tips for stack trace analysis and defense-in-depth validation.

This skill enforces a disciplined four-phase debugging framework—root cause investigation, pattern analysis, hypothesis testing, and implementation—that prioritizes understanding over quick fixes and prevents proposing solutions before tracing data flow. It auto-triggers on debugging-related queries and enforces the principle that no fixes can be proposed until Phase 1 (root cause investigation) is completed.

A Claude Code skill that detects test smells, overmocking, flaky tests, and coverage issues to help developers improve test quality and maintainability. It provides expert guidance on identifying anti-patterns, weak assertions, and adherence to testing best practices like FIRST principles and the AAA pattern.

Expert knowledge for testing JavaScript/TypeScript projects using Vitest with native ESM support, comprehensive mocking, and Vite-powered HMR for instant watch mode. Provides guidance on fast unit and integration testing, component testing, and migration workflows with Jest-compatible API.

This plugin provides web performance audits that analyze Core Web Vitals, identify performance bottlenecks, and recommend optimizations for issues like LCP, FID, and CLS. It helps developers review page load times and resolve resource blocking and render delays.

This skill guides developers in authoring WooCommerce backend PHP code that adheres to WordPress coding standards, naming conventions, and dependency injection patterns. It provides standards for file organization, docblocks, validation, and PHPUnit testing to ensure production-ready implementations.

This skill reviews WooCommerce code changes against WordPress and WooCommerce coding standards, detecting violations and providing structured reporting for pull requests and local code reviews. It integrates with backend development, UI text guidelines, and testing standards to ensure consistent code quality across WooCommerce projects.

This skill guides developers through WooCommerce project testing, linting, and quality checks using PHPUnit, phpcs, phpcbf, markdownlint, and WordPress coding standards. It provides troubleshooting and best practices for maintaining code quality throughout the WooCommerce development workflow.

Provides skills and commands for defining evaluation criteria, measuring AI output quality through rubrics and metrics, and tracking product performance over time. Includes task success measurement, user satisfaction analysis, comparative testing, and AI-specific failure classification to assess both system effectiveness and user experience.

Expert guidance for Kotlin Coroutines structured concurrency, including safe scopes, Dispatchers, cancellation, and exception handling best practices. Provides compile-time checkers, Detekt rules, Android Lint detectors, and a playbook for reviewing or writing Kotlin/Android async code.

crap-analyzer detects risky code patterns by computing Change Risk Anti-Patterns (CRAP) scores for recently-changed functions across 10 programming languages, auto-discovering the repo's test coverage framework and proposing safe refactors and test stubs. It ranks findings by risk, generates markdown reports with unified diff fixes, and can apply refactors after confirmation.

This plugin audits digital products for WCAG 2.1/2.2 compliance using automated scanning with axe-core and Puppeteer, manual verification checklists, and a visual validator agent that systematically checks keyboard navigation, screen reader compatibility, color contrast, and responsive design. It generates scored HTML reports, integrates with GitHub Actions CI/CD pipelines, and provides remediation code examples for React components and DOM fixes.

This plugin provides an api-documenter agent for creating interactive API documentation with OpenAPI 3.1, AsyncAPI, and SDK generation, plus an api-mock command for building stateful mock servers with scenario management and contract validation. It enables comprehensive API lifecycle management from specification authoring through interactive developer portals and parallel development workflows.

This Claude Code plugin provides four specialized agents (backend-architect, graphql-architect, tdd-orchestrator, temporal-python-pro) and five skill modules for comprehensive backend system design, including REST/GraphQL/gRPC APIs, microservices decomposition, test-driven development governance, and Temporal workflow orchestration. It equips teams with proven architecture patterns, TDD enforcement strategies, and production-ready implementation guidance for distributed systems and enterprise-scale APIs.

Developer Essentials provides 8 foundational skills covering code review, Git workflows, authentication, error handling, debugging, SQL optimization, monorepo management, and E2E testing that Claude automatically references when relevant. These skills activate contextually to provide constructive feedback, patterns, and best practices without requiring explicit agent invocation.

This Claude Code plugin provides two specialized agents and a command for debugging distributed systems and microservices, covering incident response, log analysis, trace configuration, and Kubernetes troubleshooting. It handles observability platforms (ELK, DataDog, Jaeger), error pattern recognition, and production debugging setups without requiring external API keys or services.

This plugin orchestrates four specialized agents—test automation, performance optimization, deployment, and security auditing—through a structured 12-step workflow to deliver production-ready full-stack features across backend, frontend, and infrastructure layers. It coordinates database design, implementation, testing, security, CI/CD setup, and observability into a cohesive end-to-end delivery pipeline.

This plugin provides two expert agents for modern JavaScript (ES6+) and TypeScript development with four skill guides covering testing patterns, advanced type systems, Node.js backend patterns, and language features. It includes a typescript-scaffold command to generate production-ready project structures for Next.js, React, Express, Fastify, libraries, and CLI tools.

This plugin extends Claude Code with browser DevTools capabilities via Model Context Protocol, enabling live DOM inspection, CSS analysis, and screenshot-to-code conversion on running web applications. It supports visual debugging, design token extraction, accessibility auditing, and performance measurement through Puppeteer and Chrome DevTools Protocol.

This plugin provides AI-powered code review, test automation, and performance analysis through two specialized agents (performance-engineer and test-automator) plus two review commands that integrate static analysis tools (SonarQube, CodeQL, Semgrep, Snyk, TruffleHog) with LLM-assisted contextual analysis across 30+ languages. It supports performance profiling, load testing, test generation with TDD practices, self-healing tests, and multi-agent review orchestration with built-in CI/CD integration for GitHub Actions, GitLab CI, and Azure DevOps.

The Python Development plugin provides a Python expert agent and five skills for modern Python development with Python 3.13+, covering async patterns, testing with pytest, packaging, performance optimization, and the uv package manager. It enables production-ready code scaffolding, code review, and optimization for FastAPI, Django, and other Python frameworks.

This plugin provides two specialized agents (bash-pro and posix-shell-pro) and three skills for writing production-grade shell scripts with defensive programming, POSIX compliance, comprehensive testing via Bats, and ShellCheck static analysis. It covers both modern Bash 5.x features and strict POSIX portability across Unix-like systems, with patterns for error handling, logging, CI/CD integration, and test infrastructure.

This plugin enforces test-driven development discipline through a tdd-orchestrator agent and code-reviewer agent, providing four commands for red-green-refactor cycles with coverage validation, anti-pattern detection, and multi-language test generation and implementation strategies. It integrates with property-based testing and mutation testing while tracking TDD metrics and supporting both Chicago and London School approaches.

This plugin provides automated test generation, debugging, and AI-powered test automation for Python and JavaScript with two specialized agents: test-automator for framework expertise and self-healing tests, and debugger for root cause analysis. The test-generate command analyzes code structure to create framework-appropriate unit test suites with mock objects and coverage gap analysis across multiple languages.

This plugin audits digital products for WCAG accessibility compliance using automated axe-core scanning, color contrast analysis, keyboard navigation testing, and screen reader validation. It includes a visual validation agent that manually verifies UI accessibility through systematic screenshot analysis and generates scored HTML reports with remediation code examples.

This plugin provides an AI-powered API documentation specialist (api-documenter agent) for creating OpenAPI 3.1 and AsyncAPI specifications with interactive developer portals and multi-language SDK generation, plus a comprehensive mock server command (api-mock) built on FastAPI for stateful API simulation with scenario management and contract validation. It supports the full API testing and documentation lifecycle including specification authoring, interactive portals, SDK generation, developer portal design, migration support, and CI/CD integration.

The Codebase Cleanup plugin provides AI-powered code review, dependency auditing, and technical debt analysis through two specialized agents and three commands for identifying and resolving code quality issues. It integrates with tools like SonarQube, CodeQL, Semgrep, and Snyk to automate security vulnerability detection, performance optimization, test automation, and structured refactoring workflows.

Developer Essentials is a skills-only plugin providing 8 foundational knowledge areas: Code Review Excellence, Git Advanced Workflows, Auth Implementation, Error Handling Patterns, Debugging Strategies, SQL Optimization, Monorepo Management, and E2E Testing Patterns that Claude automatically references when relevant. These skills deliver systematic approaches, best practices, and anti-patterns across professional development workflows without agents or commands.

This Claude Code plugin provides root cause analysis agents and commands for diagnosing application errors with stack traces, log correlation, and error tracking. It includes specialized agents for debugging and log analysis, commands for systematic error resolution and observability setup, and a multi-agent code review orchestration system.

This plugin orchestrates four specialized agents (test-automator, performance-engineer, deployment-engineer, security-auditor) through a 12-step, 4-phase workflow to deliver production-ready full-stack features spanning backend, frontend, infrastructure, testing, security, and deployment. It coordinates cross-cutting concerns including database design, API contracts, performance optimization, CI/CD setup, security auditing, and observability without requiring external API keys or tools.

This plugin provides expert agents for JavaScript and TypeScript development, covering ES6+ patterns, async programming, advanced type systems, Node.js backend development, and testing infrastructure. It includes a project scaffolding command to generate complete TypeScript project structures for Next.js, React+Vite, Node.js APIs, libraries, and CLI tools.

Expert agent for Julia 1.10+ development covering scientific computing, performance optimization, package management, and production-ready practices across the Julia ecosystem. Provides guidance on type stability, multiple dispatch, numerical algorithms, data science pipelines, and web APIs using modern Julia tooling and best practices.

This plugin extends Claude Code with browser DevTools capabilities via MCP for live UI inspection, screenshot-to-code conversion, design token extraction, and visual debugging of running web interfaces. It provides DOM inspection, CSS analysis, accessibility auditing, performance measurement, and network monitoring through natural language commands.

This plugin provides two specialized agents for performance engineering and test automation, combined with two code review commands that integrate static analysis tools (SonarQube, CodeQL, Semgrep, Snyk, TruffleHog) with LLM-powered analysis across 30+ languages. The performance-engineer agent profiles applications and designs load tests, while the test-automator agent generates tests using TDD practices and self-healing frameworks, with both review workflows supporting GitHub Actions, GitLab CI, and Azure DevOps integration.

This plugin provides production-ready Python development with 5 skills covering async patterns, testing, packaging, performance optimization, and the uv package manager. It includes a Python expert agent and project scaffolding command that work with Python 3.13+, Django, FastAPI, and modern tooling.

This plugin provides two expert agents (bash-pro and posix-shell-pro) and three reference skills for writing production-grade shell scripts with defensive patterns, testing via Bats, and ShellCheck linting configuration. It covers both modern Bash 5.x and portable POSIX sh scripting for automation, CI/CD pipelines, and system utilities.

This plugin provides a complete test-driven development workflow system with a dedicated orchestrator agent and code review agent that enforce the red-green-refactor discipline across projects. It includes four commands that map to TDD phases and track TDD metrics, supporting both Chicago School and London School approaches with configurable coverage thresholds and anti-pattern detection.

Provides automated test generation, execution, and debugging for Python and JavaScript with two specialized agents: a test-automator expert in modern frameworks and AI-powered testing strategies, and a debugger for root-cause analysis of test failures. The plugin includes a command for automated unit test generation from code analysis and integrates with other testing workflows.

assay is a deterministic QA CLI that automatically discovers and tests all controls on a web page by interacting with them, without requiring written tests or LLM inference. It works as a standalone tool, a cross-harness skill for coding agents, and a Claude Code plugin that automatically validates pages after each turn.

This Claude skill applies pairwise independent combinatorial testing (PICT) to systematically design test cases from requirements or code, generating PICT models with parameters, values, and constraints that drastically reduce test case count while maintaining high coverage. It outputs the PICT model, markdown tables of test cases, and expected results for any domain including software functions, APIs, web forms, and configurations.

Paideia is an exam-prep workspace plugin for math, physics, and engineering courses that ingests PDFs via a vision pipeline (Claude native, local Qwen3-VL, or Tesseract), extracts homework-density-weighted patterns, and drills students through twins, blinds, chains, and mock exams before grading hand-written answer PDFs. All artifacts—patterns, coverage logs, weakness maps, and cheatsheets—are stored locally as markdown in your git history with no SaaS database.

StatsClaw is a multi-agent workflow framework for Claude Code that coordinates 9 specialized AI agents to help researchers build, test, and document statistical software packages with isolated code, test, and simulation pipelines. It supports R, Python, Julia, Stata, TypeScript, Go, Rust, C, and C++, using adversarial verification to validate correctness when all pipelines converge independently.

Beagle-python provides seven specialized code-review skills for Python backends using FastAPI, SQLAlchemy, PostgreSQL, and pytest, analyzing patterns like async handlers, session management, and test fixtures. It pairs with beagle-core to form a complete workflow for Agent Skills and Claude Code platforms.

beagle-react provides 28 Agent Skills for comprehensive code review of React, React Flow, React Router, Remix v2, shadcn/ui, Tailwind, Vitest, and Zustand codebases. Skills cover framework-specific patterns, architectural guidance, best practices, and anti-pattern detection across frontend and full-stack workflows.

beagle-rust provides 12 specialized Agent Skills for comprehensive Rust code review, covering ownership, lifetimes, error handling, async/tokio, serde, sqlx, axum, macros, FFI, unsafe code, concurrency, and testing patterns. The plugin includes both a fan-out orchestration skill and focused review skills for individual technology areas.

Generates and executes language-agnostic end-to-end test plans by detecting the tech stack, tracing branch changes to user-facing flows, and running them step-by-step with optional browser testing via agent-browser. Includes two skills: gen-test-plan for creating YAML test plans and run-test-plan for sequential execution with rich debug output on failures.

A Claude Code plugin that transforms the assistant into a senior Delphi expert, automatically applying the Delphi Style Guide, Clean Code principles, and SOLID patterns when Delphi files are detected. It provides commands for technical audits, code reviews, standardized code writing, project scaffolding, TDD test generation, and specification auto-generation, with support for both Portuguese and English output.

This plugin provides 14 skills for planning, implementing, and validating causal inference analyses in R and Python, covering methods from A/B testing and difference-in-differences to instrumental variables and synthetic control. It guides users through question refinement, method selection, assumption checking, stress-testing, and executive reporting without requiring external API keys or services.

This plugin guides Claude through writing and testing goast Rego policies for Go static analysis, covering the AST input format, Rego v1 rule contract, practical recipes, and the declarative testing workflow. goast allows teams to enforce custom internal conventions on Go codebases by expressing rules as OPA/Rego policies that match against the Go AST.

Bench is a Claude Code plugin that provides API performance benchmarking capabilities, including latency profiling, throughput testing, and performance regression detection. It includes one agent and three skills to help developers analyze and optimize API performance.

This plugin provides statistical experiment design and analysis tools including A/B testing, power analysis, and causal inference capabilities for data science teams. It bundles one agent and three reusable skills to help researchers design experiments, track results, and draw causal conclusions from data.

This plugin provides an eval harness design framework with benchmark suites, automated regression testing, and human evaluation pipeline orchestration for AI systems. It includes one agent and five skills to support comprehensive evaluation workflows without requiring external dependencies.

This plugin provides API mocking capabilities including mock server design, contract testing, and API simulation for development environments. It bundles an agent with three supporting skills to help developers prototype and test API integrations without external dependencies.

This QA & testing engineer plugin provides test strategy guidance, end-to-end test suite design, integration testing support, test infrastructure setup, and flaky test triage to help developers improve testing practices. The plugin includes one agent and seven supporting skills for comprehensive testing assistance.

Capacitor quality provides 7 skills for testing, debugging, logs, performance, accessibility, security, and Xcode build hardening of Capacitor projects. It requires no external dependencies, API keys, or tools and operates entirely within the Claude environment.

Visual regression testing plugin that compares Figma designs against live web pages using pixel-level image diff and AI vision analysis to categorize discrepancies as bugs, drift, or acceptable browser rendering differences. The plugin exports Figma frames via API, screenshots web pages through Playwright, performs pixel-level comparison with region detection, and generates an HTML report with AI-driven categorization of visual issues.

The review-tests plugin reads an existing test file and diagnoses blind spots—like weak assertions, missing edge cases, mock health issues, and async bugs—then outputs a self-contained HTML report with backlinks to the source under test. It is read-only and never modifies code, operating as a diagnosis tool that points out gaps for you to fix with TDD.

This plugin provides WCAG accessibility auditing and compliance validation directly within Claude Code, testing UI elements for screen reader compatibility and keyboard navigation. It enables developers to verify inclusive design practices without external dependencies or paid services.

The api-testing-observability plugin provides API testing automation, request mocking, OpenAPI documentation generation, and observability setup capabilities through a command and agent interface. It enables developers to test APIs, generate specs, and establish monitoring without requiring external third-party services.

The data-validation-suite plugin provides schema validation, data quality monitoring, streaming validation pipelines, and input validation capabilities for backend APIs. It integrates as a Claude Code agent to enable comprehensive data integrity checking across different data processing scenarios.

This Claude Code plugin provides error analysis, trace debugging, and multi-agent problem diagnosis through 3 commands and 2 agents. It requires no external APIs or tools, making it fully self-contained for local error investigation workflows.

This plugin provides end-to-end feature orchestration with four integrated agents that handle testing, security, performance, and deployment workflows. It combines these four capabilities into a unified orchestration pipeline accessible through a single command.

This Claude Code plugin automates performance analysis and test coverage review through two dedicated agents that assess code quality metrics and execution efficiency. It provides AI-powered code quality assessment without requiring external API keys or tools, operating entirely within Claude's capabilities.

This plugin provides playtesting and game analytics capabilities for LibreGameDev, including session design protocols, observation techniques, death heatmaps, funnel analytics, and A/B testing methodology. It includes a coordinator agent, design command, and pattern library with reusable components like heatmap rendering, event logging, zone timers, and deterministic test assignment.

This plugin provides production-grade Bash scripting assistance with defensive programming patterns, POSIX compliance validation, and comprehensive testing strategies. It includes 2 agents and 3 skills to help developers write robust, maintainable shell scripts.