Claude Skills for Testing

Claude skills for testing record how your project tests: what counts as sufficient coverage, which scenarios are mandatory, how cases are named, and where the line sits between a unit and an integration test. Without those rules a model writes formally correct tests that verify the wrong things. The classic failure of generated tests is that they lock in the implementation instead of the behavior. The test asserts that one function called another, then breaks on any refactor while telling you nothing about whether the feature works. "Assert the observable result, not internal calls" is exactly the kind of rule a skill exists to hold. The other half of the rules covers mandatory scenarios: empty input, a failing external service, a repeated request. A model skips those not from incompetence but because nobody asked for them.

The second recurring task is triaging a failed run. In a cascade of forty red tests there is usually one real cause. The skill defines the order of work: find the first failure, separate consequences from causes, reproduce with a minimal case — and only then fix.

The collection below covers unit tests, E2E scenarios, coverage work and failure triage.

Skills in this collection

358 skills in this collection; the 24 highest-rated are listed below.

• TDD-цикл с контрольными точками и Git — workflow-patterns is a Claude Code skill that implements Conductor's TDD workflow, covering phase checkpoint management, Git commit handling, and a structured quality verification protocol. It guides the full red-green-refactor cycle — always writing failing tests first, then implementing tasks sourced from a track's plan.md, and enforcing quality gates before marking any work complete. Key operations include creating focused git commits with rich notes, updating plan.md immediately after task completion, waiting for checkpoint approval before proceeding, and maintaining coverage above the defined target. Detailed pattern documentation and worked examples are stored in `references/details.md`. The skill suits developers who need a disciplined, auditable development process with sequential phases and clear quality assurance checkpoints.
• Тестирование Temporal workflows на Python — temporal-python-testing is a Claude Code skill that helps test Temporal workflows in Python using pytest, time-skipping, and mocking strategies. It covers three testing levels: unit tests with WorkflowEnvironment and time-skipping (month-long workflows complete in seconds), integration tests with mocked activities to isolate workflow logic, and replay tests to validate determinism before deployment. Resources are organized into separate files — `resources/unit-testing.md`, `resources/integration-testing.md`, `resources/replay-testing.md`, and `resources/local-setup.md` — loaded progressively based on the task at hand. The skill also includes guidance on local development setup with Docker Compose, pytest configuration, and CI/CD integration, targeting ≥80% code coverage for production Temporal applications.
• Аудит доступности по стандарту WCAG 2.2 — wcag-audit-patterns is a Claude Code skill that conducts WCAG 2.2 accessibility audits combining automated testing, manual verification, and actionable remediation guidance. It covers all three conformance levels — A, AA, and AAA — along with the four POUR principles: Perceivable, Operable, Understandable, and Robust. Violations are categorized by severity, from critical blockers like missing alt text and keyboard inaccessibility to moderate issues such as improper heading hierarchy and absent language attributes. Teams preparing for ADA, Section 508, or VPAT compliance reviews, as well as developers building accessible UI components from scratch, will find it especially useful. Extended patterns and worked examples are stored in `references/details.md`.
• Визуальная проверка UI по эталонным скриншотам — visual-verdict is a Claude Code skill that compares generated UI screenshots against one or more reference images and returns a strict JSON verdict to drive the next edit iteration. It accepts reference_images[], a generated_screenshot, and an optional category_hint (e.g., hackernews, dashboard, sns-feed), then outputs a structured object containing score (0–100), verdict (pass / revise / fail), category_match, concrete differences[], actionable suggestions[], and a short reasoning summary. The pass threshold is 90: while the score stays below it, the skill requires continuing edits and re-running before any further visual review. When mismatch diagnosis is difficult, pixel-level diff tooling serves as a secondary debug aid to localize hotspots, which are then translated into specific differences and suggestions entries. It is built for teams that need deterministic, automatable visual fidelity checks during UI development, design review, or regression testing workflows.
• Тестирование с экранными читалками NVDA, JAWS и VoiceOver — screen-reader-testing is a Claude Code skill that guides testing web applications with screen readers — VoiceOver, NVDA, JAWS, TalkBack, and Narrator — to validate assistive technology compatibility. It covers all five major readers with real-world usage shares (JAWS 40%, NVDA 31%, VoiceOver 15%, TalkBack 10%, Narrator 4%), recommended browser/OS pairings, and a tiered coverage strategy from minimum to comprehensive. The skill includes complete keyboard command references for each reader, structured test scripts, and checklists covering headings, landmarks, forms, dynamic content, and tables. HTML fix examples demonstrate correct use of aria-label, aria-live, aria-describedby, and role="alert". Designed for developers and QA engineers who need to debug ARIA implementations, ensure WCAG compliance, and deliver interfaces that work reliably for blind and low-vision users.
• Тестирование смарт-контрактов на Solidity — web3-testing is a Claude Code skill that provides comprehensive smart contract testing for Solidity using both Hardhat and Foundry. It covers unit tests, integration tests, fuzz testing for edge cases, gas optimization checks, and mainnet forking for realistic protocol validation. The Hardhat setup includes hardhat-gas-reporter, solidity-coverage, and @nomicfoundation/hardhat-toolbox with fixture-based test patterns, while the Foundry side leverages cheatcodes such as vm.prank, vm.deal, and vm.expectRevert alongside property-based fuzz tests. Contract verification on Etherscan and automated coverage reporting are also part of the workflow. The skill is built for DeFi and Web3 developers who need a production-grade test suite for their on-chain code.
• Автономный контроль качества кода — ultraqa is a Claude Code skill that runs an autonomous quality-gate loop — executing checks, diagnosing failures, and applying fixes until the target condition passes. It supports five goal types via CLI flags: --tests, --build, --lint, --typecheck, and --custom "pattern", plus --interactive for delegating verification to a qa-tester subagent when a running service needs to be probed. Each of up to five cycles spawns an architect subagent (Opus) to analyze output and an executor subagent (Sonnet) to apply the recommended fix. Early exit triggers automatically when the same failure recurs three times, surfacing the root cause instead of looping indefinitely. Session state is written to .omc/ultraqa-state.json and deleted on completion or cancellation, keeping the workspace clean for subsequent runs. The skill fits CI workflows and local development alike, automating the tedious iterate-fix-rerun loop for tests, builds, and static analysis.
• Параллельная отладка методом конкурирующих гипотез — parallel-debugging is a Claude Code skill that debugs complex issues using the Analysis of Competing Hypotheses (ACH) methodology with parallel agent investigation, evidence collection, and root cause arbitration. It generates hypotheses across six failure mode categories — logic errors, data issues, state problems, integration failures, resource issues, and environment differences — then evaluates each against a three-tier confidence scale (high, medium, low) with mandatory file:line citations. The arbitration protocol classifies results as confirmed, plausible, falsified, or inconclusive, ranks competing confirmed hypotheses, and validates the proposed fix against a structured checklist. Best suited for bugs with multiple plausible root causes, issues spanning several modules, or cases where previous debugging attempts have stalled and systematic analysis is needed to avoid confirmation bias.
• Многомерное ревью кода по нескольким критериям — multi-reviewer-patterns is a Claude Code skill that coordinates parallel code reviews across multiple quality dimensions — Security, Performance, Architecture, Testing, and Accessibility — and produces a consolidated, deduplicated report. It maps each scenario to the right reviewer dimensions (for example, API endpoint changes get Security, Performance, and Architecture) and applies clear merge rules: same file:line with the same issue is collapsed into one finding credited to all reviewers, conflicting severity resolves to the higher rating, and conflicting recommendations are kept with reviewer attribution. Severity calibration follows explicit criteria — externally exploitable vulnerabilities are always Critical or High, hot-path performance issues at least Medium. The output is a structured report grouped by Critical / High / Medium / Low with a per-dimension summary table, giving teams a prioritized action list from multi-reviewer code audits.
• Верификация кода перед релизом — verify is a Claude Code skill that turns vague "it should work" claims into concrete evidence by running checks before declaring any change complete. It follows a four-level verification order: existing tests first, then typecheck and build, then narrow direct command checks, and finally manual or interactive validation with observable evidence collected. The skill reports only what was actually verified — listing what passed, what failed, and what remains unverified — without bluffing when no realistic verification path exists. It suits developers who need reliable confirmation that a feature, fix, or refactor truly works before a release or code review.
• Валидация уязвимостей перед сабмитом в bug bounty — triage-validation is a Claude Code skill that validates security findings before any report is written, reducing N/A submissions and improving acceptance rates in bug bounty programs. It contains an 8-question gate (7 core questions plus an identity/session check), four sequential pre-submission gates, a list of always-rejected vulnerability classes, a conditionally-valid findings table with chaining guidance, a CVSS 3.1 quick reference, and a 60-second pre-submit checklist. A single wrong answer triggers an immediate stop — the skill requires a real copy-paste-ready HTTP request, proven impact beyond "technically possible," and cross-identity reproduction verified against audit.jsonl session IDs to correctly classify IDOR, privilege escalation, and auth bypass. Built for security researchers who want to filter weak or out-of-scope findings during triage rather than after investing time in a full report.
• Vellum — сквозное тестирование ассистента из терминала — cli-testing is a Claude Code skill that enables end-to-end testing of a Vellum assistant entirely from the terminal, with no desktop app or web UI required. It covers the full instance lifecycle: hatching via `vellum hatch --remote docker --source .` (building images from source to test local changes), sending messages with `vellum message`, streaming replies through `vellum events`, and tearing down with `vellum retire`. The skill is designed for verifying assistant behavior, reproducing bugs, and smoke-testing changes without launching macOS or web clients. Multiple LLM provider keys are supported — Anthropic, OpenAI, Gemini, Fireworks, OpenRouter, and MiniMax — read directly from environment variables by the CLI.
• Библиотека пейлоадов для тестирования безопасности — security-arsenal is a Claude Code skill that provides a ready-to-use library of payloads, bypass tables, wordlists, and submission rules for web application security testing. It covers XSS (basic probes, cookie theft, CSP bypass, DOM sources and sinks), SSRF (AWS/GCP/Azure metadata endpoints, internal service fingerprinting, IP bypass via decimal/octal/hex/IPv6), SQL injection (detection, union-based, blind time-based, WAF bypass), XXE, NoSQLi, command injection, SSTI, IDOR, path-traversal, HTTP smuggling, WebSocket, and MFA bypass. The skill also includes an always-rejected findings list and a conditionally-valid-with-chain table to help decide whether a specific bug is worth submitting. Designed for penetration testers and bug bounty hunters who need to quickly look up the right payload or verify if a finding is reportable.
• Валидация уязвимостей перед отправкой в bug bounty — triage-validation is a Claude Code skill that validates security findings before any bug bounty report is written, reducing N/A submissions and protecting the researcher's validity ratio. It contains an 8-question gate (questions asked strictly in order — one wrong answer means killing the finding immediately), four sequential pre-submission gates covering Reality Check, Impact Validation, Deduplication, and Identity verification, an always-rejected vulnerability class list, a conditionally-valid findings table with required exploit chains, a CVSS 3.1 quick reference, a severity decision guide, and a 60-second pre-submit checklist. The Identity Check block (Q8) requires recording which session reproduced the bug and confirming cross-identity behavior — unanswered identity questions auto-fail auth-related findings, which is the most common cause of "confirmed IDOR" reports returning as N/A. The skill is built for bug bounty hunters and security researchers who need a repeatable pre-report gate rather than a post-submission rejection.
• Promptfoo — проверка промптов и защита ИИ-приложений — Promptfoo is a plugin for Claude Code that helps you connect providers and targets, write eval suites, and set up or run red team scans for apps built on language models. Promptfoo itself is an open source command line tool and library under the MIT license: it tests prompts, agents and RAG pipelines, compares models side by side (OpenAI, Anthropic, Azure, Bedrock, Ollama and more), and runs red teaming, meaning it looks for weak spots such as guardrail bypasses. Use it when you need to check prompt quality before a release, compare which model answers better, add checks to CI/CD, or review pull requests for LLM-related security issues. Evals run locally, so your prompts never leave your machine. To install the tool itself: npm install -g promptfoo, then promptfoo init --example getting-started; most providers need your own API key.
• Тестирование и сравнение LLM через omniroute CLI — cli-eval is a Claude Code skill that lets you create and run LLM evaluation suites, watch live benchmark progress, view scorecards, and compare model performance directly from the terminal using the omniroute CLI. It covers the full eval lifecycle: defining suites with rubrics (`exact-match`, `contains`, `llm-judge`, or `regex`) via a JSONL samples file, running them against specific models with `omniroute eval suites run <suiteId> --model <id> --watch` for a live TUI dashboard, and inspecting per-sample pass/fail results through `eval scorecard`. Comparing multiple models — Claude, GPT-4o, Gemini — is done by looping the same suite across targets and diffing the returned scores. CI integration is built around a score-threshold check that exits with a non-zero code when quality drops below an acceptable level, making it straightforward to gate deployments on eval results. The skill is aimed at teams who need automated regression testing for language models and continuous quality monitoring across releases.
• Отладка плагинов IntelliJ Platform — debugging is a Claude Code skill that provides techniques and tools for debugging IntelliJ Platform development. It covers `idea.log` analysis in detail: log level formats (`FINE` for debug, `INFO` for info), the package abbreviation scheme used in log categories, and ready-to-use `grep` patterns to filter entries by class name. A dedicated section explains end-to-end tracing methodology — stepping through the full execution chain from a user-facing entry point (script, command, or API) to the actual executor, identifying every layer that may transform or swallow the behavior. The skill links to internal documentation on Logger FAQ, IDE freeze investigation, and Exception Analyzing FAQ. It is aimed at IntelliJ plugin and platform developers diagnosing failures, freezes, or unexpected component behavior.
• Тестирование MPS-моделей и редактора — mps-tests is a Claude Code skill that serves as a reference for writing and modifying tests inside MPS models carrying the `@tests` stereotype. It covers four test-case types: `NodesTestCase` (typesystem, constraints, scopes, dataflow, generator output), `EditorTestCase` (intentions, actions, keystrokes, side-transforms, completion), `MigrationTestCase` (migration scripts), and `BTestCase` (plain JUnit against hand-written Java/Kotlin runtime code). The skill documents inline annotations such as `has error`, `has type`, and `ScopesTest`, label-based `node<label>` cross-references, caret markers, and running tests via MCP or directly in MPS. Reach for this skill whenever the task involves authoring or fixing tests in a `tests`-facet Solution, or interpreting failures from one.
• Тестирование коннекторов GrokConnect через Maven — test-connectors is a Claude Code skill that runs Java/Maven tests for the GrokConnect connectors project. It accepts three targeting modes: `all` for the full test suite, `<ClassName>` for a single test class, or `<ClassName>#<method>` for a specific test method. Provider tests covering PostgreSQL, MySQL, MariaDB, MS SQL Server, Oracle, ClickHouse, MongoDB, Neo4j, Cassandra, DB2, Vertica, Snowflake, Redshift, Teradata, and more rely on TestContainers and require Docker, while unit tests such as `SerializationTest`, `TableQueryTest`, and `SqlAnnotatorTest` run without it. Prerequisites are JDK 8, Maven 3+, and Docker. Before launching integration tests the skill verifies Docker is running, then executes the appropriate Maven command from the `connectors/` directory and reports results — useful for developers validating database connector behaviour in GrokConnect.
• Мутации промптов для adversarial-тестирования — attack-mutator is a Claude Code skill that generates variations of test cases and prompts for adversarial testing using semantic, encoding, and visual mutation techniques. Supported transformations include paraphrase, synonym_swap, formality_shift, base64_wrap, ROT13, unicode homoglyphs, zero-width character injection, and leetspeak. Each mutation is scored by an algorithm that weighs semantic preservation, surface novelty, and length ratio, then returns a ranked list of candidates. The skill is invoked via /mutate with optional --types and --best-of-n flags, and works with any model configured in Claude settings. It is designed for security and QA teams who need to stress-test filter bypass resistance, probe prompt injection vulnerabilities, and maximize edge-case coverage.
• BigCode Evaluation Harness — бенчмаркинг моделей кодогенерации — bigcode-evaluation-harness is a Claude Code skill that benchmarks code generation models across 15+ tasks — including HumanEval (164 problems), HumanEval+, MBPP, MBPP+, and MultiPL-E spanning 18 programming languages — using pass@k metrics. Built on the BigCode Evaluation Harness from the BigCode Project, it serves as the industry standard behind HuggingFace leaderboards for comparing coding LLMs. The skill supports quantized (4-bit) models, instruction-tuned models with configurable instruction tokens, Docker-based safe code execution for multi-language tasks, and JSON output with pass@1, pass@10, and pass@100 scores. It is the go-to choice for ML engineers who need to rigorously evaluate code model quality, test multilingual generation, or prepare a model submission for public leaderboards.
• NeMo Evaluator — оценка LLM на 100+ бенчмарках — nemo-evaluator is a Claude Code skill that runs LLM benchmarking across 100+ tasks from 18+ harnesses, covering MMLU, HumanEval, GSM8K, GPQA Diamond, VLM, and safety evaluations. Built on NVIDIA's NeMo Evaluator SDK, it supports three execution backends — local Docker, Slurm HPC, and Lepton cloud — with a container-first design for reproducible results. Workflows are configured via Hydra YAML files and controlled through `nemo-evaluator-launcher` CLI commands: `run`, `status`, `ls`, `info`, `kill`, and `export` to MLflow. Ideal for ML engineers who need to compare multiple models on identical benchmarks or scale evaluation to HPC clusters with configurable tensor and data parallelism.
• Автогенерация тестов для API — api-test-suite-builder is a Claude Code skill that automatically generates comprehensive test suites for APIs, covering unit tests, integration tests, and end-to-end scenarios. It analyzes your API structure and produces ready-to-use test cases that address edge cases, error handling, and happy-path flows. Developers and QA engineers who need to establish automated API testing without writing repetitive boilerplate code will find it especially useful. The skill speeds up the development cycle and reduces regression risk when API contracts change.
• BrowserStack — кроссбраузерное тестирование с Playwright — browserstack is a Claude Code skill that integrates the BrowserStack platform into the Playwright Pro workflow, enabling cross-browser and cross-device test automation on real browsers and mobile devices. Tests run remotely on BrowserStack's actual device infrastructure, eliminating the need to maintain a local device farm. QA engineers and developers can use it to verify web application compatibility across browsers and operating systems without manual device management. It is particularly suited for regression test automation, mobile UI validation, and ensuring release stability across diverse client environments.

FAQ

Should I trust Claude to write tests?

Model-written tests are useful as a draft and as insurance against missed edge cases, but they need review. The main risk is a test that always passes, because it creates a false sense of coverage. The practical habit is to confirm the test fails against broken code before accepting it.

How do I make Claude write tests in my project's style?

State the framework, the file structure and the naming rules in the skill, and include two or three exemplary tests straight from the repository. Examples outperform descriptions: a model reproduces a shown template far more accurately than it follows a written account of one.

All Claude Code skills