QA Skill Library

Need to decide which testing skill should be used before execution.

A quality stage needs a product perspective on user value, business rules, scope, acceptance, and release risk.

Use this skill when QA quality perspective is needed for requirements, strategy, review, test cases, or reports; triggers include QA quality perspective.

A quality stage needs a UX perspective on information architecture, interaction states, consistency, responsive behavior, or accessibility.

Use this skill when a technical quality perspective is needed for requirements, strategy, code, test cases, or reports; triggers include technical quality review, architecture review, and code review.

Need a one-day QA cadence: morning plan, execution, defects, EOD wrap-up.

Need a sprint cadence: planning → setup → execution → regression → stabilize → review.

Use this skill when project delivery constraints or action tracking are needed for test strategy, test strategy review, or test report review; triggers include project delivery perspective, delivery planning, schedule and capacity..

Need a release-window cadence: T-N planning → specialties → RC → Go/No-Go → post-release watch.

Use this skill when multiple role reports for one quality stage must be combined into a traceable synthesis; triggers include multi-role quality synthesis, role report consolidation, disagreement summary..

Need help with requirements analysis in a real project context.

Need deeper requirement analysis across multiple source documents.

Need help with test strategy in a real project context.

Need a fuller strategy with milestones, gates, ownership, and tradeoffs.

Use this skill when a proposed test strategy needs evidence-based review before Human approval; triggers include test strategy review, strategy approval review..

Need help with test case writing in a real project context.

Need test cases from multiple source documents with stronger prioritization.

Need help with test case reviewer in a real project context.

Need a stricter review of existing test cases before test execution or release.

When you need Decision Table Test Design candidates from business rules, conditions, actions, exceptions, precedence, applicability, and existing test material.

When you need State Transition Test Design candidates from state models, events, guard conditions, actions, roles, error transitions, and state-persistence evidence.

When you need Boundary Value Test Design candidates from field schemas, minimum/maximum rules, inclusivity, units, time rules, resource limits, and defect history.

When you need Equivalence Partitioning Test Design candidates from input constraints, field types, business rules, role/state differences, error contracts, and existing cases.

When you need Pairwise Test Design candidates from test factors, values for each factor, combination constraints, platform/role dimensions, risk evidence, and existing combinations.

Analyze factors, values, combination constraints, interaction risk, and existing combinations.

Analyze behavior models, states or nodes, events, path constraints, model versions, and existing execution evidence.

Analyze domain invariants, input generation domains, constraints, failure examples, shrinking strategies, and existing properties.

Analyze baseline inputs, transformation rules, expected relations, output invariants, randomness, and existing evidence.

Need help with functional testing in a real project context.

Need an API test plan, API cases, or API risk analysis.

Need help with manual testing in a real project context.

Need help with mobile testing in a real project context.

Need help with accessibility testing in a real project context.

Need help with security testing in a real project context.

Need help with bug reporting in a real project context.

Need help with test reporting in a real project context.

Use this skill when a test report needs an evidence-consistency review before Human approval; triggers include test report review, quality report audit, test evidence review..

Use this skill when you need to turn requirements and user stories into verifiable, unambiguous acceptance criteria that cover failure paths.

Use this skill when you need to find ambiguities, omissions, conflicts, untestable statements, and cross-role dependency gaps in requirements.

Use this skill when you need to identify quality risks and prioritize them by likelihood, impact, detectability, and evidence.

Use this skill when you need to assess requirements and systems for controllability, observability, isolation, and reproducibility.

Before test design, technical design, or planning when requirement quality is uncertain.

Requirement wording contains undefined terms such as “timely,” “fast,” “when necessary,” or “normal.”

PRDs, stories, API contracts, prototypes, technical notes, or acceptance criteria use different names or states.

Different artifacts allow and prohibit the same behavior.

You need to check whether requirements have acceptance, design, implementation, test, and defect coverage.

Use it when scattered prose must become comparable and verifiable `BR-##` entries.

Use it for ADRs, component/data-flow designs, technical proposals, and non-functional constraints.

Use it to check whether operations, inputs/outputs, errors, permissions, and compatibility evolution are verifiable.

Use it to check model integrity, constraints, indexes, lifecycle/privacy, and data ownership.

Use it to check whether signal fields/dimensions, semantics, correlation IDs, sampling, retention, and alerts are actionable.

Use it to distinguish expected behavior, propagation, retry conditions, and human handoff across failure modes.

Use it to define explainable boundaries for an iteration, release, change, or risk review.

Use it to determine which requirements, risks, behaviors, or failure modes lack a test intent or evidence.

Use it when business criticality, change surface, past defects, or failure modes must determine test order and depth.

Use it to systematically consider value, length, null/type, time, state, capacity, concurrency, platform, and combination boundaries.

Use it to examine invalid input, unauthorized access, dependency failure, timeout, retry exhaustion, duplicate request, partial failure, and inconsistency.

Use this Skill when the work needs evidence-bounded analysis of availability objectives, failure modes, exposure windows, and evidence readiness.

Use this Skill when the work needs evidence-bounded analysis of degradation behavior, isolation boundaries, recovery capability, and residual risk.

