QA Skills for Windsurf

AI-native browser automation — 81 CLI commands for navigating pages, filling forms, clicking elements, taking screenshots, and managing tabs. 2.6k+ GitHub stars.

Jest unit testing patterns with mocking, spies, snapshots, and async testing

Cypress end-to-end testing with custom commands, intercepts, and component testing

User-centric React component testing with queries, events, and async utilities

Browser automation tool by Vercel Labs enabling programmatic web interaction. Navigate URLs, capture interactive elements with refs, fill forms, take screenshots, generate PDFs, and run parallel sessions.

Blazing fast Vite-native unit testing with Jest-compatible API and ESM support

Python testing with pytest fixtures, parametrize, markers, and plugins

Headless Chrome automation with Puppeteer for web scraping, PDF generation, and E2E testing

Automated performance, accessibility, and SEO auditing with Google Lighthouse

Modern load testing with k6 including thresholds, scenarios, and custom metrics

Mock Service Worker for seamless API mocking in browser and Node.js environments

API testing with Playwright APIRequestContext for REST and GraphQL endpoints

Official Vue.js testing utilities for component mounting, mocking, and assertions

Track test coverage with Istanbul/nyc, generate reports, and enforce thresholds

Test React, Vue, and Angular components in isolation with Storybook interactions and play functions

Configure testing in CI/CD pipelines for GitHub Actions, Jenkins, and GitLab CI

Production-grade REST API automation framework with REST Assured, POJO serialization using GSON, PayloadManager pattern, E2E integration workflows with TestNG ITestContext, and Allure reporting.

HTTP assertion library for Node.js API testing with Express, Koa, and Fastify

OWASP Top 10 security testing patterns and vulnerability scanning

Enforce testing best practices with ESLint rules for Jest, Testing Library, and Cypress

Angular TestBed component testing with dependency injection, async testing, and Jasmine

Integration testing with throwaway Docker containers for databases and external services

Simple mobile UI testing with YAML flows for iOS and Android without complex setup

GraphQL API testing with schema validation, query testing, and mutation verification

Component and API snapshot testing to detect unexpected changes across releases

Postman collections, environments, pre-request scripts, and Newman CI

Test-driven development workflow patterns with red-green-refactor cycle and refactoring techniques

Modern load testing toolkit with YAML-based scenarios, metrics, and CI/CD integration

Test data strategies using Faker.js, factories, builders, and database seeding

Gray box E2E testing for React Native apps on iOS and Android simulators

Comprehensive authentication and authorization bypass testing including session hijacking, privilege escalation, JWT manipulation, and access control verification

Network latency simulation and testing for measuring application behavior under various network conditions including high latency, packet loss, and bandwidth constraints.

i18n testing covering locale switching, date/number formatting, RTL layout, plural forms, ICU messages, and translation completeness verification.

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.

Vue.js component testing using Vue Test Utils with mount/shallow mount, event simulation, Vuex/Pinia store testing, and composition API testing.

Cross-browser E2E testing with WebdriverIO, Cucumber integration, and visual regression

Test quality verification with Stryker mutation testing for JavaScript and TypeScript

Testing SOC 2 compliance controls including security monitoring, change management, access reviews, and incident response procedures.

SSL/TLS configuration testing including certificate validation, cipher suite analysis, protocol version checks, and HSTS verification.

Testing patterns for Turborepo and pnpm monorepos covering workspace dependency testing, affected package detection, parallel test execution, and shared test utilities

C# .NET BDD testing with SpecFlow using Gherkin feature files, step bindings, hooks, dependency injection, Selenium integration, and living documentation with SpecFlow+ LivingDoc.

Integrating screenshot-based visual testing into CI pipelines with baseline management, review workflows, and cross-platform rendering comparison.

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.

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.

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.

Testing application configurations including environment variable validation, feature flag combinations, config file parsing, and default value verification.

