QA

What Is This?

Overview

The QA skill provides a structured, iterative approach to testing web applications and resolving bugs found during the process. It combines automated test execution with a disciplined fix-and-verify loop, ensuring that each identified issue is addressed, committed atomically, and re-verified before moving on. This workflow eliminates the common problem of fixing one bug while inadvertently introducing another.

At its core, the skill operates across three testing tiers: Quick, Standard, and Comprehensive. The Quick tier focuses on critical and high-severity issues only, making it suitable for rapid pre-deployment checks. The Standard tier adds medium-severity issues to the scope, while the Comprehensive tier covers the full spectrum of potential problems including edge cases, accessibility concerns, and performance regressions. Each tier produces a structured report of findings before any fixes are applied.

The skill is designed to be triggered both explicitly and proactively. When a developer says a feature is ready for review or asks whether something works correctly, the QA skill recognizes these as natural entry points and initiates the appropriate testing tier automatically.

Who Should Use This

• Frontend developers who need to verify UI behavior, form validation, and user interaction flows before merging a pull request
• Full-stack engineers working on features that span client and server logic and need end-to-end verification
• QA engineers who want a repeatable, automated baseline test run before performing manual exploratory testing
• Team leads and tech leads who want consistent quality gates applied across all feature branches

Why Use It?

Problems It Solves

• Manual testing is inconsistent and time-consuming, often missing edge cases that automated systematic testing catches reliably
• Bug fixes applied without re-verification frequently introduce regressions in adjacent functionality
• Developers lack a clear, structured process for moving from "I think this works" to "this is verified and committed"
• Test results are often undocumented, making it difficult to track what was checked and what was found
• Context switching between testing and fixing disrupts flow and leads to incomplete resolution of identified issues

Core Highlights

• Three-tier testing system: Quick, Standard, and Comprehensive, selectable based on time and risk tolerance
• Atomic commits for each individual bug fix, preserving a clean and reviewable git history
• Iterative fix-and-verify loop that re-runs relevant tests after each change
• Proactive suggestion behavior when natural language signals readiness for testing
• Structured bug reports generated before any code modifications begin
• Works across common web application stacks without requiring custom configuration
• Integrates naturally into existing development workflows and version control practices

How to Use It?

Basic Usage

Trigger the QA skill by using natural language commands in your development environment:

qa
QA this
test this site
find bugs
test and fix
fix what's broken

To specify a tier explicitly:

quick qa
standard qa
comprehensive qa

Specific Scenarios

Scenario 1: Pre-merge verification. A developer completes a login feature and runs a Quick QA pass to catch critical issues before opening a pull request. The skill tests authentication flows, error states, and session handling, then commits fixes atomically.

Scenario 2: Post-refactor regression check. After refactoring a payment module, a Standard QA run verifies that existing checkout behavior remains intact, covering both happy paths and known edge cases like expired cards and network timeouts.

Real-World Examples

## Run a quick check on the current application state
qa quick

## Run comprehensive testing on a staging environment URL
comprehensive qa https://staging.example.com

## Ask the skill to find and fix all broken functionality
fix what's broken

When to Use It?

Use Cases

• Verifying a new feature before it is demonstrated to stakeholders
• Running regression checks after a dependency upgrade or library update
• Validating bug fixes submitted by external contributors before merging
• Performing a final quality check before a production deployment
• Testing a third-party integration after an API contract change
• Reviewing form validation, error handling, and edge case behavior in user-facing flows
• Establishing a documented baseline of application health at the start of a new project phase

Important Notes

Requirements

• A running instance of the web application, either locally or on a reachable staging environment
• Git initialized in the project directory with a clean or stash-able working state before QA begins
• Node.js or the relevant runtime installed if the skill needs to execute test scripts directly
• Sufficient permissions to read source files and commit changes to the active branch