qa-sweep · zaxbyhub, claude — Claude Code skill: QA checks and setup
qa-sweep coordinates parallel sub-agent work and independent checks of code changes. Use it for feature work, bug fixes, debugging, and reviews.
MIT ★ 539 updated 2026-10-29
npx skills add ZaxbyHub/opencode-swarm --skill qa-sweep -a claude-codeWhat qa-sweep does
For work that changes files, the skill calls for parallel implementation where tasks can be split, targeted acceptance tests before a broader test suite, and a fresh agent to challenge the result. A second independent agent checks whether the delivered changes cover the original plan. Read-only questions and code explanations do not require those review phases.
Before implementation, qa-sweep sets a static-check baseline scoped to the task files. SAST baseline capture depends on sast_scan; placeholder_scan uses the added-line map to focus its findings. High-risk work, including security, authentication, migrations, and concurrency, requires the full protocol with separate review gates. If no sub-agent tool is available, the skill calls for a clearly labelled self-review and disclosure that independent review could not be done.
To install for Claude Code, run npx skills add ZaxbyHub/opencode-swarm --skill qa-sweep -a claude-code. The skill file is at ~/.claude/skills/qa-sweep/SKILL.md. The agent continues until it reaches 95% confidence in the technical work; actions deliberately left to the user are outside that gate.
What it helps with
- split independent implementation tasks across sub-agents
- find edge cases and regressions in a fresh review
- check delivered changes against the original plan
- scope static-check findings to newly changed work
Example prompts for the agent
- Fix the bug in this module, split independent tasks across sub-agents, and follow the qa-sweep checks.
- Review these changes with a fresh agent, then compare the result with the original plan.
- Trace this failure through the source and logs; if you change files, apply the qa-sweep review process.
How to install qa-sweep
1Skills CLI (Vercel)
npx skills add ZaxbyHub/opencode-swarm --skill qa-sweep -a claude-code2Manually: put the files in place
~/.claude/skills/qa-sweep/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/qa-sweep/
1Skills CLI (Vercel)
npx skills add ZaxbyHub/opencode-swarm --skill qa-sweep -a codex2Manually: put the files in place
.agents/skills/qa-sweep/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add ZaxbyHub/opencode-swarm --skill qa-sweep -a cursor2Manually: put the files in place
.cursor/skills/qa-sweep/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install ZaxbyHub/opencode-swarm .claude/skills/qa-sweep2Manually: put the files in place
.github/skills/qa-sweep/SKILL.md1Skills CLI (Vercel)
npx skills add ZaxbyHub/opencode-swarm --skill qa-sweep -a gemini-cli2Platform CLI
gemini skills install https://github.com/ZaxbyHub/opencode-swarm --path .claude/skills/qa-sweepManually: put the files in place
.devin/skills/qa-sweep/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add ZaxbyHub/opencode-swarm --skill qa-sweep -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about qa-sweep
How do I install qa-sweep in Claude Code?
Run npx skills add ZaxbyHub/opencode-swarm --skill qa-sweep -a claude-code. The skill file is located at ~/.claude/skills/qa-sweep/SKILL.md.
What does the qa-sweep skill do?
It sets a workflow for changed work: parallel implementation, an independent adversarial review, and a separate check against the plan. The stop condition is 95% confidence.
What if no sub-agent tool is available?
The skill requires a labelled self-review and a disclosure that independent review was unavailable, rather than presenting the self-review as independent.
Source text
SKILL.md · MIT
---
name: qa-sweep
description: >
Apply when implementing features, fixing bugs, debugging errors, investigating failures,
tracing root causes, reviewing tech debt, tracing issues, planning fixes, or completing
any task. Enforces parallel sub-agent implementation, independent adversarial review,
and a 95% confidence gate before stopping.
metadata:
audience: swarm-plugin
effort: high
---
## QA & Independent Review Protocol
Follow this protocol on every implementation, fix, debugging, or review task.
### Proportionality
Scale the **depth** of each phase to risk — never skip a gate for changed work,
but match its weight to the task:
- Read-only or answer-only work (explaining code, reading logs, answering a
question) with no worktree edit: Phases 2–3 are not required; verify claims
against the actual source before answering.
- Any worktree edit (code, tests, docs, package metadata, release notes, skill
files): Phases 2 and 3 are mandatory. For a small, low-risk edit, one fresh
review agent covering both the adversarial and completeness checklists is
acceptable; for high-risk or cross-file work, keep them separate.
- High-risk work (security, auth, isolation, IPC contracts, payments,
migrations, concurrency): full protocol, no consolidation.
This proportionality applies only to qa-sweep's own Phase 2/3 passes. When
swarm mode is enabled, the swarm-mode contract's separate independent
implementation reviewer and final critic gates apply unreduced to any
changed work — consolidation here never merges or replaces those gates.
For agent-type, model, and effort selection when spawning these sub-agents,
load the `orchestrating-subagents` skill: economize on explorers, never on
reviewers.
### If no subagent tool is available
If this protocol executes in a context without a subagent tool (`Agent` or
`Task`) — check your actual tool list rather than assuming — perform the
Phase 2/3 checklists yourself as a clearly labeled **fallback self-review**
and disclose in your report that independent review was unavailable, so the
orchestrator can re-run the gate with a real fresh agent. Never present
self-review as independent review.
### Phase 1 — Parallel Implementation
- Use parallel sub-agents to speed up independent units of work wherever possible.
- Each sub-agent must read relevant source code end-to-end before making changes.
- Reference official documentation to verify whether any behavior is intended before treating it as a bug.
- Do not trust assumptions — prove every behavior against actual code.
### Pre-implementation static-gate baseline
Before the first coder dispatch in any phase, capture a static-gate baseline so findings are scoped to the phase, not to pre-existing code:
- **Defining the pre-phase file set**: the canonical source is the file list passed to `declare_scope({ taskId, files })` (see the swarm-implement skill for the discipline). If `declare_scope` was called with the task's exact file list, that IS the pre-phase file set. If `declare_scope` was not called (e.g., the file list is not 100% obvious), use the containing directories declared in the previous call, OR fall back to the task's `files_touched` array in the plan (`save_plan` writes this). Never use the entire repository as the pre-phase file set — that defeats the point of phase scoping.
- **SAST**: if `sast_scan` is available with `capture_baseline:true`, invoke it once at phase open against the pre-phase file set. Subsequent phase-scoped scans only fail on NEW findings. If swarm tools are unavailable, document the gap in the closure report and skip the baseline capture (do not silently fall back to a project-wide scan that fires on every historical finding).
- **`placeholder_scan`**: no capture-baseline mode, but it is diff-aware — pass `added_lines` (file path → phase-added line numbers) so only newly added lines drive the verdict; a file omitted from the map is scanned unfiltered (fail-closed), so cross-check its findings against the changed lines. For intentionally retained TODO/FIXME/HACK comments, pre-configure `allow_globs` (technical debt tracked elsewhere). Do not delete real placeholders to silence the gate; add them to the allowlist.
- Re-baseline if co-change detection expands the file list after the initial baseline — a missed re-baseline will mis-attribute pre-existing findings to the phase.
### Acceptance tests first
Before running any broader test suite, run the smallest test set that covers the task's acceptance criteria. Full-suite passes can mask targeted failures when ordering or concurrency changes — exercise each FR's acceptance criterion explicitly first.
### Phase 2 — Independent Adversarial Review (Mandatory)
After implementation, spawn a FRESH sub-agent that has not participated in any prior work. Give it this directive verbatim:
> "Assume all work done by the implementing agent is incorrect until you can prove otherwise with
> absolute evidence from the actual code. The implementing agent makes frequent mistakes and tends
> to miss edge cases. Do not trust any claim without tracing it yourself. Review every change,
> test, and edge case end-to-end through the real source."
The review agent must:
- Independently trace each change end-to-end through the codebase
- Search for related issues and regressions the implementing agent may have introduced
- Verify documented behavior vs. actual code behavior
- Surface every edge case not explicitly covered
**Timing requirement:** Phase 2 must complete and all confirmed findings must be addressed **before the commit you intend as the final substantive push**. Do not defer this to "after CI passes" — CI passing on a buggy commit does not retroactively make the review optional. For high-risk work (security, isolation, IPC contracts, auth, payments), this is a hard gate with no exceptions.
### Phase 3 — Completeness Verification
Spawn a SECOND independent agent to verify original planned work vs. delivered work:
> "Assume nothing was completed correctly or fully. Map every originally planned item to actual
> code changes and verify each one independently. Do not trust the implementing agent's report."
### Stop Condition
Do NOT stop until ≥95% confident that:
- All issues, related issues, and edge cases are covered
- All review agent findings have been addressed
- Delivered work matches the original plan completely
If below 95%, state what remains and continue working.
#### User-controlled gates
When the user has explicitly declined or deferred an action that is theirs to take — such as choosing "Leave it for you" on a merge offer, or explicitly saying they will merge manually — that action is outside the agent's scope. The 95% confidence gate applies to technical work the agent controls. Publication by merge is a user-controlled gate: once the user has deliberately declined it, the agent's work is complete and the stop condition is satisfied. Do not loop on pending user-controlled actions.
### Reviewer rejection loops
When a single file has gone through 2+ reviewer rejection cycles without
resolution, escalate to `critic_sounding_board` before the next re-dispatch.
The sounding board can identify whether the reviewer's bar is unreasonable,
the implementation is fundamentally wrong, or the rejection is structural
(e.g., skill-load failure masquerading as a content rejection). Do not
enter a third rejection cycle without sounding-board consultation.
### Skill-load failures in reviewer delegation
If a reviewer returns a REJECT that explicitly cites `SKILL_LOAD_FAILED`,
treat the verdict as **INCONCLUSIVE** — not a content rejection. Re-dispatch the
reviewer with `SKILLS: none` (omitting the problematic file reference)
so the reviewer evaluates the actual code, not the skill-loading
infrastructure. This only applies when the rejection explicitly cites
a skill-loading failure — never use `SKILLS: none` to suppress a
legitimate content-based rejection.
### Inline code fallback for restricted review contexts
When a reviewer cannot read files directly (read-restricted advisory
lanes, sandbox limitations), include the most relevant code snippets
inline in the delegation prompt with `path:line` anchors so citations
are independently verifiable. This is a **fallback only** — prefer
file-read access when available, and never inline entire files (large
inline prompts can produce malformed tool-call JSON). Keep inline
snippets to the specific functions or blocks under review.
### One-shot docs review delegation
When a reviewer rejects a documentation file, do not send piecemeal
fix-one-issue delegations. Read the entire file yourself, list ALL
issues in a single comprehensive delegation, and have the coder fix
everything in one pass. Apply this per-file — do not batch fixes
across unrelated files (scope containment still applies).
© ZaxbyHub · MIT · ZaxbyHub/opencode-swarm
Similar skills
All skills for Testing and QA →qa-sweep by other authors comes first.