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

• Тестирование UI в браузере через Chrome DevTools — browser-testing-with-devtools is a Claude Code skill that enables real-browser testing through the Chrome DevTools MCP server. Instead of relying on static code analysis, the agent gains live access to the DOM tree, console output, network requests and responses, computed element styles, the accessibility tree, and performance timing data including Core Web Vitals. It connects via `chrome-devtools-mcp`, supporting an isolated temporary profile (`--isolated`) for most testing scenarios or `--autoConnect` (Chrome 144+) when logged-in session state is required. Best suited for debugging UI layout and interactions, diagnosing runtime errors, verifying API calls, and running automated browser checks against a local dev server. Requires the `chrome-devtools` MCP server to be configured in `.mcp.json` or Claude Code settings.
• Критическая проверка решений через adversarial review — doubt-driven-development is a Claude Code skill that subjects every non-trivial decision to fresh-context adversarial review before it stands, using a reviewer biased to disprove rather than approve. The process follows five steps: CLAIM (state the decision and why it matters), EXTRACT (isolate the smallest reviewable artifact plus its contract, stripped of the author's reasoning), DOUBT (invoke a fresh-context reviewer with a verbatim adversarial prompt targeting unstated assumptions, edge cases, hidden coupling, and failure modes), RECONCILE (classify every finding against the artifact), and STOP (exit on trivial findings, three cycles, or explicit user override). Designed strictly for the main-session orchestrator — adding it to a persona's frontmatter is forbidden because it would trigger nested subagent spawning, an anti-pattern prohibited by orchestration-patterns. Use it before committing branching logic, crossing module boundaries, making irreversible production or security-sensitive changes, or asserting properties the type system cannot verify.
• Многоосевое ревью кода перед слиянием — code-review-and-quality is a Claude Code skill that performs multi-axis code review before merging any change. It evaluates code across five dimensions: correctness (spec adherence, edge cases, error paths), readability and simplicity, architecture, security, and performance. The skill applies to code of any origin — human-written, agent-generated, or produced by another model. For each axis it goes beyond flagging issues and proposes concrete structural remedies: replacing conditional chains with typed models, moving feature logic into the owning module, or deleting pass-through wrappers that add indirection without clarity. The approval standard is pragmatic — a change is approved when it demonstrably improves overall code health, even if imperfect, making this skill the right choice for teams that want consistent, actionable pre-merge quality gates.
• Разработка через тесты (TDD) — test-driven-development is a Claude Code skill that enforces writing a failing test before any implementation and reproducing a bug with a test before attempting a fix. It guides Claude through the full RED → GREEN → REFACTOR loop, the Prove-It Pattern for bug fixes, and the test pyramid (~80% unit, ~15% integration, ~5% E2E). Before the first test, the skill discovers the project's actual tooling by inspecting package.json, pyproject.toml, go.mod, Cargo.toml, Makefiles, and CI workflows — so it runs ./gradlew, make test, or the repo's own script rather than assuming a global default. For browser-facing changes it recommends pairing TDD with runtime verification via Chrome DevTools MCP. Works across any language or test framework, making it the right choice whenever new logic is added, existing behavior is modified, or a bug report needs a reproducible proof.
• Систематическая отладка и восстановление после ошибок — debugging-and-error-recovery is a Claude Code skill that guides a structured root-cause debugging process for test failures, broken builds, unexpected runtime behavior, and production incidents. It is built around a stop-the-line rule: when something breaks, preserve evidence and work through six ordered steps — reproduce the failure reliably, localize the failing layer (UI, API, database, build tooling, or external service), reduce to a minimal failing case, fix the root cause rather than the symptom, write a regression test, and verify end-to-end. The skill covers specific patterns for non-reproducible, timing-dependent, environment-dependent, and state-dependent bugs, plus git bisect workflows for identifying the commit that introduced a regression. It is aimed at developers who need a disciplined, repeatable approach to debugging instead of guesswork.
• Визуальная проверка 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.
• Тестирование 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.
• Автономный контроль качества кода — 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.
• Аудит доступности по стандарту 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`.
• Верификация кода перед релизом — 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.
• Многомерное ревью кода по нескольким критериям — 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.
• Параллельная отладка методом конкурирующих гипотез — 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.
• Тестирование с экранными читалками 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.
• 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.
• Валидация уязвимостей перед сабмитом в 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.
• Пентест мобильных приложений Android и iOS — mobile-pentest is a Claude Code skill that guides mobile application penetration testing for Android APK and iOS IPA targets using a runtime-first workflow: install the app, proxy traffic through Burp Suite or mitmproxy, drive real business flows by hand, and escalate to decompilation with apktool/jadx or dynamic instrumentation with Frida/objection only when traffic is SSL-pinned, encrypted, or absent. The static sweep phase uses grep and apkleaks against smali and XML to surface hardcoded secrets, hidden API endpoints, and base URLs that web recon never reaches. The skill also covers exported-activity and deeplink intent injection, WebView addJavascriptInterface bridge abuse, OkHttp interceptor chain analysis to recover request signing, and injecting a network_security_config to trust user CA certificates. Built for bug bounty hunters who need a fresh attack surface after web recon dries up or when app traffic must be MitM'd.
• 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.
• Пентест мобильных приложений Android и iOS — mobile-pentest is a Claude Code skill that implements a runtime-first methodology for pentesting mobile applications (Android APK and iOS IPA) in bug bounty engagements. The workflow follows a strict order: install the app, proxy traffic through Burp or mitmproxy, drive real business flows by hand, and escalate to decompilation with apktool/jadx or Frida/objection instrumentation only when traffic is SSL-pinned, encrypted, or absent. The skill covers static sweeps for hardcoded secrets and hidden API endpoints, SSL pinning bypass via objection patchapk and Frida CertificatePinner/checkServerTrusted hooks, request-signing recovery through the OkHttp interceptor chain, exported-activity and deeplink intent injection, WebView addJavascriptInterface bridge abuse, and JNI native-lib triage. It is built for bug bounty hunters who need a fresh attack surface when web recon dries up or when traffic must be MitM'd to test the backend.
• Unlighthouse — полный SEO-аудит всех страниц сайта — seo-unlighthouse is a Claude Code skill that runs Lighthouse across every URL on a site using the MIT-licensed Unlighthouse CLI and aggregates the results — with no API quota consumption. It is the practical free-tier alternative when PageSpeed Insights' 25 000 requests-per-day limit falls short, or when offline Core Web Vitals measurement is needed in CI pipelines or restricted environments. The command `/seo unlighthouse <url>` audits up to 200 routes in mobile mode and produces a JSON and HTML report; `--device desktop`, `--max-routes`, and `--output-dir` flags allow flexible configuration. Results are returned as a parsed `ci-result.json` containing median scores for performance, accessibility, best practices, and SEO, plus a per-route breakdown. Node 18+ and a one-time run of `extensions/unlighthouse/install.sh` are required — no API key needed.
• Библиотека пейлоадов для тестирования безопасности — 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.
• TDD-разработка с покрытием кода — tdd-workflow is a Claude Code skill that enforces test-driven development with a minimum 80% code coverage requirement across unit, integration, and E2E tests. It activates when writing new features, fixing bugs, refactoring code, adding API endpoints, or creating components. The workflow spans seven steps — from authoring user journeys and generating test cases, through implementation and refactoring, to coverage verification — and supports Jest, Vitest, and Bun's native `bun:test` runner, with Playwright handling E2E scenarios. A dedicated Step 0 detects the project's package manager and test runner separately, preventing common failures in ESM-only projects where mixing `bun test` and `bun run test` breaks test execution.
• Тестирование и сравнение 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.

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