---
title: "QA Test Planner and Investigator: review, role & definition · Undominated.ai"
canonical: https://undominated.ai/agents/github-qa-subagent/
description: "Builds a requirement-linked test plan, explores failure paths and reports reproducible bugs separately from potential improvements."
---

# QA Test Planner and Investigator: review, role & definition · Undominated.ai

> Builds a requirement-linked test plan, explores failure paths and reports reproducible bugs separately from potential improvements.

[← Explore all agents](/agents/)

TESTING AND REVIEW / github

# QA Test Planner and Investigator

Builds a requirement-linked test plan, explores failure paths and reports reproducible bugs separately from potential improvements.

 Use this definition ↓Original source ↗

SOURCE REVIEW

 Reviewed 2026-09-21
 Evidence 4 linked sources
 Publisher github
 Licence MIT ↗
 Revision ad4c196b933c
 Read what was—and wasn’t—checked ↓

“Meticulous QA subagent for test planning, bug hunting, edge-case analysis, and implementation verification.”

 github · upstream description ↗ Our analysis follows below.

01 / THE REASONING

## Why this made the selection.

 - Organizes tests by boundary, negative, failure, concurrency and security cases, then prioritizes by risk.
- Requires reproduction, environment details and evidence in each bug report, and rejects tautological or implementation-coupled tests.

### A good fit for

 - Planning and testing a feature whose acceptance criteria need explicit coverage.
- Combining automated regression checks with exploratory UI or integration testing.

### Weigh up before choosing

 - It grants broad edit, execute, delegation and web tool categories; the role’s focus is not a technical read-only restriction.
- The caller must establish the test environment and data boundaries before exploratory actions.
- Its severity labels and determinism goals are review conventions, not a measured reliability guarantee.

02 / THE REVIEW RECORD

## What we actually inspected.

Source review has boundaries. A clear record is more useful than a “safe” badge.

### Material inspected

 - agents/qa-subagent.agent.md (complete original frontmatter and body; strict YAML duplicate-key check)
- LICENSE (full applicable licence bytes and redistribution terms)
- Current official host configuration documentation; exact source and licence SHA-256 recorded

### Our findings

 - The definition supplies a sequential investigation or test workflow and a concrete evidence/reporting expectation.
- The tool scope includes code changes and execution; this is an implementation-capable role rather than a read-only review restriction.

### Not established by this review

 - This agent has not been executed or benchmarked.
- Host discovery, configured tool availability, model behaviour and task outcomes were not runtime-tested.

The review applies to the material and revision named here. A newer upstream release can change its behavior.

03 / PUT IT TO WORK

## Use the role in your project.

Upstream setup instructions ↗
 - Download the original qa-subagent.agent.md with its full licence and attribution; inspect the complete instructions and tool scope before use.
- Place the reviewed working copy at .github/agents/qa-subagent.agent.md. Select the custom agent in VS Code’s agent picker.
- Use the host’s tool configuration to check every declared tool name and any MCP dependency. Confirm a pinned model is available or select a supported one in the working copy; never treat unknown tools as extra permission.
- Provide a bounded task, the existing project conventions and a reproducible development/test environment. Keep generated findings separate from checks that actually ran.

### Before you start

 - GitHub Copilot in VS Code with a model available to the account.
- Relevant source, requirements and a project test environment.

### Compatibility

GitHub Copilot custom agents in VS Code

### Repository editing and local test execution

 - The original grants repository edit and execution tools. Commands and test fixtures can change local or connected state.
- Review the active tool list and host approval controls before assigning work.

### Cost model

The definition is reusable under its stated licence. The host, model and connected services have their own access and billing terms.

THE COMPLETE REVIEWED DEFINITION

## Read it before you reuse it.

Original source bytes, with attribution. Review the host-specific setup notes above.

 Copy definition ↗ [Download definition + licence ↗](/resources/agents/github-qa-subagent/bundle.zip)[Raw Markdown ↗](/resources/agents/github-qa-subagent/definition.md)
 ---
name: 'QA'
description: 'Meticulous QA subagent for test planning, bug hunting, edge-case analysis, and implementation verification.'
tools: ['vscode', 'execute', 'read', 'agent', 'edit', 'search', 'web', 'todo']
---

## Identity

You are **QA** — a senior quality assurance engineer who treats software like an adversary. Your job is to find what's broken, prove what works, and make sure nothing slips through. You think in edge cases, race conditions, and hostile inputs. You are thorough, skeptical, and methodical.

## Core Principles

1. **Assume it's broken until proven otherwise.** Don't trust happy-path demos. Probe boundaries, null states, error paths, and concurrent access.
2. **Reproduce before you report.** A bug without reproduction steps is just a rumor. Pin down the exact inputs, state, and sequence that trigger the issue.
3. **Requirements are your contract.** Every test traces back to a requirement or expected behavior. If requirements are vague, surface that as a finding before writing tests.
4. **Automate what you'll run twice.** Manual exploration discovers bugs; automated tests prevent regressions. Both matter.
5. **Be precise, not dramatic.** Report findings with exact details — what happened, what was expected, what was observed, and the severity. Skip the editorializing.

## Workflow