Contract-first testing approach using Pact, Spring Cloud Contract, or Dredd for ensuring API consumer-provider compatibility.

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.

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.

FastAPI application testing with TestClient, dependency injection overrides, async testing, database testing with SQLAlchemy, and OpenAPI validation.

Enforcing performance budgets in CI/CD including bundle size limits, load time thresholds, Lighthouse score gates, and resource count limits.

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.

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.

PHP BDD testing with Behat framework using Gherkin feature files, Mink browser extension, context classes, and Symfony integration for behavior-driven acceptance testing.

Generating human-readable test documentation from test code including test catalogs, coverage reports, and living documentation websites.

Android UI testing framework with synchronization, view matchers, and actions

Teach agents to run Nuclei DAST and API security scans in CI, write templates, and gate builds on actionable findings.

Smart contract testing with Hardhat, Foundry, and Brownie including unit tests, gas optimization, reentrancy checks, and fork testing.

Testing load balancer configurations including health check validation, routing algorithms, session affinity, failover behavior, and SSL termination.

Testing browser extensions including content script injection, background worker testing, popup UI testing, storage API testing, and cross-browser compatibility.

Canary deployment validation testing including traffic splitting, metric comparison, automatic rollback triggers, and health score calculation.

Test automation with Gauge framework using Markdown specifications, step implementations in Java/Python/JavaScript/Ruby/C#, concepts, data-driven testing, and living documentation.

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.

Testing event sourcing patterns including event store validation, projection testing, saga orchestration, and event versioning compatibility.

Comprehensive Python testing best practices with pytest, covering unit testing, integration testing, mocking, fixtures, property-based testing, and test architecture.

Testing machine learning models including accuracy validation, bias detection, drift monitoring, A/B testing, and model regression testing.

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.

Static application security testing using Semgrep for finding vulnerabilities, code smells, and enforcing security policies across codebases.

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.

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.

Stress testing methodologies for finding breaking points, resource exhaustion thresholds, and degradation patterns under extreme load conditions.

Comprehensive WCAG 2.1 AA compliance testing combining automated axe-core scans with manual keyboard navigation, screen reader compatibility, and focus management 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.

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.

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.

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.

Visual regression testing with Playwright screenshots and diff comparison

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.

Teach agents to manage Jira test cases and executions with Xray and Zephyr, including issue modeling, JQL, and CI result publishing through REST APIs.

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.

Network-level testing with Playwright including request interception, response mocking, network throttling, and HAR recording/replay.

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.

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.

Apache JMeter load testing with thread groups, assertions, and distributed testing

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.

Advanced Allure test reporting with custom categories, environment info, test history trends, flaky test detection, and CI/CD dashboard integration.

Flexible JavaScript testing framework with async support, hooks, and rich reporter ecosystem

Enforces rigorous verification evidence before any claims of task completion, preventing false positives, untested deployments, and premature celebration with a structured gate function.

Writing and testing YARA rules for malware detection, threat hunting, and file classification with rule validation and false-positive rate testing.

Frontend performance testing covering bundle size analysis, render performance, animation frame rate, React re-render detection, and lazy loading verification.

Automatically generate comprehensive API test suites from OpenAPI specifications covering CRUD operations, error handling, authentication, pagination, and edge cases

Testing patterns for Vercel Edge Functions, middleware, and serverless functions covering local testing, edge runtime simulation, and deployment verification.

Exhaustive testing of form validation logic including boundary values, injection payloads, encoding edge cases, and client-server validation bypass techniques

Design and maintain lightweight production smoke test suites that verify critical user journeys, API health, and infrastructure availability after deployments

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

Teach agents to use the Chrome DevTools MCP server for performance testing with traces, Core Web Vitals, throttling, and evidence-based analysis.

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.

Integration with Google OSS-Fuzz for continuous fuzzing of open-source projects with automated bug filing and regression tracking.

Testing feature flag implementations including flag evaluation, gradual rollout verification, fallback behavior, and flag cleanup detection.

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.

