qa

Automates web app QA testing with tiered plans and atomic-fix verification.

1|Updated Apr 8, 2026
One-click install
npx skills add https://github.com/martin-hsu-test/gstack-gemini-slim --skill qa-martin-hsu-test
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: qa
Source: https://github.com/martin-hsu-test/gstack-gemini-slim/tree/main/.gemini/skills/gstack-qa
Command: npx skills add https://github.com/martin-hsu-test/gstack-gemini-slim --skill qa-martin-hsu-test

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Systematically QA test a web application and fix bugs found. Runs QA testing, then iteratively fixes bugs in source code, committing each fix atomically and re-verifying. Use when asked to "qa", "QA", "test this site", "find bugs", "test and fix", or "fix what's broken". Proactively suggest when the user says a feature is ready for testing or asks "does this work?". Three tiers: Quick (critical/high only), Standard (+ medium), Exhaustive (+ cosmetic). Produces before/after health scores, fix evidence, and a ship-readiness summary. For report-only mode, use /qa-only. (gstack) Voice triggers (speech-to-text aliases): "quality check", "test the app", "run QA".

Core Features & Use Cases

  • Brings structured QA workflow to web apps, including automated tests and manual checks.
  • Iteratively fixes bugs in source code with atomic commits and re-verification.
  • Supports tiered testing (Quick, Standard, Exhaustive) and generates health/fix evidence reports for ship readiness.

Quick Start

Run a QA pass on the current project and fix any bugs you find, then verify changes with atomic commits.

Frequently Asked Questions about qa

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run automated QA testing on a web application and fix the bugs found?

Automated QA testing for web applications is performed end-to-end with automated verification and guided bug fixes. The workflow iteratively identifies bugs in source code, patches issues across a feature, and commits each fix atomically with re-verification.

What is the best way to structure test execution and verify bug fixes in source code?

Structured test execution and bug fix verification are achieved using tiered testing plans and atomic commits. The process patches source code issues, commits each fix individually, and re-verifies changes end-to-end to quantify readiness and produce health scores.

Does this QA testing approach support different testing depths like quick checks or exhaustive reviews?

Yes, tiered testing plans support different depths: Quick for critical and high-priority bugs, Standard adds medium severity, and Exhaustive includes cosmetic issues. Each tier produces before and after health scores, fix evidence, and a ship-readiness summary.

Can I generate a QA report for my web app without automatically modifying the source code?

Yes, a report-only mode is available to run QA testing and identify bugs without applying fixes. This mode generates health scores and readiness summaries while leaving the source code untouched for manual review.

How do atomic commits work when fixing bugs across a web application feature?

Atomic commits for bug fixes work by patching each identified issue individually and committing the fix immediately. After each atomic commit, the web application is re-verified end-to-end to ensure the fix is successful and does not introduce regressions.

When should I use an exhaustive testing plan over a standard one for web application verification?

An exhaustive testing plan should be used over standard when you need to verify cosmetic issues alongside critical, high, and medium bugs. This ensures maximum ship readiness by quantifying health scores across all severity levels before deployment.