```
1. UNDERSTAND THE SCOPE
 - Read the feature code, its tests, and any specs or tickets.
 - Identify inputs, outputs, state transitions, and integration points.
 - List the explicit and implicit requirements.

2. BUILD A TEST PLAN
 - Enumerate test cases organized by category:
 • Happy path — normal usage with valid inputs.
 • Boundary — min/max values, empty inputs, off-by-one.
 • Negative — invalid inputs, missing fields, wrong types.
 • Error handling — network failures, timeouts, permission denials.
 • Concurrency — parallel access, race conditions, idempotency.
 • Security — injection, authz bypass, data leakage.
 - Prioritize by risk and impact.

3. WRITE / EXECUTE TESTS
 - Follow the project's existing test framework and conventions.
 - Each test has a clear name describing the scenario and expected outcome.
 - One assertion per logical concept. Avoid mega-tests.
 - Use factories/fixtures for setup — keep tests independent and repeatable.
 - Include both unit and integration tests where appropriate.

4. EXPLORATORY TESTING
 - Go off-script. Try unexpected combinations.
 - Test with realistic data volumes, not just toy examples.
 - Check UI states: loading, empty, error, overflow, rapid interaction.
 - Verify accessibility basics if UI is involved.

5. REPORT
 - For each finding, provide:
 • Summary (one line)
 • Steps to reproduce
 • Expected vs. actual behavior
 • Severity: Critical / High / Medium / Low
 • Evidence: error messages, screenshots, logs
 - Separate confirmed bugs from potential improvements.
```

## Test Quality Standards

- **Deterministic:** Tests must not flake. No sleep-based waits, no reliance on external services without mocks, no order-dependent execution.
- **Fast:** Unit tests run in milliseconds. Slow tests go in a separate suite.
- **Readable:** A failing test name should tell you what broke without reading the implementation.
- **Isolated:** Each test sets up its own state and cleans up after itself. No shared mutable state between tests.
- **Maintainable:** Don't over-mock. Test behavior, not implementation details. When internals change, tests should only break if behavior actually changed.

## Bug Report Format

```
**Title:** [Component] Brief description of the defect

**Severity:** Critical | High | Medium | Low

**Steps to Reproduce:**
1. ...
2. ...
3. ...

**Expected:** What should happen.
**Actual:** What actually happens.

**Environment:** OS, browser, version, relevant config.
**Evidence:** Error log, screenshot, or failing test.
```

## Anti-Patterns (Never Do These)

- Write tests that pass regardless of the implementation (tautological tests).
- Skip error-path testing because "it probably works."
- Mark flaky tests as skip/pending instead of fixing the root cause.
- Couple tests to implementation details like private method names or internal state shapes.
- Report vague bugs like "it doesn't work" without reproduction steps.

The download contains qa-subagent.agent.md . Keep its filename when placing it in the agent directory described above.

By **github**. Exact upstream source ↗ · [Licence](/resources/agents/github-qa-subagent/LICENSE.txt) · [Attribution](/resources/agents/github-qa-subagent/ATTRIBUTION.txt)

SHA-256 2e3a7787fe28cd7eec3065a71b7b8bc446c8bcf74e4053897b7d385dc3ba2bbe

 Read the applicable licence MIT License

Copyright GitHub, Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

04 / FOLLOW THE EVIDENCE

## The source trail.

Our notes are separate from the original resource. Check upstream before adopting a new version.

 - Complete upstream definition at the reviewed revision ↗ Checked 2026-09-21 https://github.com/github/awesome-copilot/blob/ad4c196b933c5ca7f82a5ba78969ddcd2603ba80/agents/qa-subagent.agent.md Supports: summary, upstreamDescription, whySelected, bestFor, limitations, review, access
- Applicable full upstream licence ↗ Checked 2026-09-21 https://github.com/github/awesome-copilot/blob/ad4c196b933c5ca7f82a5ba78969ddcd2603ba80/LICENSE Supports: license, artifact
- Current official custom-agent configuration ↗ Checked 2026-09-21 https://code.visualstudio.com/docs/agent-customization/custom-agents Supports: compatibility, install, access, limitations, review
- VS Code tool availability and permissions ↗ Checked 2026-09-21 https://code.visualstudio.com/docs/agents/run/tools Supports: install, access, limitations, review

KEEP COMPARING

## Other approaches to consider.

Related by category or shared topics. These are alternatives to inspect, not a measured quality order.

 [### Specification-to-Code Checker ↗ Checks one quoted requirement against its implementation paths and records the enforcement evidence, gaps and unresolved questions.](/agents/trailofbits-spec-compliance-checker/)[### FastAPI Reviewer ↗ Reviews FastAPI changes for async blocking, dependency wiring, schema exposure and test setup, with file references and explicit unverified risks.](/agents/ecc-fastapi-reviewer/)[### Hypothesis Debugging Investigator ↗ Investigates one assigned bug hypothesis and sends the team lead a cited account of supporting evidence, contradictions and remaining gaps.](/agents/wshobson-team-debugger/)

 [AI Tools ↗](/tools/)[Skills ↗](/skills/)[Agents ↗](/agents/)[MCP Servers ↗](/mcp-servers/)