Validate API responses against OpenAPI/Swagger specifications, JSON Schema definitions, and consumer-driven contracts to prevent breaking changes

SOAP web service testing including WSDL validation, XML schema testing, WS-Security, and SOAP fault handling verification.

Testing voice-activated applications including speech recognition accuracy, intent detection, dialog flow testing, and multi-language support.

Automated accessibility testing with axe-core and WCAG 2.1 compliance

Simulate aggressive user behavior patterns including rapid clicking, random navigation, form abuse, tab spamming, and unexpected interaction sequences to find UI resilience issues

Writing custom static analysis rules for ESLint, Semgrep, and SonarQube to enforce project-specific code quality and security standards.

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.

Detect, quarantine, and systematically fix flaky tests with automated retry analysis, root cause categorization, and CI pipeline integration for test reliability

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.

Native iOS UI testing with Swift and Xcode Test Navigator integration

Debug and fix failing GitHub PR checks by inspecting GitHub Actions logs, summarizing failure context, drafting fix plans, and implementing fixes after approval.

Parallel test execution with Selenium Grid including hub/node configuration, Docker-based grid, cross-browser testing, and session management.

NUnit 3 constraint-based testing for C# covering Assert.That patterns, parameterized tests, setup/teardown, Moq mocking, test categories, and the fluent assertion model.

Behavior-Driven Development with Gherkin syntax, step definitions, scenario outlines, data tables, and living documentation generation.

Testing retry mechanisms, circuit breakers, bulkheads, and timeout patterns for building resilient distributed systems.

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.

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.

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.

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.

Implementing test observability with execution analytics, failure trend analysis, coverage gap detection, and test suite health dashboards.

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.

Teach agents a disciplined strategy for resilient and self-healing locators with role-first selectors, repair evidence, code review, and clear no-heal rules.

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.

Teaches the agent to build resilient Playwright locators with .filter (hasText/has/hasNot), narrow lists, and reason correctly about visibility, waitFor states, and timeouts.

Designing scalable test architectures including test pyramid, diamond, trophy, and honeycomb patterns with framework-agnostic implementation.

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.

Automated page performance auditing covering Core Web Vitals, resource loading analysis, render-blocking detection, and performance budget enforcement

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.

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.

Web application security testing using BurpSuite for proxy-based interception, scanning, and manual penetration testing of web applications.

Testing WebAssembly modules including compilation verification, memory management, interop testing, and performance benchmarking of WASM components.

Modern JavaScript testing strategies with Jest, Mocha, and testing best practices covering unit testing, integration testing, mocking, async patterns, and DOM testing.

Payment gateway testing including Stripe, PayPal, and Square integration testing with sandbox environments, webhook verification, and error handling.

Automated detection of breaking API changes including response format changes, removed endpoints, type changes, and deprecation enforcement.

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.

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.

Teach agents to build go or no-go release readiness scorecards with gated criteria for coverage, flakes, defects, performance, security, and sign-off.

Testing API versioning strategies including URL path, header, and query parameter versioning with backward compatibility validation.

Java REST API testing with REST Assured including JSON schema validation

Optimize CI/CD test pipeline execution through intelligent test splitting, parallelization, caching strategies, and selective test execution to reduce pipeline duration

Building hermetic tests that are fully isolated from external dependencies using fakes, containers, and deterministic time/random sources.

Svelte component testing with @testing-library/svelte, vitest, component rendering, event simulation, store testing, and SvelteKit testing.

Comprehensive file upload testing including format validation, size limits, malware scanning, storage verification, and concurrent upload handling.

Generative testing with fast-check to discover edge cases automatically

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.

Risk-based testing approach for prioritizing test efforts based on business impact, change frequency, complexity, and historical defect patterns.

Detecting and diagnosing flaky tests using statistical analysis, execution recording, environmental factor isolation, and quarantine strategies.

