
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.
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.
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.
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.
Teach agents to build go or no-go release readiness scorecards with gated criteria for coverage, flakes, defects, performance, security, and sign-off.
Teach agents a disciplined strategy for resilient and self-healing locators with role-first selectors, repair evidence, code review, and clear no-heal rules.
Teach agents to define and enforce CI quality gates for diff coverage, flaky tests, performance budgets, security thresholds, and regression health.
Teach agents to run session-based exploratory testing with charters, time boxes, tours, note-taking, debriefs, and coverage tracking.
Teach agents to manage Jira test cases and executions with Xray and Zephyr, including issue modeling, JQL, and CI result publishing through REST APIs.
Teach agents to use AI browser agents for exploratory and smoke QA with step budgets, evidence-based assertions, guardrails, and Playwright conversion.
Teach agents to guide manual accessibility audits for keyboard, screen reader, zoom, reflow, focus, and WCAG 2.2 criteria that scanners miss.
Teach agents to build synthetic monitoring as code with Checkly, including Playwright browser checks, API checks, alerting, and CI deploy workflows.
Teach agents to shard and parallelize Playwright, Jest, and pytest suites in CI to reduce wall-clock time while merging reports reliably.
Teach agents to automate accessibility testing in CI with pa11y and pa11y-ci, including thresholds, sitemap crawling, GitHub Actions gating, and WCAG rule tuning.
Teach agents to run Nuclei DAST and API security scans in CI, write templates, and gate builds on actionable findings.
Teach AI coding agents to use the Playwright CLI and debug loop efficiently with last-failed runs, locator probing, trace evidence, and safe healing.
Teach agents to use the Chrome DevTools MCP server for performance testing with traces, Core Web Vitals, throttling, and evidence-based analysis.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
End-to-end testing skill using Cypress for web applications, covering custom commands, network intercepts, fixtures, cy.session, and component testing patterns.
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.
Python testing skill using pytest, covering fixtures, parametrize, markers, conftest, plugins, mocking, and advanced testing patterns.
Comprehensive RESTful API testing patterns covering HTTP methods, status codes, request/response validation, authentication, error handling, and contract testing.
Comprehensive end-to-end testing skill using Playwright for web applications, covering page objects, selectors, assertions, waits, fixtures, and test organization.
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.
Unit testing skill using Jest for TypeScript and JavaScript, covering mocking, spies, snapshots, coverage, async testing, and custom matchers.
Performance and load testing skill using k6, covering load test scripts, thresholds, scenarios, checks, custom metrics, and results analysis.
API testing skill using Playwright's built-in APIRequestContext for RESTful service validation, authentication flows, and API contract verification.
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.
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.
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.
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.
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.
SOAP web service testing including WSDL validation, XML schema testing, WS-Security, and SOAP fault handling verification.
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.
Vue.js component testing using Vue Test Utils with mount/shallow mount, event simulation, Vuex/Pinia store testing, and composition API testing.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Opinionated pytest patterns for AI agents - conftest fixture scoping, parametrize, markers, pyproject config, coverage, xdist parallelism, mocking, and AAA-structured test naming.
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.
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 migrate a Jest suite to Vitest — vi.mock and the globals shim, vitest.config workspaces/projects, coverage, browser mode, and Vitest v4 breaking changes.
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.
Measure RAG pipeline quality with context precision/recall, faithfulness, answer relevancy, and groundedness using Ragas and DeepEval, with golden datasets and pass/fail thresholds.
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.
Teaches the agent to build resilient Playwright locators with .filter (hasText/has/hasNot), narrow lists, and reason correctly about visibility, waitFor states, and timeouts.
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.
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.
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.
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.
Testing patterns for Drizzle ORM covering migration testing, query builder testing, transaction testing, and database integration testing with PostgreSQL, SQLite, and MySQL.
End-to-end database testing with test containers, data seeding, cleanup strategies, transaction isolation, and production data anonymization.
Validate error boundary implementations in React and other frameworks ensuring graceful degradation, proper fallback UI rendering, and error recovery flows
Android UI testing with Espresso framework including view matchers, actions, assertions, idling resources, and RecyclerView testing patterns.
Express.js API testing with supertest, middleware testing, route handler testing, error handling verification, and authentication testing.
FastAPI application testing with TestClient, dependency injection overrides, async testing, database testing with SQLAlchemy, and OpenAPI validation.
Validate the first-time user experience including onboarding flows, empty states, tutorial completion, progressive disclosure, and initial setup wizards
Exhaustive testing of form validation logic including boundary values, injection payloads, encoding edge cases, and client-server validation bypass techniques
Browser automation testing with Geb framework for Groovy/JVM using jQuery-like content DSL, Page Object pattern, Spock integration, and WebDriver abstraction.
Testing GraphQL subscriptions including WebSocket lifecycle, real-time event delivery, authorization on subscriptions, and connection management.
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.
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.
Identify and diagnose memory leaks in web applications using heap snapshots, allocation timelines, and automated leak detection patterns.
Python-based load testing with Locust for writing user behavior scripts, distributed testing, real-time web UI monitoring, and custom load shapes.
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.
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.
Testing CI/CD pipeline configurations including build validation, deployment verification, rollback testing, and pipeline-as-code quality checks.
AI-enhanced visual testing with Playwright combining screenshot comparison, visual AI engines, and intelligent diff analysis for catching visual regressions at scale.
Command-line browser automation with Playwright CLI for navigation, snapshots, uploads, downloads, tracing, and QA workflows.
Rust testing with built-in test framework, integration tests, doc tests, property-based testing with proptest, and cargo test configuration.
Parallel test execution with Selenium Grid including hub/node configuration, Docker-based grid, cross-browser testing, and session management.
Integration testing with Sentry for error tracking, performance monitoring, and release health verification in production environments.
Evaluate search functionality quality including relevance ranking, typo tolerance, faceted filtering, autocomplete accuracy, and zero-results handling
Testing Service Level Agreements and Objectives including availability targets, latency percentiles, error budgets, and automated SLO compliance reporting.
Building effective smoke test suites for deployment verification including critical path coverage, health endpoints, and rapid feedback testing.
Testing implementations against formal specifications including RFC compliance, protocol adherence, and standards conformance verification.
Testing Server-Sent Events implementations including event stream validation, reconnection behavior, event ID tracking, and EventSource client testing.
Identify stale cache issues across browser cache, CDN layers, API response caching, and application-level caches that cause users to see outdated content
Testing patterns for Supabase applications covering auth flow testing, Row Level Security policy testing, realtime subscription testing, and edge function testing
Test-Driven Development mastery with red-green-refactor cycle, outside-in TDD, test-first design, and incremental development patterns.
Automatically generate comprehensive test cases from user stories and acceptance criteria using BDD patterns, equivalence partitioning, and risk-based prioritization
Build reusable test data factories with realistic fake data generation, relationship handling, and deterministic seeding for reproducible tests.
Data-driven testing with parameterized tests, test matrices, combinatorial testing, and pairwise parameter generation techniques.
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.
Advanced Java testing with TestNG covering data providers, parallel execution, test groups, XML suite configuration, listeners, soft assertions, and dependency management.
Testing patterns for Turborepo and pnpm monorepos covering workspace dependency testing, affected package detection, parallel test execution, and shared test utilities
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.
Testing and monitoring Core Web Vitals (LCP, FID, CLS, INP, TTFB) to ensure web performance meets Google search ranking thresholds.
Cross-site scripting vulnerability testing covering reflected, stored, and DOM-based XSS with sanitization validation and CSP bypass detection.
Testing WebAssembly modules including compilation verification, memory management, interop testing, and performance benchmarking of WASM components.
Automated web application security scanning using OWASP ZAP for finding XSS, SQL injection, CSRF, and other OWASP Top 10 vulnerabilities.
Comprehensive testing patterns for Zod schemas covering validation testing, transform testing, error message verification, and integration with API endpoints and forms
Cross-platform desktop and application screenshot capture for visual testing, UI verification, and automated visual comparison across macOS, Linux, and Windows.
Modern JavaScript testing strategies with Jest, Mocha, and testing best practices covering unit testing, integration testing, mocking, async patterns, and DOM testing.
Quantify and prioritize test technical debt by analyzing coverage gaps, flaky test ratios, outdated assertions, and missing test categories across codebases.
Writing and testing YARA rules for malware detection, threat hunting, and file classification with rule validation and false-positive rate testing.
.NET testing with xUnit, NUnit, MSTest, FluentAssertions, Moq, integration testing with WebApplicationFactory, and Entity Framework testing.
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.
API testing skill using Postman and Newman, covering collections, environments, pre-request scripts, test scripts, and CI/CD integration with Newman.
Mobile web testing skill using Playwright device emulation covering responsive testing, touch interactions, viewport management, network throttling, geolocation testing, and mobile-specific UI patterns.
Generate structured exploratory testing charters with focused missions, time-boxed sessions, risk-based areas, and standardized note-taking templates for systematic exploration
Testing application configurations including environment variable validation, feature flag combinations, config file parsing, and default value verification.
Testing cookie and session management including secure flags, SameSite policy, session fixation, timeout behavior, and cross-domain cookie handling.
Automated detection and prevention of leaked secrets, API keys, passwords, and tokens in code using tools like gitleaks, trufflehog, and pre-commit hooks.
Flutter app testing with widget tests, integration tests, golden tests, Mockito, bloc testing, and Flutter Driver for end-to-end scenarios.
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.
Python testing skill using pytest, covering fixtures, parametrize, markers, conftest, plugins, mocking, and advanced testing patterns.
Validate progressive web app offline functionality including service worker caching, offline data persistence, sync-on-reconnect behavior, and graceful degradation
Payment gateway testing including Stripe, PayPal, and Square integration testing with sandbox environments, webhook verification, and error handling.
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.
Testing feature flag implementations including flag evaluation, gradual rollout verification, fallback behavior, and flag cleanup detection.
Testing API versioning strategies including URL path, header, and query parameter versioning with backward compatibility validation.
Test fixture design patterns including builders, factories, object mothers, and fixture management for maintainable test data setup.
Testing monitoring and alerting configurations including threshold validation, alert routing, escalation policies, and false-positive rate monitoring.
Testing event sourcing patterns including event store validation, projection testing, saga orchestration, and event versioning compatibility.
Test notification systems for spam behavior including duplicate alerts, missing throttling, incorrect delivery channels, and notification preference violations
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.
Java BDD testing with Serenity BDD framework using the Screenplay pattern, Cucumber integration, step libraries, comprehensive reporting, and living documentation generation.
Managing test environments including provisioning, configuration, data seeding, isolation, cleanup, and environment-as-code patterns.
Automated responsive design testing across breakpoints, viewports, and devices with visual comparison and layout verification.
Comprehensive WCAG 2.1 AA compliance testing combining automated axe-core scans with manual keyboard navigation, screen reader compatibility, and focus management verification
Configure and generate rich Allure test reports with test categorization, historical trends, environment details, and CI/CD integration for comprehensive test visibility
Automated accessibility testing with axe-core integrated into CI pipelines, including custom rule configuration, issue prioritization, and remediation guidance.
Comprehensive WCAG compliance and accessibility testing covering ARIA, keyboard navigation, screen readers, color contrast, and automated a11y validation.
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.
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.
Behavior-Driven Development with Gherkin syntax, step definitions, scenario outlines, data tables, and living documentation generation.
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.
API endpoint fuzzing for discovering unexpected behaviors, crashes, and security vulnerabilities through malformed requests, boundary values, and protocol violations.
Testing API rate limiting implementations including throttling behavior, burst handling, rate limit headers, and distributed rate limiting patterns.
Automatically generate comprehensive API test suites from OpenAPI specifications covering CRUD operations, error handling, authentication, pagination, and edge cases
Comprehensive RESTful API testing patterns covering HTTP methods, status codes, request/response validation, authentication, error handling, and contract testing.
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.
Comprehensive website auditing skill using Lighthouse, PageSpeed Insights, and web performance APIs to audit performance, accessibility, SEO, best practices, and security.
Behavior-Driven Development skill using Cucumber, covering feature files, step definitions, Gherkin best practices, data tables, scenario outlines, and hooks.
Accessibility testing skill using axe-core and Playwright for automated WCAG 2.1 compliance auditing, custom rules, and accessibility reporting.
Python BDD testing with Behave framework using Gherkin feature files, step definitions, environment hooks, and Selenium integration for behavior-driven acceptance testing.
Bug report writing skill covering clear reproduction steps, severity classification, effective communication, triage processes, and defect lifecycle management.
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.
Fuzz testing for Rust applications using cargo-fuzz and libFuzzer to discover memory safety issues, panics, and undefined behavior.
Map changelog entries and release notes to affected test cases, ensuring every user-facing change has corresponding test coverage verification.
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.
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.
Advanced security analysis using GitHub CodeQL to find zero-day vulnerabilities, injection flaws, and security anti-patterns in source code.
Evaluate interface complexity by measuring information density, decision points, visual hierarchy, and task completion paths to reduce user cognitive burden.
Contract testing for GraphQL APIs including schema breaking change detection, query compatibility testing, and federated schema validation.
Contract-first testing approach using Pact, Spring Cloud Contract, or Dredd for ensuring API consumer-provider compatibility.
Automated cross-browser testing across Chrome, Firefox, Safari, and Edge with visual comparison, feature detection, and polyfill verification.
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 dark mode rendering issues including contrast failures, missing theme tokens, image inversions, and transition glitches across components.
Testing database migration scripts for correctness, rollback safety, data integrity, and zero-downtime migration patterns.
Advanced debugging patterns for test failures covering root cause analysis, flakiness investigation, performance debugging, and systematic troubleshooting methodologies.
Frontend performance testing covering bundle size analysis, render performance, animation frame rate, React re-render detection, and lazy loading verification.
End-to-end testing for React Native apps using Detox with gray-box testing, synchronization, device simulation, and CI integration.
Testing Docker containers and images including Dockerfile linting, container structure tests, security scanning, and multi-stage build validation.
Audit empty states across web applications ensuring proper messaging, helpful CTAs, illustration rendering, and graceful handling when data is unavailable
Testing in ephemeral preview environments for pull requests including environment provisioning, data seeding, and automated teardown.
Audit error messages across an application for clarity, actionability, consistency, and user-friendliness by cataloging and grading every error surface.
Testing error handling paths including exception propagation, error boundaries, retry logic, circuit breakers, and graceful degradation.
Generating realistic test data with Faker libraries for names, addresses, emails, dates, and domain-specific data with reproducible seed control.
Flask application testing with test client, fixture patterns, SQLAlchemy model testing, blueprint testing, and Flask-specific extension testing.
Comprehensive GraphQL API testing including query/mutation testing, schema validation, resolver testing, subscription testing, and N+1 query detection.
Detecting and testing infrastructure drift between desired state and actual state using automated scanning, alerting, and remediation patterns.
Load and performance testing skill using Apache JMeter, covering test plans, thread groups, assertions, listeners, timers, and distributed testing.
Performance and load testing skill using k6, covering load test scripts, thresholds, scenarios, checks, custom metrics, and results analysis.
Laravel PHP testing with PHPUnit, feature tests, browser tests with Dusk, database factories, mocking facades, and HTTP testing helpers.
Coverage-guided fuzz testing using libFuzzer for C/C++ applications to find memory corruption, buffer overflows, and crash-inducing inputs.
Automated open-source license compliance testing to detect license conflicts, copyleft violations, and license compatibility issues in dependencies.
Detect localization and internationalization defects including untranslated strings, text expansion overflow, RTL layout issues, and locale-specific formatting errors
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.
Scalable mobile testing using cloud device farms like AWS Device Farm, BrowserStack, and Firebase Test Lab for cross-device compatibility.
MongoDB testing with in-memory MongoDB, aggregation pipeline testing, schema validation, indexing verification, and replica set testing.
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.
Generate and run mutation tests to measure test suite effectiveness by introducing code mutations and verifying detection rates.
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.
Network latency simulation and testing for measuring application behavior under various network conditions including high latency, packet loss, and bandwidth constraints.
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.
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.
Generate optimized test combinations using pairwise (all-pairs) testing algorithms to achieve maximum coverage with minimum test cases across multiple input parameters
API testing skill using Playwright's built-in APIRequestContext for RESTful service validation, authentication flows, and API contract verification.
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.
Property-based testing using hypothesis, fast-check, and QuickCheck to generate random test inputs and verify program invariants automatically.
Comprehensive Python testing best practices with pytest, covering unit testing, integration testing, mocking, fixtures, property-based testing, and test architecture.
Testing message queue implementations including RabbitMQ, SQS, and Kafka with delivery guarantees, ordering, dead letter queues, and consumer testing.
Testing patterns for Remix applications covering loader testing, action testing, route testing, form submission testing, and nested route integration testing.
API testing skill using REST Assured for Java, covering request specifications, response validation, authentication, JSON schema validation, and serialization.
Risk-based testing approach for prioritizing test efforts based on business impact, change frequency, complexity, and historical defect patterns.
C# .NET BDD testing with SpecFlow using Gherkin feature files, step bindings, hooks, dependency injection, Selenium integration, and living documentation with SpecFlow+ LivingDoc.
SSL/TLS configuration testing including certificate validation, cipher suite analysis, protocol version checks, and HSTS verification.
Testing UI components through Storybook stories with play functions, interaction testing, accessibility checks, and visual regression via Chromatic.
Stress testing methodologies for finding breaking points, resource exhaustion thresholds, and degradation patterns under extreme load conditions.
Swift testing with XCTest, Swift Testing framework, async/await testing, SwiftUI preview testing, and performance measurement.
Svelte component testing with @testing-library/svelte, vitest, component rendering, event simulation, store testing, and SvelteKit testing.
Designing scalable test architectures including test pyramid, diamond, trophy, and honeycomb patterns with framework-agnostic implementation.
Optimizing test coverage beyond line coverage including branch coverage, mutation score, path coverage, and identifying meaningful coverage gaps.
Test data generation and management skill covering Faker.js, factory patterns, builders, database seeding, and test data strategies for reliable test suites.
Building hermetic tests that are fully isolated from external dependencies using fakes, containers, and deterministic time/random sources.
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.
Testing patterns for Vercel Edge Functions, middleware, and serverless functions covering local testing, edge runtime simulation, and deployment verification.
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.
Automated WCAG 2.2 AA/AAA compliance testing with axe-core, Pa11y, and manual testing patterns for keyboard navigation, screen readers, and color contrast.
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.
WebSocket testing including connection lifecycle, reconnection logic, message ordering, backpressure handling, and binary frame testing.
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.
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.
Unit testing skill using Jest for TypeScript and JavaScript, covering mocking, spies, snapshots, coverage, async testing, and custom matchers.
American Fuzzy Lop Plus Plus mutation-based fuzz testing for finding crashes, hangs, and security vulnerabilities in binary programs.
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.
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.
Setting up and optimizing test pipelines in GitHub Actions with caching, parallel execution, matrix builds, and test result reporting.
Django application testing with TestCase, fixtures, factory_boy, model testing, view testing, middleware testing, and Django REST framework testing.
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.
Anonymizing production data for testing while maintaining referential integrity, data distributions, and edge case representation.
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 SOC 2 compliance controls including security monitoring, change management, access reviews, and incident response procedures.
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.
Web application security testing using BurpSuite for proxy-based interception, scanning, and manual penetration testing of web applications.
Analyze pull request code changes to determine which tests are affected, recommend test execution order, and identify missing test coverage for modified code paths
Classic xUnit-style Ruby testing with Test::Unit covering assertions, fixtures, test case organization, mocking patterns, and lifecycle hooks for reliable Ruby application testing.
Testing logging implementations including log level verification, structured logging validation, log rotation testing, and log aggregation pipeline testing.
Safe testing-in-production strategies including feature flags, shadow traffic, canary releases, dark launches, and observability-driven development.
Integration testing strategies including database integration, external service integration, message queue testing, and test container patterns.
IoT device testing including firmware validation, protocol testing (MQTT, CoAP), power consumption testing, and over-the-air update verification.
Testing GDPR compliance requirements including data deletion, consent management, data portability, right to erasure, and privacy policy enforcement.
Email delivery testing including content verification, rendering across clients, spam score checking, link validation, and transactional email workflow testing.
Comprehensive JWT token security testing including signature verification, expiration checks, algorithm confusion attacks, and claim validation.
Integrating screenshot-based visual testing into CI pipelines with baseline management, review workflows, and cross-platform rendering comparison.
Automated scanning of project dependencies for known vulnerabilities using tools like npm audit, Snyk, and Dependabot patterns.
Kubernetes deployment testing including manifest validation, Helm chart testing, pod health checks, network policy testing, and rollback verification.
Redis testing including cache behavior verification, pub/sub testing, transaction testing, cluster failover testing, and data expiration validation.
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.
Intelligent regression test selection using code change analysis, dependency graphs, and risk assessment to minimize test execution time.
Writing custom static analysis rules for ESLint, Semgrep, and SonarQube to enforce project-specific code quality and security standards.
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.
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.
Automated API testing using Postman collections with Newman CLI for CI/CD integration, environment management, and test reporting.
Analyzing code changes to determine which tests are impacted, enabling selective test execution and faster CI feedback loops.
OpenAPI/Swagger specification validation and testing to ensure API implementations match their documented contracts with automated drift detection.
Comprehensive Python unittest skill covering TestCase patterns, assertion methods, mocking with unittest.mock, subtests, fixtures, and test organization for robust Python application testing.
Automated compliance testing using Open Policy Agent, Chef InSpec, and custom policy engines for security baseline validation.
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.
Testing data pipelines including ETL validation, data quality checks, pipeline orchestration testing, and data lineage verification.
End-to-end type-safe API testing with tRPC covering router testing, middleware testing, subscription testing, and client-server integration testing patterns
Testing multi-tenant application isolation including data segregation, tenant-specific configuration, cross-tenant access prevention, and performance isolation.
Component testing with Cypress including mount API, React/Vue/Angular component testing, stub patterns, and visual snapshot testing.
Optimize CI test pipelines through intelligent test splitting, parallelization, caching strategies, and selective test execution based on code changes.
End-to-end web testing skill using Selenium WebDriver with Java, covering WebDriver setup, page objects, explicit waits, and TestNG/JUnit integration.
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.
Comprehensive authentication testing including login flows, password policies, MFA, session management, account lockout, and SSO integration.
Elasticsearch testing including index management, query validation, mapping verification, bulk operation testing, and search relevance scoring.
Testing real-time collaborative features including conflict resolution, CRDT validation, cursor presence, and concurrent editing scenarios.
Processing and analyzing Static Analysis Results Interchange Format (SARIF) files for aggregating security findings across multiple scanning tools.
CLI-first browser automation using Playwright CLI for navigation, form filling, snapshots, screenshots, data extraction, and UI-flow debugging from the terminal.
Generate consumer-driven contract tests using Pact framework to verify API provider-consumer compatibility and prevent integration breaking changes
Test touch gestures including swipe, pinch-to-zoom, long press, and drag-and-drop on mobile viewports and touch-enabled devices.
Security testing skill based on OWASP Top 10, covering ZAP scanning, security headers, input validation, authentication, and authorization testing.
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.
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.
Testing API schema evolution patterns including additive changes, field deprecation, type widening, and backward-compatible migration strategies.
Repository-grounded threat modeling that enumerates trust boundaries, assets, attacker capabilities, abuse paths, and mitigations to produce actionable AppSec-grade threat models.
Comprehensive file upload testing including format validation, size limits, malware scanning, storage verification, and concurrent upload handling.
Isolating and testing individual UI components with dependency mocking, state injection, and visual snapshot verification.
Testing image processing pipelines including format conversion, resize quality, metadata handling, watermark verification, and thumbnail generation.
Testing HIPAA compliance for healthcare applications including PHI handling, audit logging, access controls, and data encryption verification.
Chaos testing for Kubernetes workloads using Chaos Mesh, Litmus, and custom fault injection for pod, network, and disk failures.
Static application security testing using Semgrep for finding vulnerabilities, code smells, and enforcing security policies across codebases.
Network-level testing with Playwright including request interception, response mocking, network throttling, and HAR recording/replay.
Infrastructure-as-Code testing with Terratest, terraform validate, plan verification, and drift detection for Terraform configurations.
Automated detection of breaking API changes including response format changes, removed endpoints, type changes, and deprecation enforcement.
Consumer-driven contract testing for microservices using Pact, ensuring API compatibility and preventing integration breakages across service boundaries.
Comprehensive end-to-end testing methodologies and best practices covering architecture, test design, data management, flakiness prevention, and cross-browser strategies.
Golden file testing pattern for comparing output against approved baselines with update workflows, diff tools, and version control integration.
Test WebSocket connections for reliability including reconnection logic, message ordering, heartbeat mechanisms, and connection state management under adverse conditions
Testing retry mechanisms, circuit breakers, bulkheads, and timeout patterns for building resilient distributed systems.
Verify loading indicators, skeleton screens, and progress bars appear correctly during async operations and disappear on completion or error.
Advanced mutation testing using Stryker, PIT, and mutmut to measure test suite quality by introducing controlled mutations and tracking kill rates.
Comprehensive authentication and authorization bypass testing including session hijacking, privilege escalation, JWT manipulation, and access control verification
Systematically detect, capture, and categorize browser console errors, warnings, and unhandled exceptions during automated test execution
Visual regression testing skill using Playwright, covering screenshot comparison, visual diff thresholds, responsive testing, baseline management, and CI integration.
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.
Detecting and diagnosing flaky tests using statistical analysis, execution recording, environmental factor isolation, and quarantine strategies.
Testing scheduled tasks and cron jobs including execution timing, idempotency, failure recovery, overlap prevention, and timezone handling.
Enforcing performance budgets in CI/CD including bundle size limits, load time thresholds, Lighthouse score gates, and resource count limits.
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.
i18n testing covering locale switching, date/number formatting, RTL layout, plural forms, ICU messages, and translation completeness verification.
Testing patterns for Clerk authentication including sign-in flow testing, protected route testing, webhook verification, middleware testing, and organization-based access control
Rails application testing with RSpec, FactoryBot, Capybara, system tests, request specs, model specs, and Rails-specific testing conventions.
Testing browser extensions including content script injection, background worker testing, popup UI testing, storage API testing, and cross-browser compatibility.
Generate and maintain visual regression screenshot baselines with intelligent diffing, responsive breakpoint coverage, and dynamic content masking strategies
BDD-style JavaScript testing with Jasmine covering spies, async patterns, custom matchers, clock manipulation, and comprehensive test organization for frontend and Node.js applications.
Testing voice-activated applications including speech recognition accuracy, intent detection, dialog flow testing, and multi-language support.
Automated web performance auditing using Google Lighthouse for Core Web Vitals, accessibility, SEO, and best practices scoring with CI 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.
Identify and log user experience friction points including excessive clicks, confusing navigation, slow interactions, and workflow bottlenecks through automated heuristic analysis
Systematically test responsive layouts across breakpoints to find overflow, overlap, and alignment bugs using viewport simulation and visual comparison.
Generate realistic performance test scenarios with load profiles, ramp-up patterns, think times, and acceptance criteria derived from production traffic analysis
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.
Generate comprehensive test cases from state machine models covering all states, transitions, guard conditions, and invalid transition attempts for workflow-heavy features
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.
Next.js application testing covering Server Components, App Router, API routes, middleware, dynamic routes, and SSR/SSG testing patterns.
Production-grade Java unit and integration testing with JUnit 5 covering assertions, parameterized tests, lifecycle hooks, Mockito mocking, nested tests, and extensions.
Search feature testing including relevance scoring, autocomplete, typo tolerance, faceted search, pagination, and search analytics verification.
Testing machine learning models including accuracy validation, bias detection, drift monitoring, A/B testing, and model regression testing.
End-to-end testing skill using Cypress for web applications, covering custom commands, network intercepts, fixtures, cy.session, and component testing patterns.
Generate tests for database migration safety covering schema changes, data integrity preservation, rollback verification, and zero-downtime migration validation
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.
Synthetic monitoring test creation for uptime checking, user journey simulation, API health verification, and multi-region availability testing.
Comprehensive PHP testing with PHPUnit covering assertions, data providers, mocking, test doubles, database testing, and HTTP testing for reliable PHP application development.
Detect and diagnose race conditions in web applications through concurrent interaction testing, state mutation analysis, and timing-sensitive scenario reproduction.
Systematic memory profiling and leak detection in applications using heap snapshots, allocation tracking, and garbage collection analysis.
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.
Smart contract testing with Hardhat, Foundry, and Brownie including unit tests, gas optimization, reentrancy checks, and fork testing.
Canary deployment validation testing including traffic splitting, metric comparison, automatic rollback triggers, and health score calculation.
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.
Testing Cross-Origin Resource Sharing configurations for misconfigurations, overly permissive policies, and credential handling vulnerabilities.
Automated detection and reporting of broken links, missing resources, and orphaned pages across web applications using crawl-based and DOM-based strategies
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.
Testing desktop applications built with Electron, Tauri, or native frameworks including window management, IPC, tray icons, and auto-update testing.
Testing edge computing deployments including latency verification, edge function testing, CDN worker testing, and geo-distributed test execution.
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.
Debug and fix failing GitHub PR checks by inspecting GitHub Actions logs, summarizing failure context, drafting fix plans, and implementing fixes after approval.
Go testing with testing package, table-driven tests, subtests, benchmarks, test fixtures, httptest, and testify assertions.
gRPC service testing including protobuf validation, streaming tests, error handling, deadline testing, and load testing for gRPC endpoints.
Testing load balancer configurations including health check validation, routing algorithms, session affinity, failover behavior, and SSL termination.
Accessibility testing for mobile apps including VoiceOver/TalkBack testing, touch target sizes, dynamic type support, and motor accessibility.
API mocking with Mock Service Worker for browser and Node.js environments including request interception, response simulation, and network error testing.
Testing PDF generation including layout verification, content accuracy, font embedding, accessibility (PDF/UA), and cross-platform rendering consistency.
Detect and eliminate N+1 query problems in database-backed applications through query counting, execution plan analysis, and ORM configuration auditing
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.
Testing PCI-DSS compliance for payment processing including encryption validation, access control testing, and secure data storage verification.
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.
Visual regression testing with Playwright including screenshot comparison, pixel-diff thresholds, dynamic content masking, and cross-browser visual validation.
Build lightweight production smoke test suites that verify critical user paths, API health, and third-party integrations after every deployment.
Component testing using React Testing Library with user-centric queries, accessibility-focused selectors, and integration testing patterns.
Convert bug reports and incident post-mortems into automated regression tests that prevent recurrence of previously discovered defects.
Production-grade REST API automation framework with REST Assured, POJO serialization using GSON, PayloadManager pattern, E2E integration workflows with TestNG ITestContext, and Allure reporting.
Comprehensive Ruby testing with RSpec including describe/context/it blocks, matchers, let/before hooks, mocking with doubles, shared examples, and Rails integration.
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.
Perform language and framework specific security best-practice reviews, vulnerability detection, and secure-by-default coding guidance for Python, JavaScript/TypeScript, and Go applications.
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.
Testing serverless functions including Lambda, Cloud Functions, and Edge Functions with local emulation, cold start testing, and timeout handling.
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.
Snapshot testing strategies for UI components, API responses, and data structures with update workflows, review patterns, and anti-pattern avoidance.
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.
Testing patterns for TanStack Query (React Query) covering query hook testing, mutation testing, cache behavior testing, and optimistic update verification.
Docker-based integration testing with Testcontainers for databases, message queues, cloud services, and custom containers with lifecycle management.
Generating human-readable test documentation from test code including test catalogs, coverage reports, and living documentation websites.
Test isolation techniques including database cleanup, transaction rollback, parallel test execution, and shared resource management.
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.
Test plan generation skill covering requirements analysis, test strategy, coverage matrices, risk-based testing, and test estimation techniques.
Find timezone-related bugs in date handling, scheduling, and display logic by testing across multiple timezones and edge cases like DST transitions.
Enforces rigorous verification evidence before any claims of task completion, preventing false positives, untested deployments, and premature celebration with a structured gate function.
Modern JavaScript and TypeScript testing with Vitest, covering unit testing, integration testing, mocking, snapshots, browser mode, and Vite integration.
Detect, quarantine, and systematically fix flaky tests with automated retry analysis, root cause categorization, and CI pipeline integration for test reliability
Testing concurrent code including race condition detection, deadlock prevention, thread safety verification, and parallel execution correctness.
DNS configuration testing including record validation, DNSSEC verification, resolution timing, failover testing, and DNS-based service discovery.
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.
Identify untested code paths, uncovered branches, and missing test scenarios using coverage analysis, risk mapping, and change-based coverage tracking
Validating A/B test implementations including traffic splitting accuracy, statistical significance calculation, metric tracking, and experiment cleanup.
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.
Advanced Allure test reporting with custom categories, environment info, test history trends, flaky test detection, and CI/CD dashboard integration.
Validate API responses against OpenAPI/Swagger specifications, JSON Schema definitions, and consumer-driven contracts to prevent breaking changes
Testing augmented and virtual reality applications including spatial tracking, gesture recognition, performance on headsets, and motion sickness testing.
Modern cloud-scale load testing using Artillery.io for HTTP, WebSocket, Socket.io, and custom protocol testing with YAML-based test definitions.
Role-based and attribute-based access control testing including permission matrices, privilege escalation prevention, and resource-level authorization.
Testing library backward compatibility including public API surface verification, semver compliance, TypeScript type compatibility, and migration path validation.
Generate boundary value test cases for numeric ranges, string lengths, date ranges, collection sizes, and domain-specific constraints using systematic analysis techniques
PHP BDD testing with Behat framework using Gherkin feature files, Mink browser extension, context classes, and Symfony integration for behavior-driven acceptance testing.
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.
Testing CDN configurations, cache hit ratios, cache invalidation, TTL policies, and edge caching behavior for optimal content delivery.
Advanced chaos engineering patterns using Chaos Monkey, Litmus, and Gremlin for testing distributed system resilience under failure conditions.
Consumer-driven contract testing skill using Pact, covering consumer tests, provider verification, Pact Broker integration, and CI/CD workflows.
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.
Content Security Policy testing and validation to prevent XSS attacks, data injection, and clickjacking through proper CSP header configuration.
Systematic dark mode testing covering color contrast, theme switching, persistence, media query respect, component-level theming, and image adaptation.
Verifying data integrity constraints, referential integrity, data type validation, and consistency checks across database operations.
Database performance testing including query optimization, index analysis, connection pooling, slow query detection, and N+1 query prevention.
Testing distributed tracing implementations including context propagation, span correlation, baggage handling, and trace sampling verification.