Use this Skill when the work needs evidence-bounded analysis of fault-injection hypotheses, blast radius, stop conditions, and safety guardrails.

Use this Skill when the work needs evidence-bounded analysis of primary-secondary triggers, traffic transfer, data consistency, and recovery evidence.

Use this Skill when the work needs evidence-bounded analysis of recovery point, recovery time, recovery steps, validation evidence, and human takeover.

Use this Skill when the work needs evidence-bounded analysis of retry triggers, backoff, idempotency, retry limits, and duplicate side effects.

Use this Skill when the work needs evidence-bounded analysis of timeout budgets, cancellation propagation, downstream boundaries, user feedback, and retry interaction.

Use this Skill when the work needs evidence-bounded analysis of closed, open, and half-open states, threshold evidence, recovery probes, and fallback.

Use this Skill when the work needs evidence-bounded analysis of dependency-failure taxonomy, isolation, degradation, fallback, and dependency recovery.

Use this Skill when the work needs evidence-bounded analysis of disaster scenarios, recovery priority, backup evidence, runbooks, and restore validation.

Use this Skill when the work needs evidence-bounded analysis of identity credentials, authentication flows, failure paths, and lifecycle.

Use this Skill when the work needs evidence-bounded analysis of subject-resource-action relations, permission boundaries, denial paths, and delegation.

Use this Skill when the work needs evidence-bounded analysis of session creation, fixation, expiry, revocation, concurrency, and cross-device boundaries.

Use this Skill when the work needs evidence-bounded analysis of API attack surface, input boundaries, identity and authorization, error leakage, and security contracts.

Use this Skill when the work needs evidence-bounded analysis of security objectives, testability, trace links, acceptance conditions, and evidence gaps.

Use this Skill when the work needs evidence-bounded analysis of assets, trust boundaries, attack surface, threat scenarios, mitigations, and assumptions.

Use this Skill when the work needs evidence-bounded analysis of secret locations, flows, log exposure, configuration boundaries, and rotation evidence.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for entry criteria, evidence requirements, owners, and exception paths for a delivery or release gate.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for quality metric definitions, calculation rules, data sources, freshness, and anti-gaming boundaries.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for quality dashboard audiences, decision questions, panels, drill-downs, freshness, and alert boundaries.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for quality-debt items, origins, impact, age, priority, ownership, and paydown tradeoffs.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for quality-practice maturity dimensions, rubric anchors, evidence sufficiency, and improvement gaps.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for the relationship between test signals and defects or risks, missed-detection limits, false signals, and validation plans.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for automation candidates, build/run/maintenance costs, benefit assumptions, time horizon, and sensitivity.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for queues, dependencies, capacity, handoffs, and evidence for testing constraints.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for tradeoffs among regression selection, ordering, parallelism, caching, and risk preservation.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for pipeline stages, feedback latency, resources, flakiness, caching/sharding, and rollback boundaries.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for slow tests, profiling evidence, setup/teardown, parallelism, isolation, and baselines.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for change frequency, repair effort, flaky cost, ownership, maintainability, and confidence.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for quality and delivery metrics, denominators, attribution limits, gaming risk, and the Human-use boundary.

Need to review a PR / diff / commit and catch logic, security, financial-loss, or maintainability risks before merge.

Use this skill when you need to identify affected capabilities, regression scope, and release risk from code, configuration, data, and dependency changes.

Use this skill when you need to derive the smallest sufficient test scope from a pull request's diff, dependencies, and historical risk.

Use this skill when you need to verify provider-consumer API contracts across schemas, semantics, compatibility, and evolution.

Need help with automation testing in a real project context.

When you need API schema validation candidates from OpenAPI, JSON Schema, GraphQL schemas, endpoint inventories, request-response samples, versions, and validation reports.

When you need API negative testing candidates from API contracts, authentication and authorization constraints, parameter rules, error codes, rate-limit rules, defects, and raw responses.

When you need API idempotency testing candidates from API contracts, idempotency-key rules, retry policies, timeout evidence, business side effects, message records, and database observations.

When you need pagination continuity and consistency candidates from pagination parameter contracts, sort fields, cursor or offset rules, dataset snapshots, concurrent changes, and response samples.

When you need API rate limit testing candidates from rate-limit policies, quota windows, tenant or user dimensions, 429 responses, Retry-After, monitoring, and load-test boundaries.

When you need version compatibility candidates from version contracts, change logs, old-client samples, compatibility policies, deprecation timelines, gateway routes, and response comparisons.

When you need error-contract consistency candidates from error-response schemas, HTTP status conventions, error-code catalogs, authorization rules, logs, and redaction requirements.

Use it to determine which entities, fields, states, roles, and relationships a scenario needs.

Use this skill when you need to design reusable test datasets covering business rules, boundaries, combinations, and privacy constraints.

Need API outputs that should land in Bruno structure or Bruno workflow.

Need outputs that should land in a Postman API testing workflow.

Need API outputs that should land in pytest-based automation.

Need API outputs that should land in REST Assured based automation.

Need API outputs that should land in Supertest based automation.

Need outputs that should land in a Selenium UI testing workflow.