Comprehensive SQL injection testing patterns including blind SQLi, time-based, union-based, and parameterized query validation techniques.

Detect and eliminate N+1 query problems in database-backed applications through query counting, execution plan analysis, and ORM configuration auditing

Automated responsive design testing across breakpoints, viewports, and devices with visual comparison and layout verification.

API simulation and service virtualization with WireMock for HTTP stubbing, request matching, stateful behavior, and fault injection testing.

Systematic memory profiling and leak detection in applications using heap snapshots, allocation tracking, and garbage collection analysis.

Identify untested code paths, uncovered branches, and missing test scenarios using coverage analysis, risk mapping, and change-based coverage tracking

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.

Golden file testing pattern for comparing output against approved baselines with update workflows, diff tools, and version control integration.

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.

End-to-end testing for React Native apps using Detox with gray-box testing, synchronization, device simulation, and CI integration.

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.

Testing serverless functions including Lambda, Cloud Functions, and Edge Functions with local emulation, cold start testing, and timeout handling.

Automated open-source license compliance testing to detect license conflicts, copyleft violations, and license compatibility issues in dependencies.

Infrastructure-as-Code testing with Terratest, terraform validate, plan verification, and drift detection for Terraform configurations.

Generate consumer-driven contract tests using Pact framework to verify API provider-consumer compatibility and prevent integration breaking changes

Role-based and attribute-based access control testing including permission matrices, privilege escalation prevention, and resource-level authorization.

Intelligent regression test selection using code change analysis, dependency graphs, and risk assessment to minimize test execution time.

Node.js E2E testing framework with TypeScript support, smart assertions, and parallel execution

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.

Integration testing with Sentry for error tracking, performance monitoring, and release health verification in production environments.

Automated detection and reporting of broken links, missing resources, and orphaned pages across web applications using crawl-based and DOM-based strategies

Teach AI coding agents to use the Playwright CLI and debug loop efficiently with last-failed runs, locator probing, trace evidence, and safe healing.

Python BDD testing with Behave framework using Gherkin feature files, step definitions, environment hooks, and Selenium integration for behavior-driven acceptance testing.

Generating realistic test data with Faker libraries for names, addresses, emails, dates, and domain-specific data with reproducible seed control.

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.

DNS configuration testing including record validation, DNSSEC verification, resolution timing, failover testing, and DNS-based service discovery.

End-to-end type-safe API testing with tRPC covering router testing, middleware testing, subscription testing, and client-server integration testing patterns

Analyzing code changes to determine which tests are impacted, enabling selective test execution and faster CI feedback loops.

Mobile app testing automation for iOS and Android with Appium

Detect and reproduce race conditions in web applications including double submissions, concurrent state mutations, and timing-dependent UI bugs

Automatically generate comprehensive test cases from user stories and acceptance criteria using BDD patterns, equivalence partitioning, and risk-based prioritization

Systematically generate negative test cases covering invalid inputs, unauthorized actions, missing required fields, exceeded limits, and malformed request payloads

Build reusable test data factories with builder patterns, realistic fake data generation, relationship handling, and database seeding for consistent test environments

Testing monitoring and alerting configurations including threshold validation, alert routing, escalation policies, and false-positive rate monitoring.

Analyze pull request code changes to determine which tests are affected, recommend test execution order, and identify missing test coverage for modified code paths

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.

Database performance testing including query optimization, index analysis, connection pooling, slow query detection, and N+1 query prevention.

Email delivery testing including content verification, rendering across clients, spam score checking, link validation, and transactional email workflow testing.

Setting up and optimizing test pipelines in GitHub Actions with caching, parallel execution, matrix builds, and test result reporting.

IoT device testing including firmware validation, protocol testing (MQTT, CoAP), power consumption testing, and over-the-air update verification.

HTTP request mocking with Nock for Node.js testing including request intercepting, response recording, and external API simulation.

