Skip to content
Skills Library
Programming · Testing

qa-test

/qa-test

Run an automated QA flow against a CLI or a locally-served app and report step-level pass/fail with evidence. Use when asked to QA-test a feature, exercise a flow end-to-end, or smoke-test what a PR changed.

Repository
lastlight ↗
Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Run an automated QA flow against a CLI or a locally-served app and report step-level pass/fail with evidence. Use when asked to QA-test a feature, exercise a flow end-to-end, or smoke-test what a PR changed.

Original author description

Run an automated QA flow against a CLI or a locally-served app and report step-level pass/fail with evidence. Use when asked to QA-test a feature, exercise a flow end-to-end, or smoke-test what a PR changed.

How it works

  1. Parse the target
  2. Define the steps
  3. Run each step
  4. Report
Original SKILL.md headings · 92 lines, 679 words
SKILL.md preview
---
name: qa-test
description: Run an automated QA flow against a CLI or a locally-served app and report step-level pass/fail with evidence. Use when asked to QA-test a feature, exercise a flow end-to-end, or smoke-test what a PR changed.
version: 1.0.0
tags: [github, qa, testing, evidence]
---

# QA Test

Drive a target through a sequence of steps and report **step-level pass/fail**
with evidence for each step. The deliverable is a QA report, not a single
verdict — partial coverage with documented failures is the expected output.

This skill uses the **building** skill for installing dependencies and running
the repo's build/run commands in the sandbox.

> **Scope (text-evidence path).** In the default text phase the sandbox agent
> has bash, file read, and the github tools — no browser, no screenshots. QA a
> **CLI** directly, or a **web service** by starting its dev-server in the
> background and exercising it with `curl` (status codes, response bodies,
> headers). Capture stdout/stderr, exit codes, and log excerpts as per-step
> evidence. Driving a real browser UI and attaching screenshots is the separate
> `browser-qa` skill, staged only in the gated browser phase running on the
> docker QA image (Playwright + Chromium). If that skill isn't in your
> catalogue, mark a step that genuinely needs rendered-UI interaction
> **BLOCKED** with the reason rather than faking a result — the browser phase
> will pick it up when available.

## Parse the target

The Context block gives you what to test and (usually) a PR/issue. The target
may be:

- A **CLI command** (`my-cli --flag`, a subcommand) → run it directly.
- A **local web service** (an app the repo serves on a port) → start it, hit it
  with `curl`.
- A **PR reference + focus area** → read the diff and infer the flow that
  exercises what changed.
- A **free-text flow** ("create a project, then list it") → infer concrete steps.

When a PR/issue is given, read its description + diff (from the local checkout —
see the **building** skill) to decide what's worth testing.

## Define the steps

If the request specifies steps, use them. Otherwise design a reasonable flow:

- **CLI**: invoke with valid input → assert output/exit code → invoke an edge
  case (bad flag, missing arg) → assert it's handled → done.
- **Web service**: start the server → wait until it's ready → hit the primary
  endpoint(s) → assert status + body → hit an error case → assert handling →
  stop the server.

State the steps and their success criteria before running. If the flow or the
success criteria are genuinely ambiguous and you can't infer them from the diff,
say what's unclear in the report rather than inventing a pass.

## Run each step

Follow the **building** skill to install and build first. Then run each step in
order, capturing evidence (command + stdout/stderr + exit code) at every step.

- **Record each step's result as you go** — PASS, FAIL, or BLOCKED.
- **On failure, continue to the next step** for maximum coverage — *unless* the
  failure blocks everything downstream (e.g. the server never starts, or a login
  step fails). If it's a hard blocker, record it, mark the rest BLOCKED, and stop.
- Treat a wrong result as a real finding, not your mistake. Don't edit the code
  under test to make a step pass.

## Report

Produce your report as your **final message** in this shape — the workflow posts
it for you (don't `github_add_issue_comment` yourself; that would double-post).
**Keep it concise**: a one-line environment summary, the results table (terse
Evidence cells), the failures, and a short coverage note — not a step-by-step
narration.

```
## QA Test: <target>

**Environment:** <branch / commit, package manager, how the app was run>

### Results
| Step | Status | Evidence |
|------|--------|----------|
| <step description> | PASS / FAIL / BLOCKED | <command + key output / exit code> |

### Issues found
- <each FAIL with the expected vs observed behaviour and the evidence>

### Coverage
<what was tested, and what was not tested and why (e.g. a UI-only step that the
text-evidence sandbox can't drive).>
```

Every defined step must have a row and a result. Never report a flow as
"passed" with steps you didn't actually run — list them as untested instead.

Versions

RepositoryScoreLicence
This page · nearform/lastlight100MIT
anhle9x/ai-worker90MIT

Database snapshot: 13.11.2026 · package version 483d1c33cee4 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100runner
    Use when executing a stable E2E test case that has already been refined. Follows test steps exactly without deviation, reports pass/fail with evidence.
  • 100browser-qa
    Drive a real headless browser against a locally-served web UI and capture screenshot evidence, reporting step-level PASS/FAIL/BLOCKED with extracted DOM text and console errors. Use when a phase on the docker QA image must exercise a rendered UI and attach screenshots — it…
  • 100dev-smoke
    AI DevKit · Smoke-test the user flows a change affects (CLI, API, UI) end to end with a disposable sandboxed script against the real app. Use before calling a feature or fix done, when unit tests pass but the flow is untested, or when users ask for a smoke, e2e, or impact check.
  • 100e2e-walk
    Use when someone wants the app tested end to end by hand, the way a user would: "walk through the main flows", "smoke test the release", "пройдись по основным сценариям", "протестируй релиз". Installs the newest release on an emulator or phone, or opens the web build or desktop…
  • 100test-in-browser
    Check a user flow in the locally running app with the Playwright MCP browser and record evidence: verify the stack is up, act as customer or back office, take a screenshot per step into .context/, watch the console, and give a PASS/FAIL/BLOCKED verdict per acceptance criterion.…
  • 100autoqa
    Self-QA a repo's running application end-to-end — discover how it runs, build a feature×modality test plan, execute it against a live instance, and produce a witnessed pass/fail report. Use when the user says "autoqa", "QA this repo/branch", "verify every feature works",…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.