Need outputs that should land in a Playwright UI testing workflow.

Need outputs that should land in a TestCafe UI testing workflow.

Need outputs that should land in a Cypress UI testing workflow.

Need outputs that should land in a Puppeteer UI testing workflow.

Need outputs that should land in a WebdriverIO UI testing workflow.

When you need UI test strategy candidates from user journeys, page and component inventories, state flows, designs, platform matrices, accessibility requirements, and defect evidence.

When you need UI test selector review candidates from DOM or component code, test code, accessible names, data-testid conventions, locator history, and failure screenshots.

When you need UI test wait strategy review candidates from test code, network and rendering events, observable states, timeout configuration, failure traces, retries, and fixed sleeps.

When you need visual regression testing candidates from page inventories, baseline screenshots, viewports and browsers, fonts, test data, diff thresholds, design changes, and prior diffs.

When you need cross-browser testing candidates from browser and device support matrices, user distribution, engine versions, rendering differences, known defects, CI capacity, and environment limits.

Use this skill when you need to identify intermittent test failure patterns, evidence, candidate causes, and stabilization actions.

Use this skill when you need to define regression boundaries and depth from change, dependencies, risk, and available capacity.

Use this skill when you need to select the smallest sufficient subset of existing tests that covers change risk and explain tradeoffs.

Need help with ai assisted testing in a real project context.

Reviewing, changing, or accepting AI-generated unit, functional, API, or E2E tests.

When you need test code review candidates from test code, fixtures, assertions, dependency injection, run history, failure logs, change diffs, and CI configuration.

When you need mutation testing analysis candidates from mutation reports, operator configuration, killed and surviving results, equivalent-mutant notes, test mappings, coverage, and run logs.

When you need mock quality review candidates from API or service contracts, mock implementations, stub data, interaction assertions, integration tests, drift records, and real responses.

When you need test suite health analysis candidates from CI run history, duration distributions, reruns, quarantine lists, duplicate tests, maintenance records, coverage, and defect evidence.

Need help with performance testing in a real project context.

Need performance outputs that should land in k6 structure.

Need performance outputs that should land in Gatling structure.

Need outputs that should land in a JMeter performance testing workflow.

Use this skill when you need to translate production traffic and business behavior into a reproducible performance-test workload model.

Use this skill when you need to interpret performance-test results for target attainment, knees, error patterns, and capacity risk.

Use this skill when you need to combine load, metrics, and traces to locate resources or code paths limiting throughput or latency.

Use this skill when you need to compare versions or time windows, quantify performance changes, and locate regression risk associated with changes.

Use this skill when you need to estimate capacity needs and scaling triggers from workload, utilization, and growth assumptions.

Use this skill when you need to identify systemic root causes and contributing factors using evidence, hypotheses, and verification experiments.

Use this skill when you need to reconstruct events from structured and unstructured logs, detect anomalies, and form testable causal hypotheses.

Use this skill when you need to verify production releases, configuration changes, or fixes under controlled risk without causing harmful side effects.

Use this skill when you need to build an incident timeline, control impact, form evidence-backed hypotheses, and drive recovery and learning.

Use this skill when you need to use traces, spans, and topology to locate cross-service latency, error propagation, and dependency failures.

Use this skill when you need to analyze metric anomaly magnitude, duration, correlated signals, and business impact.

Use this skill when you need to verify product AI features for quality, safety, fairness, fallback behavior, and user experience.

Use this skill when you need to design repeatable evaluations for LLM systems across capability, safety, reliability, and business value.

Use this skill when you need to test LLM applications for task quality, robustness, safety, factuality, and version regressions.

Use this skill when you need to verify prompts for correctness, consistency, and control across representative, boundary, adversarial, and version-change cases.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for grounding, relevance, completeness, citation support, abstention, and answer-level evidence in RAG outputs.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for query variants, chunking, filters, recall/precision proxies, ranking, freshness, and retrieval evidence.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for claim-to-source relations, unsupported assertions, abstention, uncertainty, and evidence review.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for repeat inputs, version/model/prompt factors, invariants, variance evidence, and comparison boundaries.

Use this skill when you need to systematically verify agent planning, memory, tool use, recovery, safety boundaries, and task completion quality.

Use this skill when you need to verify an AI agent's tool selection, argument contracts, authorization, failure recovery, and side-effect boundaries.

Use this skill when you need to verify LLM applications against direct and indirect prompt injection, data exfiltration, and unauthorized tool use.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for loop state, plan/action/observation cycles, stop conditions, budgets, repetition, and trace evidence.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for memory write/read/update/delete, retention, contamination, isolation, provenance, and forgetting behavior.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for Agent identity, tool/resource scope, approval, denial, escalation, and side-effect boundaries.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for failure classification, retry/fallback/escalation, state consistency, user notice, and recovery evidence.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for checkpoints, heartbeats, resume, cancellation, duplicate submission, timeouts, and resource lifecycle.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for delegation, coordination, shared state, conflicts, ownership, termination, and traceability.

Use this skill when you need evidence-bounded analysis, design, or validation preparation for safety policy, abuse categories, refusal/redirect behavior, privacy, escalation, and Human risk decisions.