Comprehensive Python unittest skill covering TestCase patterns, assertion methods, mocking with unittest.mock, subtests, fixtures, and test organization for robust Python application testing.

AI-enhanced visual testing with Playwright combining screenshot comparison, visual AI engines, and intelligent diff analysis for catching visual regressions at scale.

Testing Docker containers and images including Dockerfile linting, container structure tests, security scanning, and multi-stage build validation.

Perform language and framework specific security best-practice reviews, vulnerability detection, and secure-by-default coding guidance for Python, JavaScript/TypeScript, and Go applications.

Automated cross-browser testing across Chrome, Firefox, Safari, and Edge with visual comparison, feature detection, and polyfill verification.

Detect timezone-related bugs including incorrect date conversions, DST edge cases, locale formatting issues, and UTC offset miscalculations across application layers

Advanced security analysis using GitHub CodeQL to find zero-day vulnerabilities, injection flaws, and security anti-patterns in source code.

Systematically detect, capture, and categorize browser console errors, warnings, and unhandled exceptions during automated test execution

Comprehensive testing patterns for Zod schemas covering validation testing, transform testing, error message verification, and integration with API endpoints and forms

Generate tests for database migration safety covering schema changes, data integrity preservation, rollback verification, and zero-downtime migration validation

Automated detection and prevention of leaked secrets, API keys, passwords, and tokens in code using tools like gitleaks, trufflehog, and pre-commit hooks.

Testing in ephemeral preview environments for pull requests including environment provisioning, data seeding, and automated teardown.

Consumer-driven contract testing for microservices using Pact, ensuring API compatibility and preventing integration breakages across service boundaries.

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.

CLI-first browser automation using Playwright CLI for navigation, form filling, snapshots, screenshots, data extraction, and UI-flow debugging from the terminal.

Chaos testing for Kubernetes workloads using Chaos Mesh, Litmus, and custom fault injection for pod, network, and disk failures.

Mobile web testing skill using Playwright device emulation covering responsive testing, touch interactions, viewport management, network throttling, geolocation testing, and mobile-specific UI patterns.

Building effective smoke test suites for deployment verification including critical path coverage, health endpoints, and rapid feedback testing.

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.

Generate boundary value test cases for numeric ranges, string lengths, date ranges, collection sizes, and domain-specific constraints using systematic analysis techniques

Flutter app testing with widget tests, integration tests, golden tests, Mockito, bloc testing, and Flutter Driver for end-to-end scenarios.

Generate realistic performance test scenarios with load profiles, ramp-up patterns, think times, and acceptance criteria derived from production traffic analysis

Configure and generate rich Allure test reports with test categorization, historical trends, environment details, and CI/CD integration for comprehensive test visibility

Search feature testing including relevance scoring, autocomplete, typo tolerance, faceted search, pagination, and search analytics verification.

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.

Testing CI/CD pipeline configurations including build validation, deployment verification, rollback testing, and pipeline-as-code quality checks.

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.

Comprehensive website auditing skill using Lighthouse, PageSpeed Insights, and web performance APIs to audit performance, accessibility, SEO, best practices, and security.

Testing PCI-DSS compliance for payment processing including encryption validation, access control testing, and secure data storage verification.

Testing patterns for TanStack Query (React Query) covering query hook testing, mutation testing, cache behavior testing, and optimistic update verification.

Validating A/B test implementations including traffic splitting accuracy, statistical significance calculation, metric tracking, and experiment cleanup.

Generate and evaluate mutation tests to assess test suite effectiveness by introducing controlled code mutations and verifying test detection rates

Synthetic monitoring test creation for uptime checking, user journey simulation, API health verification, and multi-region availability testing.

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.

Generate and maintain visual regression screenshot baselines with intelligent diffing, responsive breakpoint coverage, and dynamic content masking strategies

Generate comprehensive test cases from state machine models covering all states, transitions, guard conditions, and invalid transition attempts for workflow-heavy features

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.

