426 skills published by PramodDutta across 1 repository. Together they weigh 1 462 137 tokens — that is what loading all of them at once would cost you in context.
426 skills 1 462 137 tokens total
Validating A/B test implementations including traffic splitting accuracy, statistical significance calculation, metric tracking, and experiment cleanup.
Comprehensive WCAG compliance and accessibility testing covering ARIA, keyboard navigation, screen readers, color contrast, and automated a11y validation.
Comprehensive WCAG 2.1 AA compliance testing combining automated axe-core scans with manual keyboard navigation, screen reader compatibility, and focus management verification
Teach agents to guide manual accessibility audits for keyboard, screen reader, zoom, reflow, focus, and WCAG 2.2 criteria that scanners miss.
Use when adding or editing QA skills in seed-skills/ or getting them onto the live qaskills.sh catalog, e.g. "add N new skills", "create a seed skill for X", "seed the database", "the skill page is empty", "skill 404s on the site".
Advanced Allure test reporting with custom categories, environment info, test history trends, flaky test detection, and CI/CD dashboard integration.
Advanced chaos engineering patterns using Chaos Monkey, Litmus, and Gremlin for testing distributed system resilience under failure conditions.
Advanced mutation testing using Stryker, PIT, and mutmut to measure test suite quality by introducing controlled mutations and tracking kill rates.
Enterprise-grade Playwright test automation framework using 8-layer architecture with Page Object Model, Module Pattern, custom fixtures, API testing layer, structured logging, data generators, multi-browser support, Docker, CI/CD pipelines, and custom HTML reporting.
WebSocket testing including connection lifecycle, reconnection logic, message ordering, backpressure handling, and binary frame testing.
American Fuzzy Lop Plus Plus mutation-based fuzz testing for finding crashes, hangs, and security vulnerabilities in binary programs.
Fast Rust-based headless browser automation CLI with Node.js fallback for AI agents, featuring navigation, clicking, typing, snapshots, and structured commands optimized for agent workflows.
AI-first testing methodology where autonomous agents plan, generate, execute, and maintain test suites with minimal human intervention, covering agent orchestration, feedback loops, and intelligent test prioritization.
Comprehensive evaluation patterns for AI agents including multi-turn conversation testing, LLM-as-judge frameworks, benchmark suites, regression detection, and systematic eval pipelines for measuring agent quality and safety.
Testing machine learning models including accuracy validation, bias detection, drift monitoring, A/B testing, and model regression testing.
Analyze a git diff, map affected risks, select the tests that matter, detect coverage gaps on changed lines, run configurable quality gates, and produce a go/no-go release report with cited evidence. Recommends only; never merges or deploys.
Test LLM, RAG, MCP, and agentic systems end to end. Build golden datasets, run deterministic checks and LLM judges, score retrieval, probe prompt injection, verify tool use, and gate CI on thresholds. Orchestrates DeepEval, Ragas, promptfoo, and Langfuse.
Systematic patterns for prompting AI coding agents to generate high-quality tests including prompt engineering for test creation, coverage-driven generation, mutation-aware testing, and review checklists for AI-generated test code.
AI-powered test orchestration skill covering intelligent test selection, risk-based test prioritization, flaky test management, test impact analysis, parallel execution optimization, and predictive test failure detection using machine learning.
Testing monitoring and alerting configurations including threshold validation, alert routing, escalation policies, and false-positive rate monitoring.
Configure and generate rich Allure test reports with test categorization, historical trends, environment details, and CI/CD integration for comprehensive test visibility
Simulate aggressive user behavior patterns including rapid clicking, random navigation, form abuse, tab spamming, and unexpected interaction sequences to find UI resilience issues
Angular application testing with TestBed, component harness, service testing, directive testing, and Angular-specific testing utilities.
Automated detection of breaking API changes including response format changes, removed endpoints, type changes, and deprecation enforcement.
Validate API responses against OpenAPI/Swagger specifications, JSON Schema definitions, and consumer-driven contracts to prevent breaking changes
API endpoint fuzzing for discovering unexpected behaviors, crashes, and security vulnerabilities through malformed requests, boundary values, and protocol violations.
API gateway testing skill covering rate limiting validation, request routing, authentication proxy testing, load balancing verification, circuit breaker testing, and gateway configuration validation for Kong, Envoy, and AWS API Gateway.
Testing API rate limiting implementations including throttling behavior, burst handling, rate limit headers, and distributed rate limiting patterns.
Testing API schema evolution patterns including additive changes, field deprecation, type widening, and backward-compatible migration strategies.
Comprehensive API security testing based on OWASP API Security Top 10 including broken authentication, injection attacks, rate limiting, BOLA/BFLA vulnerabilities, and automated security scanning with ZAP and custom scripts.
Comprehensive RESTful API testing patterns covering HTTP methods, status codes, request/response validation, authentication, error handling, and contract testing.
Comprehensive RESTful API testing patterns covering HTTP methods, status codes, request/response validation, authentication, error handling, and contract testing.
Automatically generate comprehensive API test suites from OpenAPI specifications covering CRUD operations, error handling, authentication, pagination, and edge cases
Testing API versioning strategies including URL path, header, and query parameter versioning with backward compatibility validation.
Mobile application testing skill using Appium for iOS and Android, covering device capabilities, selectors, gestures, and cross-platform testing strategies.
Approval testing methodology using ApprovalTests library for verifying complex outputs against human-approved results with diff-based review.
Write and run Artillery load tests with YAML phases and scenarios, CSV data payloads, the expect plugin for functional checks, and ensure thresholds that fail CI when latency or error budgets are breached.
Modern cloud-scale load testing using Artillery.io for HTTP, WebSocket, Socket.io, and custom protocol testing with YAML-based test definitions.
Testing augmented and virtual reality applications including spatial tracking, gesture recognition, performance on headsets, and motion sickness testing.
Comprehensive authentication and authorization bypass testing including session hijacking, privilege escalation, JWT manipulation, and access control verification
Comprehensive authentication testing including login flows, password policies, MFA, session management, account lockout, and SSO integration.
Role-based and attribute-based access control testing including permission matrices, privilege escalation prevention, and resource-level authorization.
Testing patterns for autonomous AI coding agents like Devin and SWE-Agent including task verification, output validation, sandboxed execution, regression testing for agent behavior, and safety guardrails for autonomous code generation.
Automated accessibility testing with axe-core integrated into CI pipelines, including custom rule configuration, issue prioritization, and remediation guidance.
Accessibility testing skill using axe-core and Playwright for automated WCAG 2.1 compliance auditing, custom rules, and accessibility reporting.
Behavior-Driven Development skill using Cucumber, covering feature files, step definitions, Gherkin best practices, data tables, scenario outlines, and hooks.
Behavior-Driven Development with Gherkin syntax, step definitions, scenario outlines, data tables, and living documentation generation.
PHP BDD testing with Behat framework using Gherkin feature files, Mink browser extension, context classes, and Symfony integration for behavior-driven acceptance testing.
Python BDD testing with Behave framework using Gherkin feature files, step definitions, environment hooks, and Selenium integration for behavior-driven acceptance testing.
Generate boundary value test cases for numeric ranges, string lengths, date ranges, collection sizes, and domain-specific constraints using systematic analysis techniques
Teach agents to use AI browser agents for exploratory and smoke QA with step budgets, evidence-based assertions, guardrails, and Playwright conversion.
BrowserBash is a vendor-independent, natural-language browser automation CLI. Drive a real browser from plain-English objectives or committable Markdown tests, run on local Chrome, CDP/Playwright MCP, Browserbase, LambdaTest, or BrowserStack, and stream NDJSON results with CI exit codes — using free local Ollama models or any cloud LLM.
Testing browser extensions including content script injection, background worker testing, popup UI testing, storage API testing, and cross-browser compatibility.
Cloud-based cross-browser and cross-device testing with BrowserStack including Automate, App Automate, Percy visual testing, Observability, and integration with Playwright, Selenium, and CI/CD pipelines.
CLI tool for persistent browser automation with multi-session support, featuring Chromium/Real/Remote browser modes, cookie management, JavaScript execution, and long-running automation workflows.
Bug report writing skill covering clear reproduction steps, severity classification, effective communication, triage processes, and defect lifecycle management.
Fast test execution with Bun's built-in test runner including snapshot testing, mocking, code coverage, lifecycle hooks, DOM testing with happy-dom, and migration from Jest and Vitest to Bun test.
Web application security testing using BurpSuite for proxy-based interception, scanning, and manual penetration testing of web applications.
Canary deployment validation testing including traffic splitting, metric comparison, automatic rollback triggers, and health score calculation.
Expert-level Capybara acceptance testing skill for Ruby and Rails applications. Covers RSpec integration, DSL methods, scoping, Page Objects with SitePrism, JavaScript interactions, and database cleaning strategies.
Fuzz testing for Rust applications using cargo-fuzz and libFuzzer to discover memory safety issues, panics, and undefined behavior.
Testing CDN configurations, cache hit ratios, cache invalidation, TTL policies, and edge caching behavior for optimal content delivery.
Map changelog entries and release notes to affected test cases, ensuring every user-facing change has corresponding test coverage verification.
Teach agents to build synthetic monitoring as code with Checkly, including Playwright browser checks, API checks, alerting, and CI deploy workflows.
Teach agents to use the Chrome DevTools MCP server for performance testing with traces, Core Web Vitals, throttling, and evidence-based analysis.
Expert-level CI/CD pipeline skill for test automation. Covers GitHub Actions, Jenkins, GitLab CI, Azure DevOps, parallel execution, matrix strategies, caching, artifact management, and deployment gates.
CI/CD pipeline configuration skill for test automation, covering GitHub Actions, Jenkins, GitLab CI, test parallelization, reporting, and artifact management.
Testing CI/CD pipeline configurations including build validation, deployment verification, rollback testing, and pipeline-as-code quality checks.
Optimize CI test pipelines through intelligent test splitting, parallelization, caching strategies, and selective test execution based on code changes.
Teach agents to shard and parallelize Playwright, Jest, and pytest suites in CI to reduce wall-clock time while merging reports reliably.
The complete QA skill for Claude Code — turn Claude into an expert QA engineer that picks the right test type, writes reliable Playwright, Cypress, and pytest tests, eliminates flaky tests, enforces coverage, and wires up CI. Claude Code QA testing done right.
Testing patterns for Clerk authentication including sign-in flow testing, protected route testing, webhook verification, middleware testing, and organization-based access control
Expert-level Codeception testing skill for PHP applications. Covers acceptance, functional, and unit testing with the Actor pattern, BDD-style syntax, Page Objects, API testing, and database helpers.
Measure and enforce test coverage with Istanbul/nyc, c8, Jest, and Vitest. Covers branch versus line coverage, per-directory thresholds, CI gates, and correctly excluding generated code from reports.
Advanced security analysis using GitHub CodeQL to find zero-day vulnerabilities, injection flaws, and security anti-patterns in source code.
Master code review best practices with constructive feedback patterns, quality assurance standards, review checklists, security considerations, and collaborative improvement techniques for high-quality software delivery.
Evaluate interface complexity by measuring information density, decision points, visual hierarchy, and task completion paths to reduce user cognitive burden.
Automated compliance testing using Open Policy Agent, Chef InSpec, and custom policy engines for security baseline validation.
Isolating and testing individual UI components with dependency mocking, state injection, and visual snapshot verification.
Testing concurrent code including race condition detection, deadlock prevention, thread safety verification, and parallel execution correctness.
Testing application configurations including environment variable validation, feature flag combinations, config file parsing, and default value verification.
Systematically detect, capture, and categorize browser console errors, warnings, and unhandled exceptions during automated test execution
Contract-first testing approach using Pact, Spring Cloud Contract, or Dredd for ensuring API consumer-provider compatibility.
Generate consumer-driven contract tests using Pact framework to verify API provider-consumer compatibility and prevent integration breaking changes
Consumer-driven contract testing skill using Pact, covering consumer tests, provider verification, Pact Broker integration, and CI/CD workflows.
Testing cookie and session management including secure flags, SameSite policy, session fixation, timeout behavior, and cross-domain cookie handling.
Testing and monitoring Core Web Vitals (LCP, FID, CLS, INP, TTFB) to ensure web performance meets Google search ranking thresholds.
Testing Cross-Origin Resource Sharing configurations for misconfigurations, overly permissive policies, and credential handling vulnerabilities.
Testing scheduled tasks and cron jobs including execution timing, idempotency, failure recovery, overlap prevention, and timezone handling.
Automated cross-browser testing across Chrome, Firefox, Safari, and Edge with visual comparison, feature detection, and polyfill verification.
Content Security Policy testing and validation to prevent XSS attacks, data injection, and clickjacking through proper CSP header configuration.
Effective test automation patterns with Cursor AI IDE including Composer for test suite generation, Cmd+K for inline test edits, Chat for test debugging, codebase-aware test generation, and rules configuration for testing conventions.
Author effective Cursor rules in .cursor/rules/*.mdc - YAML frontmatter (description, globs, alwaysApply), the four rule types, scoped QA rules, subagents, and structure that actually steers the model.
Writing custom static analysis rules for ESLint, Semgrep, and SonarQube to enforce project-specific code quality and security standards.
Component testing with Cypress including mount API, React/Vue/Angular component testing, stub patterns, and visual snapshot testing.
End-to-end testing skill using Cypress for web applications, covering custom commands, network intercepts, fixtures, cy.session, and component testing patterns.
End-to-end testing skill using Cypress for web applications, covering custom commands, network intercepts, fixtures, cy.session, and component testing patterns.
Component testing patterns with Cypress v14 including React, Vue, and Angular component mounting, custom mount commands, interaction testing, visual snapshots, and integration with Vite and Webpack bundlers.
Detect dark mode rendering issues including contrast failures, missing theme tokens, image inversions, and transition glitches across components.
Systematic dark mode testing covering color contrast, theme switching, persistence, media query respect, component-level theming, and image adaptation.
Generate tests for database migration safety covering schema changes, data integrity preservation, rollback verification, and zero-downtime migration validation
Testing database migration scripts for correctness, rollback safety, data integrity, and zero-downtime migration patterns.
Database performance testing including query optimization, index analysis, connection pooling, slow query detection, and N+1 query prevention.
Verifying data integrity constraints, referential integrity, data type validation, and consistency checks across database operations.
Testing data pipelines including ETL validation, data quality checks, pipeline orchestration testing, and data lineage verification.
Automated detection and reporting of broken links, missing resources, and orphaned pages across web applications using crawl-based and DOM-based strategies
Advanced debugging patterns for test failures covering root cause analysis, flakiness investigation, performance debugging, and systematic troubleshooting methodologies.
Test LLM applications with DeepEval, pytest-style unit tests for LLM outputs using G-Eval, answer relevancy, faithfulness, hallucination and custom metrics, with CI quality gates and dataset-driven regression runs.
Automated scanning of project dependencies for known vulnerabilities using tools like npm audit, Snyk, and Dependabot patterns.
Testing desktop applications built with Electron, Tauri, or native frameworks including window management, IPC, tray icons, and auto-update testing.
Gray-box end-to-end testing for React Native apps with Detox. Covers .detoxrc.js configuration, build and test commands, matchers, device.launchApp control, automatic synchronization, and macOS CI pipelines.
End-to-end testing for React Native apps using Detox with gray-box testing, synchronization, device simulation, and CI integration.
Testing distributed tracing implementations including context propagation, span correlation, baggage handling, and trace sampling verification.
Django application testing with TestCase, fixtures, factory_boy, model testing, view testing, middleware testing, and Django REST framework testing.
DNS configuration testing including record validation, DNSSEC verification, resolution timing, failover testing, and DNS-based service discovery.
Testing Docker containers and images including Dockerfile linting, container structure tests, security scanning, and multi-stage build validation.
Integration testing with real dependencies in throwaway Docker containers using the Testcontainers Node.js API - GenericContainer, exposed ports, wait strategies, module containers, Docker Compose environments, and reliable cleanup.
Testing patterns for Drizzle ORM covering migration testing, query builder testing, transaction testing, and database integration testing with PostgreSQL, SQLite, and MySQL.
Make Claude Code write and maintain end-to-end tests like a senior SDET — Playwright and Cypress flows with stable locators, the Page Object Model, fixtures, reused auth state, network mocking, and flake-free CI. Claude Code E2E testing, done right.
Comprehensive end-to-end testing methodologies and best practices covering architecture, test design, data management, flakiness prevention, and cross-browser strategies.
Make Claude Code write and maintain end-to-end tests like a senior SDET — Playwright and Cypress flows with stable locators, the Page Object Model, fixtures, reused auth state, network mocking, and flake-free CI. Claude Code E2E testing, done right.
Testing edge computing deployments including latency verification, edge function testing, CDN worker testing, and geo-distributed test execution.
Elasticsearch testing including index management, query validation, mapping verification, bulk operation testing, and search relevance scoring.
Email delivery testing including content verification, rendering across clients, spam score checking, link validation, and transactional email workflow testing.
Audit empty states across web applications ensuring proper messaging, helpful CTAs, illustration rendering, and graceful handling when data is unavailable
End-to-end database testing with test containers, data seeding, cleanup strategies, transaction isolation, and production data anonymization.
Testing in ephemeral preview environments for pull requests including environment provisioning, data seeding, and automated teardown.
Validate error boundary implementations in React and other frameworks ensuring graceful degradation, proper fallback UI rendering, and error recovery flows
Testing error handling paths including exception propagation, error boundaries, retry logic, circuit breakers, and graceful degradation.
Audit error messages across an application for clarity, actionability, consistency, and user-friendliness by cataloging and grading every error surface.
Enforce test quality with ESLint - eslint-plugin-jest, eslint-plugin-playwright, and eslint-plugin-testing-library rules in flat config, blocking focused tests, missing assertions, and flaky waits via a CI lint gate.
Android UI testing with Espresso framework including view matchers, actions, assertions, idling resources, and RecyclerView testing patterns.
Testing event sourcing patterns including event store validation, projection testing, saga orchestration, and event versioning compatibility.
Generate structured exploratory testing charters with focused missions, time-boxed sessions, risk-based areas, and standardized note-taking templates for systematic exploration
Express.js API testing with supertest, middleware testing, route handler testing, error handling verification, and authentication testing.
Generating realistic test data with Faker libraries for names, addresses, emails, dates, and domain-specific data with reproducible seed control.
FastAPI application testing with TestClient, dependency injection overrides, async testing, database testing with SQLAlchemy, and OpenAPI validation.
Testing feature flag implementations including flag evaluation, gradual rollout verification, fallback behavior, and flag cleanup detection.
Comprehensive file upload testing including format validation, size limits, malware scanning, storage verification, and concurrent upload handling.
Validate the first-time user experience including onboarding flows, empty states, tutorial completion, progressive disclosure, and initial setup wizards
Diagnose flaky test failures from Playwright reports, traces, and rerun history. Classify each failure as product, test, environment, data, or unknown with cited evidence and a proposed fix. Never auto-modifies code without opt-in.
Detect, quarantine, and systematically fix flaky tests with automated retry analysis, root cause categorization, and CI pipeline integration for test reliability
Flask application testing with test client, fixture patterns, SQLAlchemy model testing, blueprint testing, and Flask-specific extension testing.
Flutter app testing with widget tests, integration tests, golden tests, Mockito, bloc testing, and Flutter Driver for end-to-end scenarios.
Exhaustive testing of form validation logic including boundary values, injection payloads, encoding edge cases, and client-server validation bypass techniques
Frontend performance testing covering bundle size analysis, render performance, animation frame rate, React re-render detection, and lazy loading verification.
High-performance load testing using Gatling with Scala/Java DSL for simulating thousands of concurrent users and analyzing response time distributions.
Test automation with Gauge framework using Markdown specifications, step implementations in Java/Python/JavaScript/Ruby/C#, concepts, data-driven testing, and living documentation.
Testing GDPR compliance requirements including data deletion, consent management, data portability, right to erasure, and privacy policy enforcement.
Browser automation testing with Geb framework for Groovy/JVM using jQuery-like content DSL, Page Object pattern, Spock integration, and WebDriver abstraction.
Setting up and optimizing test pipelines in GitHub Actions with caching, parallel execution, matrix builds, and test result reporting.
Debug and fix failing GitHub PR checks by inspecting GitHub Actions logs, summarizing failure context, drafting fix plans, and implementing fixes after approval.
Effective patterns for using GitHub Copilot to generate, refactor, and maintain test code including prompt engineering for test generation, Copilot Chat for debugging, inline suggestions for assertions, and workspace context optimization.
Golden file testing pattern for comparing output against approved baselines with update workflows, diff tools, and version control integration.
Go testing with testing package, table-driven tests, subtests, benchmarks, test fixtures, httptest, and testify assertions.
Contract testing for GraphQL APIs including schema breaking change detection, query compatibility testing, and federated schema validation.
Testing GraphQL subscriptions including WebSocket lifecycle, real-time event delivery, authorization on subscriptions, and connection management.
Comprehensive GraphQL API testing including query/mutation testing, schema validation, resolver testing, subscription testing, and N+1 query detection.
gRPC service testing including protobuf validation, streaming tests, error handling, deadline testing, and load testing for gRPC endpoints.
Building hermetic tests that are fully isolated from external dependencies using fakes, containers, and deterministic time/random sources.
Testing HIPAA compliance for healthcare applications including PHI handling, audit logging, access controls, and data encryption verification.
Testing image processing pipelines including format conversion, resize quality, metadata handling, watermark verification, and thumbnail generation.
Detecting and testing infrastructure drift between desired state and actual state using automated scanning, alerting, and remediation patterns.
Integration testing strategies including database integration, external service integration, message queue testing, and test container patterns.
i18n testing covering locale switching, date/number formatting, RTL layout, plural forms, ICU messages, and translation completeness verification.
IoT device testing including firmware validation, protocol testing (MQTT, CoAP), power consumption testing, and over-the-air update verification.
Apply classic test design techniques the ISTQB way, equivalence partitioning, boundary value analysis, decision tables, state transition testing, and pairwise combinations, to derive minimal high-coverage test sets from requirements.
BDD-style JavaScript testing with Jasmine covering spies, async patterns, custom matchers, clock manipulation, and comprehensive test organization for frontend and Node.js applications.
Modern JavaScript testing strategies with Jest, Mocha, and testing best practices covering unit testing, integration testing, mocking, async patterns, and DOM testing.
Teaches the agent the right way to mock in Jest — jest.fn, mockImplementation, mockResolvedValue, jest.mock factories, spyOn with restore, and isolating modules like axios.
Unit testing skill using Jest for TypeScript and JavaScript, covering mocking, spies, snapshots, coverage, async testing, and custom matchers.
Unit testing skill using Jest for TypeScript and JavaScript, covering mocking, spies, snapshots, coverage, async testing, and custom matchers.
Run QA work in Jira like a professional, bug lifecycle and triage, JQL queries for testers, quality dashboards, sprint QA rituals, and REST API automation for bulk bug operations and reporting.
Load and performance testing skill using Apache JMeter, covering test plans, thread groups, assertions, listeners, timers, and distributed testing.
Production-grade Java unit and integration testing with JUnit 5 covering assertions, parameterized tests, lifecycle hooks, Mockito mocking, nested tests, and extensions.
Comprehensive JWT token security testing including signature verification, expiration checks, algorithm confusion attacks, and claim validation.
Performance and load testing skill using k6, covering load test scripts, thresholds, scenarios, checks, custom metrics, and results analysis.
Performance and load testing skill using k6, covering load test scripts, thresholds, scenarios, checks, custom metrics, and results analysis.
Test Kafka-based event-driven systems, producer and consumer integration tests with Testcontainers, schema compatibility gates, idempotency and ordering verification, dead-letter handling, and end-to-end event flow assertions.
Comprehensive Karma test runner skill for browser-based JavaScript unit testing with Jasmine, Mocha, or QUnit frameworks, real browser execution, coverage reporting, and CI/CD pipeline integration.
Comprehensive testing patterns for Katalon Studio including codeless record-and-playback, Groovy scripted testing, custom keywords, data-driven testing, cross-browser execution, and CI/CD integration with Katalon TestOps.
Kotlin testing with JUnit 5, MockK, Kotest, coroutine testing, Android testing with Espresso, and Kotlin-specific assertion libraries.
Chaos testing for Kubernetes workloads using Chaos Mesh, Litmus, and custom fault injection for pod, network, and disk failures.
Kubernetes deployment testing including manifest validation, Helm chart testing, pod health checks, network policy testing, and rollback verification.
Instrument LLM apps with Langfuse tracing, then use traces, scores, and datasets to test in production, run evaluations on real traffic, catch regressions, and close the loop from incident to golden dataset.
Expert-level Laravel Dusk browser testing skill for PHP/Laravel applications. Covers Chrome-based E2E testing, browser assertions, Page Objects, component testing, authentication helpers, and database integration.
Laravel PHP testing with PHPUnit, feature tests, browser tests with Dusk, database factories, mocking facades, and HTTP testing helpers.
Expert-level Lettuce BDD testing skill for Python applications. Covers Gherkin feature files, step definitions, terrain hooks, Selenium integration, data-driven scenarios, and migration guidance to Behave for modern projects.
Coverage-guided fuzz testing using libFuzzer for C/C++ applications to find memory corruption, buffer overflows, and crash-inducing inputs.
Testing library backward compatibility including public API surface verification, semver compliance, TypeScript type compatibility, and migration path validation.
Automated open-source license compliance testing to detect license conflicts, copyleft violations, and license compatibility issues in dependencies.
Automated web performance auditing using Google Lighthouse for Core Web Vitals, accessibility, SEO, and best practices scoring with CI integration.
Testing LLM-powered features including output quality validation, hallucination detection, token usage monitoring, and prompt regression testing.
Security testing for LLM-powered applications including prompt injection, jailbreak detection, data leakage prevention, and AI safety testing.
Testing load balancer configurations including health check validation, routing algorithms, session affinity, failover behavior, and SSL termination.
Verify loading indicators, skeleton screens, and progress bars appear correctly during async operations and disappear on completion or error.
Detect localization and internationalization defects including untranslated strings, text expansion overflow, RTL layout issues, and locale-specific formatting errors
Python-based load testing with Locust for writing user behavior scripts, distributed testing, real-time web UI monitoring, and custom load shapes.
Testing logging implementations including log level verification, structured logging validation, log rotation testing, and log aggregation pipeline testing.
AI-powered testing patterns with Mabl including auto-healing tests, visual regression, API testing, performance monitoring, CI/CD integration, and intelligent test maintenance using Mabl's machine learning capabilities.
Black-box mobile UI testing with Maestro YAML flows - launchApp, tapOn, inputText, assertVisible, reusable runFlow subflows, environment parameters, JUnit reporting, and emulator-based CI pipelines.
Comprehensive testing patterns for Model Context Protocol servers including tool validation, transport testing, schema verification, and end-to-end MCP integration testing with stdio and SSE transports.
Identify and diagnose memory leaks in web applications using heap snapshots, allocation timelines, and automated leak detection patterns.
Systematic memory profiling and leak detection in applications using heap snapshots, allocation tracking, and garbage collection analysis.
Testing message queue implementations including RabbitMQ, SQS, and Kafka with delivery guarantees, ordering, dead letter queues, and consumer testing.
Consumer-driven contract testing for microservices using Pact, ensuring API compatibility and preventing integration breakages across service boundaries.
Accessibility testing for mobile apps including VoiceOver/TalkBack testing, touch target sizes, dynamic type support, and motor accessibility.
Scalable mobile testing using cloud device farms like AWS Device Farm, BrowserStack, and Firebase Test Lab for cross-device compatibility.
Test touch gestures including swipe, pinch-to-zoom, long press, and drag-and-drop on mobile viewports and touch-enabled devices.
Mobile application performance testing including app launch time, frame rendering, memory profiling, battery consumption, network throttling, and crash analytics using Appium, XCTest, and Espresso with real device testing.
Comprehensive Mocha testing skill for writing robust unit and integration tests in JavaScript and TypeScript with Chai assertions, Sinon mocking, async patterns, and CI/CD integration.
MongoDB testing with in-memory MongoDB, aggregation pipeline testing, schema validation, indexing verification, and replica set testing.
Microsoft's built-in .NET testing framework covering test classes, data-driven tests, assertions, lifecycle management, mocking with Moq, and integration testing for C# applications.
Mock Service Worker v2 patterns - http and graphql request handlers, setupServer for Node test runs, setupWorker for the browser, per-test handler overrides, and strict unhandled-request policies.
API mocking with Mock Service Worker for browser and Node.js environments including request interception, response simulation, and network error testing.
Testing multi-tenant application isolation including data segregation, tenant-specific configuration, cross-tenant access prevention, and performance isolation.
Generate and run mutation tests to measure test suite effectiveness by introducing code mutations and verifying detection rates.
Run mutation testing with StrykerJS for TypeScript/JavaScript and mutmut for Python to measure whether your test suite actually catches bugs, enforce mutation score thresholds, and keep runs fast with incremental mode in CI.
Detect and eliminate N+1 query problems in database-backed applications through query counting, execution plan analysis, and ORM configuration auditing
Systematically generate negative test cases covering invalid inputs, unauthorized actions, missing required fields, exceeded limits, and malformed request payloads
Comprehensive Nemo.js test automation skill for PayPal's Selenium-based Node.js testing framework featuring view-driven locators, flexible configuration, Mocha integration, and scalable browser automation patterns.
NestJS application testing with @nestjs/testing, dependency injection mocking, e2e testing with supertest, guard testing, and pipe validation testing.
.NET testing with xUnit, NUnit, MSTest, FluentAssertions, Moq, integration testing with WebApplicationFactory, and Entity Framework testing.
Network latency simulation and testing for measuring application behavior under various network conditions including high latency, packet loss, and bandwidth constraints.
Next.js application testing covering Server Components, App Router, API routes, middleware, dynamic routes, and SSR/SSG testing patterns.
Comprehensive NightwatchJS end-to-end testing skill with integrated Selenium WebDriver, built-in assertions, page objects, and parallel test execution for reliable browser automation in JavaScript and TypeScript.
HTTP request mocking with Nock for Node.js testing including request intercepting, response recording, and external API simulation.
Test notification systems for spam behavior including duplicate alerts, missing throttling, incorrect delivery channels, and notification preference violations
Teach agents to run Nuclei DAST and API security scans in CI, write templates, and gate builds on actionable findings.
NUnit 3 constraint-based testing for C# covering Assert.That patterns, parameterized tests, setup/teardown, Moq mocking, test categories, and the fluent assertion model.
Security testing for OAuth2 implementations including authorization code flow, PKCE, token handling, redirect URI validation, and scope enforcement.
Validate progressive web app offline functionality including service worker caching, offline data persistence, sync-on-reconnect behavior, and graceful degradation
Grade LLM and agent traces with OpenAI Evals - build datasets, configure string/python/model graders, run eval suites, and gate agent behavior changes in CI.
OpenAPI/Swagger specification validation and testing to ensure API implementations match their documented contracts with automated drift detection.
Automatically generating API tests from OpenAPI/Swagger specifications including request validation, response schema checking, and edge case generation.
Testing distributed tracing and observability instrumentation with OpenTelemetry including span verification, metric collection, and log correlation.
Integration with Google OSS-Fuzz for continuous fuzzing of open-source projects with automated bug filing and regression tracking.
Security testing skill based on OWASP Top 10, covering ZAP scanning, security headers, input validation, authentication, and authorization testing.
Automated web application security scanning using OWASP ZAP for finding XSS, SQL injection, CSRF, and other OWASP Top 10 vulnerabilities.
Teach agents to automate accessibility testing in CI with pa11y and pa11y-ci, including thresholds, sitemap crawling, GitHub Actions gating, and WCAG rule tuning.
Analyze page load performance using Core Web Vitals, Lighthouse scores, resource waterfall analysis, and performance budgets with automated regression detection.
Testing pagination implementations including cursor-based, offset-based, keyset pagination with edge cases, performance, and consistency verification.
Generate optimized test combinations using pairwise (all-pairs) testing algorithms to achieve maximum coverage with minimum test cases across multiple input parameters
Payment gateway testing including Stripe, PayPal, and Square integration testing with sandbox environments, webhook verification, and error handling.
Testing PCI-DSS compliance for payment processing including encryption validation, access control testing, and secure data storage verification.
Testing PDF generation including layout verification, content accuracy, font embedding, accessibility (PDF/UA), and cross-platform rendering consistency.
Catch UI regressions with Percy visual testing, snapshot strategy, Playwright and Cypress integration, responsive widths, dynamic-content stabilization, review workflow discipline, and CI gating without approval fatigue.
Enforcing performance budgets in CI/CD including bundle size limits, load time thresholds, Lighthouse score gates, and resource count limits.
Generate realistic performance test scenarios with load profiles, ramp-up patterns, think times, and acceptance criteria derived from production traffic analysis
Comprehensive PHP testing with PHPUnit covering assertions, data providers, mocking, test doubles, database testing, and HTTP testing for reliable PHP application development.
Testing patterns for Playwright AI-powered agents including the Planner, Generator, and Healer architecture for self-healing test automation, intelligent test generation, and adaptive test execution strategies.
API testing skill using Playwright's built-in APIRequestContext for RESTful service validation, authentication flows, and API contract verification.
API testing skill using Playwright's built-in APIRequestContext for RESTful service validation, authentication flows, and API contract verification.
Teach AI coding agents to use the Playwright CLI and debug loop efficiently with last-failed runs, locator probing, trace evidence, and safe healing.
CLI-first browser automation using Playwright CLI for navigation, form filling, snapshots, screenshots, data extraction, and UI-flow debugging from the terminal.
Command-line browser automation with Playwright CLI for navigation, snapshots, uploads, downloads, tracing, and QA workflows.
Comprehensive end-to-end testing skill using Playwright for web applications, covering page objects, selectors, assertions, waits, fixtures, and test organization.
Comprehensive end-to-end testing skill using Playwright for web applications, covering page objects, selectors, assertions, waits, fixtures, and test organization.
Advanced Playwright automation with auto-detection, custom fixtures, trace debugging, visual testing, mobile emulation, and production-grade test architecture.
Teaches the agent to build resilient Playwright locators with .filter (hasText/has/hasNot), narrow lists, and reason correctly about visibility, waitFor states, and timeouts.
Mobile web testing skill using Playwright device emulation covering responsive testing, touch interactions, viewport management, network throttling, geolocation testing, and mobile-specific UI patterns.
Teaches the agent to handle popups, new tabs, and multiple browser windows in Playwright using waitForEvent('page'), context pages, and reliable tab switching for OAuth and target=_blank links.
Network-level testing with Playwright including request interception, response mocking, network throttling, and HAR recording/replay.
Teaches the agent when and how to use page.evaluate, evaluateHandle, and exposeFunction in Playwright — passing arguments safely, reading DOM/JS state, and why locators should be preferred for actions.
Teaches the agent to structure tests with test.step, attach evidence and annotations via test.info, use soft assertions, and produce readable, debuggable Playwright HTML reports.
AI-enhanced visual testing with Playwright combining screenshot comparison, visual AI engines, and intelligent diff analysis for catching visual regressions at scale.
Visual regression testing with Playwright including screenshot comparison, pixel-diff thresholds, dynamic content masking, and cross-browser visual validation.
API testing skill using Postman and Newman, covering collections, environments, pre-request scripts, test scripts, and CI/CD integration with Newman.
Automated API testing using Postman collections with Newman CLI for CI/CD integration, environment management, and test reporting.
Build lightweight production smoke test suites that verify critical user paths, API health, and third-party integrations after every deployment.
PWA testing skill covering service worker validation, offline mode testing, cache strategy verification, web app manifest testing, push notification testing, install prompt testing, and background sync verification.
Evaluate and red-team LLM applications with promptfoo, declarative YAML evals, assertions, model comparisons, and automated adversarial scans for prompt injection, jailbreaks, PII leaks, and unsafe outputs in CI.
Comprehensive prompt testing and LLM output evaluation skill covering hallucination detection, response quality scoring, regression testing for prompts, A/B testing, and building evaluation pipelines for AI-powered applications.
Property-based testing using hypothesis, fast-check, and QuickCheck to generate random test inputs and verify program invariants automatically.
Comprehensive Protractor end-to-end testing skill for Angular and AngularJS applications with Angular-specific locators, automatic waitForAngular synchronization, Page Object patterns, and migration guidance to modern frameworks.
Review pull requests for test coverage like a senior SDET, map the diff to required test classes, spot untested branches and missing regression tests, judge test quality not just presence, and write actionable review comments.
Analyze pull request code changes to determine which tests are affected, recommend test execution order, and identify missing test coverage for modified code paths
Use when publishing SEO blog articles to qaskills.sh, e.g. "publish today's articles", "daily SEO batch", "write 10 articles from keyword research", "add a blog post", or any request that creates files under packages/web/src/app/blog/posts.
Automate Chrome with Puppeteer for scraping, screenshots, PDF generation, and E2E checks — correct launch options, reliable waiting with locators and waitForSelector, request interception, and headless CI execution.
Comprehensive Puppeteer browser automation and testing skill for headless Chrome scripting, web scraping, PDF generation, network interception, and end-to-end test workflows in JavaScript and TypeScript.
Opinionated pytest patterns for AI agents - conftest fixture scoping, parametrize, markers, pyproject config, coverage, xdist parallelism, mocking, and AAA-structured test naming.
Python testing skill using pytest, covering fixtures, parametrize, markers, conftest, plugins, mocking, and advanced testing patterns.
Python testing skill using pytest, covering fixtures, parametrize, markers, conftest, plugins, mocking, and advanced testing patterns.
Comprehensive Python testing best practices with pytest, covering unit testing, integration testing, mocking, fixtures, property-based testing, and test architecture.
Comprehensive Python unittest skill covering TestCase patterns, assertion methods, mocking with unittest.mock, subtests, fixtures, and test organization for robust Python application testing.
Turn Claude Code into an autonomous QA agent — an explore, generate, run, heal, report loop that maps the app, writes tests for real user journeys, executes them, self-heals broken locators, and reports coverage. Build a QA agent skill for Claude Code.
Turn Claude Code into an autonomous QA agent — an explore, generate, run, heal, report loop that maps the app, writes tests for real user journeys, executes them, self-heals broken locators, and reports coverage. Build a QA agent skill for Claude Code.
The complete QA skill for Claude Code — turn Claude into an expert QA engineer that picks the right test type, writes reliable Playwright, Cypress, and pytest tests, eliminates flaky tests, enforces coverage, and wires up CI. Claude Code QA testing done right.
Pull weekly/monthly performance metrics for qaskills.sh from Google Analytics 4 (GA4) and Google Search Console (GSC) via Claude in Chrome. Returns traffic, channels, top queries, top pages, growth deltas in a single report.
Teach agents to define and enforce CI quality gates for diff coverage, flaky tests, performance budgets, security thresholds, and regression health.
Detect and diagnose race conditions in web applications through concurrent interaction testing, state mutation analysis, and timing-sensitive scenario reproduction.
Evaluate RAG pipelines with Ragas, measuring faithfulness, answer relevancy, context precision and recall, building golden datasets, and wiring threshold gates into CI for retrieval regressions.
Measure RAG pipeline quality with context precision/recall, faithfulness, answer relevancy, and groundedness using Ragas and DeepEval, with golden datasets and pass/fail thresholds.
Gate RAG pipelines in CI with versioned golden eval sets, per-metric thresholds, baseline drift detection, and a build that fails when retrieval or answer quality regresses.
Component testing using React Testing Library with user-centric queries, accessibility-focused selectors, and integration testing patterns.
Testing real-time collaborative features including conflict resolution, CRDT validation, cursor presence, and concurrent editing scenarios.
Redis testing including cache behavior verification, pub/sub testing, transaction testing, cluster failover testing, and data expiration validation.
Convert bug reports and incident post-mortems into automated regression tests that prevent recurrence of previously discovered defects.
Intelligent regression test selection using code change analysis, dependency graphs, and risk assessment to minimize test execution time.
Teach agents to build go or no-go release readiness scorecards with gated criteria for coverage, flakes, defects, performance, security, and sign-off.
Testing patterns for Remix applications covering loader testing, action testing, route testing, form submission testing, and nested route integration testing.
Automated responsive design testing across breakpoints, viewports, and devices with visual comparison and layout verification.
Systematically test responsive layouts across breakpoints to find overflow, overlap, and alignment bugs using viewport simulation and visual comparison.
Production-grade REST API automation framework with REST Assured, POJO serialization using GSON, PayloadManager pattern, E2E integration workflows with TestNG ITestContext, and Allure reporting.
API testing skill using REST Assured for Java, covering request specifications, response validation, authentication, JSON schema validation, and serialization.
Testing retry mechanisms, circuit breakers, bulkheads, and timeout patterns for building resilient distributed systems.
Risk-based testing approach for prioritizing test efforts based on business impact, change frequency, complexity, and historical defect patterns.
Expert-level Robot Framework testing skill covering keyword-driven syntax, SeleniumLibrary, RequestsLibrary, custom Python keywords, data-driven testing, resource files, and parallel execution with Pabot.
Comprehensive Ruby testing with RSpec including describe/context/it blocks, matchers, let/before hooks, mocking with doubles, shared examples, and Rails integration.
Rails application testing with RSpec, FactoryBot, Capybara, system tests, request specs, model specs, and Rails-specific testing conventions.
Classic xUnit-style Ruby testing with Test::Unit covering assertions, fixtures, test case organization, mocking patterns, and lifecycle hooks for reliable Ruby application testing.
Rust testing with built-in test framework, integration tests, doc tests, property-based testing with proptest, and cargo test configuration.
Processing and analyzing Static Analysis Results Interchange Format (SARIF) files for aggregating security findings across multiple scanning tools.
Generate and maintain visual regression screenshot baselines with intelligent diffing, responsive breakpoint coverage, and dynamic content masking strategies
Cross-platform desktop and application screenshot capture for visual testing, UI verification, and automated visual comparison across macOS, Linux, and Windows.
Integrating screenshot-based visual testing into CI pipelines with baseline management, review workflows, and cross-platform rendering comparison.
Automated screenshot comparison testing with configurable thresholds, anti-aliasing tolerance, and responsive viewport visual validation.
Comprehensive SDET interview preparation covering coding challenges, system design for testing, automation framework design, CI/CD pipeline questions, testing strategy discussions, and behavioral interview patterns for QA engineering roles.
Search feature testing including relevance scoring, autocomplete, typo tolerance, faceted search, pagination, and search analytics verification.
Evaluate search functionality quality including relevance ranking, typo tolerance, faceted filtering, autocomplete accuracy, and zero-results handling
Automated detection and prevention of leaked secrets, API keys, passwords, and tokens in code using tools like gitleaks, trufflehog, and pre-commit hooks.
Generate test data from the schemas you already have. Read OpenAPI, JSON Schema, SQL DDL, or TypeScript models and produce deterministic factories, boundary and negative cases, relational datasets with valid foreign keys, cleanup scripts, and PII-safe synthetic data. Production records never leave the machine.
Perform language and framework specific security best-practice reviews, vulnerability detection, and secure-by-default coding guidance for Python, JavaScript/TypeScript, and Go applications.
Analyze git repositories to build security ownership topology, compute bus factor for sensitive code, detect orphaned security-critical files, and export ownership graphs for visualization.
Repository-grounded threat modeling that enumerates trust boundaries, assets, attacker capabilities, abuse paths, and mitigations to produce actionable AppSec-grade threat models.
Expert-level Selenide UI testing skill for Java applications. Covers concise fluent API, automatic waits, smart selectors, collections, Page Objects, and integration with JUnit 5 and Gradle/Maven builds.
Advanced Selenium WebDriver framework with three Page Object Model patterns (Basic POM, Improved POM, Page Factory), retry mechanisms, Allure reporting, Excel data-driven testing, and Selenoid grid support.
Parallel test execution with Selenium Grid including hub/node configuration, Docker-based grid, cross-browser testing, and session management.
End-to-end web testing skill using Selenium WebDriver with Java, covering WebDriver setup, page objects, explicit waits, and TestNG/JUnit integration.
Port a Java Selenium suite to Playwright TypeScript - locator mapping, WebDriverWait to auto-wait, Grid to workers, Page Object port, with before/after code and a phased checklist.
Teach agents a disciplined strategy for resilient and self-healing locators with role-first selectors, repair evidence, code review, and clear no-heal rules.
Static application security testing using Semgrep for finding vulnerabilities, code smells, and enforcing security policies across codebases.
Integration testing with Sentry for error tracking, performance monitoring, and release health verification in production environments.
Java BDD testing with Serenity BDD framework using the Screenplay pattern, Cucumber integration, step libraries, comprehensive reporting, and living documentation generation.
Testing serverless functions including Lambda, Cloud Functions, and Edge Functions with local emulation, cold start testing, and timeout handling.
Testing Server-Sent Events implementations including event stream validation, reconnection behavior, event ID tracking, and EventSource client testing.
Teach agents to run session-based exploratory testing with charters, time boxes, tours, note-taking, debriefs, and coverage tracking.
Testing skill for shadcn/ui and Radix UI component libraries covering accessible component testing, dialog and popover testing, form validation testing, data table testing, command palette testing, and theme switching verification.
Use when deploying qaskills.sh to production, verifying whether a deploy landed, or when a push to main did not show up on the live site, e.g. "deploy", "ship it", "push this live", "is prod updated?", "the site still shows the old version".
Testing Service Level Agreements and Objectives including availability targets, latency percentiles, error budgets, and automated SLO compliance reporting.
Smart contract testing with Hardhat, Foundry, and Brownie including unit tests, gas optimization, reentrancy checks, and fork testing.
Building effective smoke test suites for deployment verification including critical path coverage, health endpoints, and rapid feedback testing.
Snapshot testing strategies for UI components, API responses, and data structures with update workflows, review patterns, and anti-pattern avoidance.
SOAP web service testing including WSDL validation, XML schema testing, WS-Security, and SOAP fault handling verification.
Testing SOC 2 compliance controls including security monitoring, change management, access reviews, and incident response procedures.
C# .NET BDD testing with SpecFlow using Gherkin feature files, step bindings, hooks, dependency injection, Selenium integration, and living documentation with SpecFlow+ LivingDoc.
Testing implementations against formal specifications including RFC compliance, protocol adherence, and standards conformance verification.
Spring Boot application testing with @SpringBootTest, MockMvc, @DataJpaTest, Testcontainers, and Spring Security testing patterns.
Comprehensive SQL injection testing patterns including blind SQLi, time-based, union-based, and parameterized query validation techniques.
SSL/TLS configuration testing including certificate validation, cipher suite analysis, protocol version checks, and HSTS verification.
Identify stale cache issues across browser cache, CDN layers, API response caching, and application-level caches that cause users to see outdated content
Generate comprehensive test cases from state machine models covering all states, transitions, guard conditions, and invalid transition attempts for workflow-heavy features
Testing UI components through Storybook stories with play functions, interaction testing, accessibility checks, and visual regression via Chromatic.
Streaming API testing skill covering Server-Sent Events testing, chunked transfer encoding, gRPC streaming, real-time data validation, backpressure testing, connection resilience, and AI/LLM streaming response testing.
Stress testing methodologies for finding breaking points, resource exhaustion thresholds, and degradation patterns under extreme load conditions.
Testing patterns for Supabase applications covering auth flow testing, Row Level Security policy testing, realtime subscription testing, and edge function testing
Test Node.js HTTP APIs in-process with SuperTest — request(app) without binding a port, chained .expect assertions, auth headers, JSON body validation, and Jest integration with proper async/await patterns.
Svelte component testing with @testing-library/svelte, vitest, component rendering, event simulation, store testing, and SvelteKit testing.
Swift testing with XCTest, Swift Testing framework, async/await testing, SwiftUI preview testing, and performance measurement.
Synthetic monitoring test creation for uptime checking, user journey simulation, API health verification, and multi-region availability testing.
Testing patterns for TanStack Query (React Query) covering query hook testing, mutation testing, cache behavior testing, and optimistic update verification.
Practice strict red-green-refactor test-driven development — write one failing test first, make it pass with the minimum code, then refactor under green, with worked cycles in Jest and pytest, AAA structure, and behavior-based test naming.
Test-Driven Development mastery with red-green-refactor cycle, outside-in TDD, test-first design, and incremental development patterns.
Infrastructure-as-Code testing with Terratest, terraform validate, plan verification, and drift detection for Terraform configurations.
Designing scalable test architectures including test pyramid, diamond, trophy, and honeycomb patterns with framework-agnostic implementation.
Comprehensive TestCafe end-to-end testing skill for writing reliable browser automation tests in JavaScript and TypeScript without WebDriver dependencies, featuring smart assertions, automatic waiting, and parallel execution.
Automatically generate comprehensive test cases from user stories and acceptance criteria using BDD patterns, equivalence partitioning, and risk-based prioritization
Docker-based integration testing with Testcontainers for databases, message queues, cloud services, and custom containers with lifecycle management.
Teaches the agent to speed up Node integration tests with Testcontainers reuse — withReuse(true), TESTCONTAINERS_REUSE_ENABLE, the .testcontainers.properties opt-in, stable hashing for Postgres/MySQL/Kafka, and Ryuk/CI caveats.
Identify untested code paths, uncovered branches, and missing test scenarios using coverage analysis, risk mapping, and change-based coverage tracking
Optimizing test coverage beyond line coverage including branch coverage, mutation score, path coverage, and identifying meaningful coverage gaps.
Anonymizing production data for testing while maintaining referential integrity, data distributions, and edge case representation.
Build reusable test data factories with realistic fake data generation, relationship handling, and deterministic seeding for reproducible tests.
Test data generation and management skill covering Faker.js, factory patterns, builders, database seeding, and test data strategies for reliable test suites.
Quantify and prioritize test technical debt by analyzing coverage gaps, flaky test ratios, outdated assertions, and missing test categories across codebases.
Generating human-readable test documentation from test code including test catalogs, coverage reports, and living documentation websites.
Comprehensive guide to test doubles including mocks, stubs, spies, fakes, and dummies with when-to-use guidelines and anti-pattern avoidance.
Master the Test-Driven Development approach with Red-Green-Refactor cycles, writing tests before code, comprehensive coverage patterns, and quality code practices for building robust, maintainable software.
Managing test environments including provisioning, configuration, data seeding, isolation, cleanup, and environment-as-code patterns.
Test fixture design patterns including builders, factories, object mothers, and fixture management for maintainable test data setup.
Detecting and diagnosing flaky tests using statistical analysis, execution recording, environmental factor isolation, and quarantine strategies.
Analyzing code changes to determine which tests are impacted, enabling selective test execution and faster CI feedback loops.
Safe testing-in-production strategies including feature flags, shadow traffic, canary releases, dark launches, and observability-driven development.
Test isolation techniques including database cleanup, transaction rollback, parallel test execution, and shared resource management.
Define and build QA metrics that drive decisions, escape rate, flake rate, coverage of risk, MTTR for test failures, release readiness scorecards, anti-gaming rules, and dashboard layouts with SQL and query examples.
Test framework migration skill covering strategies for migrating between testing frameworks including Selenium to Playwright, Jest to Vitest, Enzyme to React Testing Library, and Protractor to Cypress with automated codemods and incremental migration patterns.
Advanced Java testing with TestNG covering data providers, parallel execution, test groups, XML suite configuration, listeners, soft assertions, and dependency management.
Implementing test observability with execution analytics, failure trend analysis, coverage gap detection, and test suite health dashboards.
Data-driven testing with parameterized tests, test matrices, combinatorial testing, and pairwise parameter generation techniques.
Test plan generation skill covering requirements analysis, test strategy, coverage matrices, risk-based testing, and test estimation techniques.
Organize testing in TestRail, suite and section architecture, writing maintainable cases, test runs and plans, milestone reporting, and TestRail API automation to push automated results into one quality view.
Building test reporting dashboards with real-time execution metrics, trend analysis, flaky test detection, coverage visualization, and integration with Allure, ReportPortal, and custom dashboards using Grafana and Prometheus.
End-to-end test automation using testRigor's plain English syntax for writing maintainable tests without coding, covering cross-browser testing, mobile testing, API validation, and integrations with CI/CD pipelines.
Comprehensive test strategy design methodology covering risk-based testing, test pyramid optimization, coverage planning, environment strategy, data management, and test automation ROI analysis for enterprise and startup contexts.
Optimizing test suite execution speed with parallelization, test splitting, caching, selective test execution, and test impact analysis.
Find timezone-related bugs in date handling, scheduling, and display logic by testing across multiple timezones and edge cases like DST transitions.
End-to-end type-safe API testing with tRPC covering router testing, middleware testing, subscription testing, and client-server integration testing patterns
Testing patterns for Turborepo and pnpm monorepos covering workspace dependency testing, affected package detection, parallel test execution, and shared test utilities
Generate high-signal unit tests for existing code, behavior-first case selection, boundary and error paths, mocking discipline, mutation-tested quality, and framework-idiomatic output for Vitest, Jest, and pytest.
Identify and log user experience friction points including excessive clicks, confusing navigation, slow interactions, and workflow bottlenecks through automated heuristic analysis
Testing patterns for Vercel Edge Functions, middleware, and serverless functions covering local testing, edge runtime simulation, and deployment verification.
Enforces rigorous verification evidence before any claims of task completion, preventing false positives, untested deployments, and premature celebration with a structured gate function.
Browser automation for AI agents. Navigate pages, fill forms, click elements, take screenshots, and manage tabs — all through simple CLI commands. 2.6k+ GitHub stars.
Natural language test automation methodology where tests are written as plain English instructions, leveraging AI agents to interpret intent, generate executable tests, and maintain test suites without traditional code-based selectors or assertions.
Visual regression testing skill using Playwright, covering screenshot comparison, visual diff thresholds, responsive testing, baseline management, and CI integration.
Teaches the agent to migrate a Jest suite to Vitest — vi.mock and the globals shim, vitest.config workspaces/projects, coverage, browser mode, and Vitest v4 breaking changes.
Modern JavaScript and TypeScript testing with Vitest, covering unit testing, integration testing, mocking, snapshots, browser mode, and Vite integration.
Write fast unit and integration tests with Vitest — vitest.config.ts setup, vi.fn and vi.mock module mocking, fake timers, snapshots, V8 coverage with thresholds, workspaces for monorepos, and in-source testing.
Testing voice-activated applications including speech recognition accuracy, intent detection, dialog flow testing, and multi-language support.
Test Vue 3 components with Vue Test Utils and Vitest — mount vs shallowMount, finding and triggering DOM, asserting props and emitted events, awaiting async updates, and mocking Pinia stores and Vue Router.
Vue.js component testing using Vue Test Utils with mount/shallow mount, event simulation, Vuex/Pinia store testing, and composition API testing.
Automated WCAG 2.2 AA/AAA compliance testing with axe-core, Pa11y, and manual testing patterns for keyboard navigation, screen readers, and color contrast.
Anthropic's official web application testing skill using native Python Playwright scripts with helper utilities for server lifecycle management, browser automation, and comprehensive E2E testing workflows.
Testing WebAssembly modules including compilation verification, memory management, interop testing, and performance benchmarking of WASM components.
Build WebdriverIO E2E suites — wdio.conf.ts setup, $ and $$ selectors, auto-wait and waitUntil, Mocha framework structure, page objects, parallel capabilities, and services for visual testing and Appium mobile.
Comprehensive WebDriverIO (WDIO) test automation skill for generating reliable end-to-end browser tests in JavaScript and TypeScript with Page Object Model, custom commands, and advanced synchronization strategies.
Testing webhook implementations including delivery verification, retry logic, signature validation, idempotency, and failure handling patterns.
Comprehensive website auditing skill using Lighthouse, PageSpeed Insights, and web performance APIs to audit performance, accessibility, SEO, best practices, and security.
Test WebSocket connections for reliability including reconnection logic, message ordering, heartbeat mechanisms, and connection state management under adverse conditions
API simulation and service virtualization with WireMock for HTTP stubbing, request matching, stateful behavior, and fault injection testing.
iOS UI testing with XCUITest framework covering element queries, gesture simulation, accessibility testing, and Xcode test plan configuration.
Teach agents to manage Jira test cases and executions with Xray and Zephyr, including issue modeling, JQL, and CI result publishing through REST APIs.
Cross-site scripting vulnerability testing covering reflected, stored, and DOM-based XSS with sanitization validation and CSP bypass detection.
Comprehensive xUnit.net testing skill for writing reliable unit, integration, and acceptance tests in C# with [Fact], [Theory], fixtures, dependency injection, and parallel execution strategies.
Writing and testing YARA rules for malware detection, threat hunting, and file classification with rule validation and false-positive rate testing.
Comprehensive testing patterns for Zod schemas covering validation testing, transform testing, error message verification, and integration with API endpoints and forms