Orchestrate Resumable QA Pipelines with the qa Skill

Where this fits

A developer drops a ticket into their agent: 'Test the new checkout flow end-to-end.' Without an orchestrator, the agent either loads all testing skills at once, muddles contexts, and produces a report with no traceable artifacts. The qa skill is a thin entry point that turns that request into a pipeline: requirement understanding → test strategy → case writing → review → execution → bug analysis → regression → report. It only orchestrates; all testing methodology lives in stage-specific skills, and every artifact lands on disk so the pipeline can be interrupted and resumed.

Why agents benefit

• Keeps context clean: each stage runs with only its own skill and the previous stage's artifact; the main session stores just pipeline state and file paths.
• Resumes from disk: if a run is interrupted, the agent can read the last checkpoint and continue from there instead of re-running earlier stages.
• Delegates without method conflict: the orchestrator does not duplicate testing knowledge, so stage experts can be swapped or updated independently.
• Avoids instruction overload: the anti-pattern of stacking nine SKILL.md files in one session is explicitly blocked; even in pre-injected setups, phase order prevents cross-skill interference.
• Routes honestly: if the user only asks for 'review this test case,' qa redirects to test-case-review rather than starting a heavyweight pipeline.

Practical scenarios

Feature request to full test report

A developer asks 'Run a complete test on the new API.' The agent starts the pipeline, produces a test strategy, writes and reviews cases, executes E2E checks, analyzes failures, selects regression scope, and writes a final report. The user can trace every decision back to an artifact on disk.

Resuming after a session timeout

The pipeline reaches execution but the session dies. The next morning, the developer says 'continue the testing.' qa finds the checkpoint files, verifies which stages completed, and resumes from the first unfinished stage without re-generating prior deliverables.

Single-phase request avoids pipeline overhead

A QA engineer asks 'Review these existing test cases for coverage gaps.' The skill detects that this is not a full-pipeline request, hands over to the case-review stage skill, and skips requirement modeling, execution, and reporting.

Add it to your agent workflow

Install the skill:

npx skills add fishzjp/qa-skills --skill qa

Then ask for an end-to-end pass:

user: Test the search feature against the requirement doc.
agent: Starting QA pipeline.
       Stage 1: requirement analysis -> artifacts/requirements.md
       Stage 2: test strategy -> artifacts/strategy.md
       ...

Check pipeline-state.json after each stage; that file is the source of truth for resumption.

Compare before adopting

Evaluate against your current prompt chain or monolithic test skill. Look at quality signals: does the README document the dual-mode context isolation and the pre-injected fallback? Are stage-skill boundaries clean? Check maintenance freshness: version 0.7.0 exists, but stars are modest, so confirm commits and issue responses are active. Compare alternatives: a single all-in-one test skill may be simpler but loses resumability and stage isolation. Finally, verify workflow fit—your runtime must support persisted artifacts for the checkpoint promise to hold.

Why it is worth tracking

This skill is worth watching because it solves a real orchestration problem—multi-stage testing with clean context isolation—without embedding fragile test-method knowledge. The versioned pipeline design, explicit anti-pattern guidance, and graceful degradation to sequential mode are good signals even before community size grows. If your agents frequently handle 'test this whole feature' requests, evaluate it now; if you already use separate testing skills, track it as a potential integration shell. The OpenAgentSkill listing keeps the maintenance signals in one place: https://www.openagentskill.com/skills/fishzjp-qa