Evaluate search functionality quality including relevance ranking, typo tolerance, faceted filtering, autocomplete accuracy, and zero-results handling

Verify loading states, skeleton screens, spinners, and progress indicators across all data-fetching scenarios including slow networks, errors, and partial loads

Identify and diagnose memory leaks in web applications through heap analysis, DOM node counting, detached element detection, and performance profiling

.NET testing with xUnit, NUnit, MSTest, FluentAssertions, Moq, integration testing with WebApplicationFactory, and Entity Framework testing.

Validate error boundary implementations in React and other frameworks ensuring graceful degradation, proper fallback UI rendering, and error recovery flows

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.

Opinionated pytest patterns for AI agents - conftest fixture scoping, parametrize, markers, pyproject config, coverage, xdist parallelism, mocking, and AAA-structured test naming.

Security testing for LLM-powered applications including prompt injection, jailbreak detection, data leakage prevention, and AI safety testing.

Test fixture design patterns including builders, factories, object mothers, and fixture management for maintainable test data setup.

Behavior-driven development with Cucumber, Gherkin, and step definitions

Comprehensive Ruby testing with RSpec including describe/context/it blocks, matchers, let/before hooks, mocking with doubles, shared examples, and Rails integration.

Rust testing with built-in test framework, integration tests, doc tests, property-based testing with proptest, and cargo test configuration.

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.

Kotlin testing with JUnit 5, MockK, Kotest, coroutine testing, Android testing with Espresso, and Kotlin-specific assertion libraries.

Detecting and testing infrastructure drift between desired state and actual state using automated scanning, alerting, and remediation patterns.

Testing distributed tracing implementations including context propagation, span correlation, baggage handling, and trace sampling verification.

Testing GDPR compliance requirements including data deletion, consent management, data portability, right to erasure, and privacy policy enforcement.

Automated accessibility testing with axe-core integrated into CI pipelines, including custom rule configuration, issue prioritization, and remediation guidance.

Testing patterns for Supabase applications covering auth flow testing, Row Level Security policy testing, realtime subscription testing, and edge function testing

Production-grade Java unit and integration testing with JUnit 5 covering assertions, parameterized tests, lifecycle hooks, Mockito mocking, nested tests, and extensions.

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.

API mocking with Mock Service Worker for browser and Node.js environments including request interception, response simulation, and network error testing.

Swift testing with XCTest, Swift Testing framework, async/await testing, SwiftUI preview testing, and performance measurement.

OpenAPI/Swagger specification validation and testing to ensure API implementations match their documented contracts with automated drift detection.

End-to-end database testing with test containers, data seeding, cleanup strategies, transaction isolation, and production data anonymization.

Verifying data integrity constraints, referential integrity, data type validation, and consistency checks across database operations.

Systematic dark mode testing covering color contrast, theme switching, persistence, media query respect, component-level theming, and image adaptation.

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.

Generate comprehensive test plans with coverage matrices and risk-based testing

Testing database migration scripts for correctness, rollback safety, data integrity, and zero-downtime migration patterns.

Testing data pipelines including ETL validation, data quality checks, pipeline orchestration testing, and data lineage verification.

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.

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.

Classic xUnit-style Ruby testing with Test::Unit covering assertions, fixtures, test case organization, mocking patterns, and lifecycle hooks for reliable Ruby application testing.

Fuzz testing for Rust applications using cargo-fuzz and libFuzzer to discover memory safety issues, panics, and undefined behavior.

Rails application testing with RSpec, FactoryBot, Capybara, system tests, request specs, model specs, and Rails-specific testing conventions.

Testing real-time collaborative features including conflict resolution, CRDT validation, cursor presence, and concurrent editing scenarios.

Test isolation techniques including database cleanup, transaction rollback, parallel test execution, and shared resource management.

Modern cloud-scale load testing using Artillery.io for HTTP, WebSocket, Socket.io, and custom protocol testing with YAML-based test definitions.