Skip to content
Back to skills

Test

ASecurity

Test a running web app with Argus and report verified bugs with evidence. Use when the user asks to test, QA or check an app or a feature; when a development task has changed something a person uses in a browser and it should be checked there before the work is called done; and when a bug found earlier has been fixed and needs re-testing. Load it before asking the user where the app is or what to test: it says how to find out.

  • 7 stars
  • 0 votes
  • 0 copies
  • 0 views
  • Added November 18, 2026
testingpythongobashdockertesting

Works with

  • cli
  • mcp

Security analysis

A100/100

Scanned November 18, 2026

npx -y skills add chriswu727/argus --skill test --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Test?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Test
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/chriswu727-test/badge)](https://www.skillsdirectory.com/skills/chriswu727-test)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
description: Test a running web app with Argus and report verified bugs with evidence. Use when the user asks to test, QA or check an app or a feature; when a development task has changed something a person uses in a browser and it should be checked there before the work is called done; and when a bug found earlier has been fixed and needs re-testing. Load it before asking the user where the app is or what to test: it says how to find out.
argument-hint: "[url] [what to focus on]"
---

Test the application the user is authorized to exercise, using the Argus MCP
tools (`mcp__plugin_argus-testing_argus__*`), and finish without needing the
user: they should hear the result, not manage the run. Arguments: $ARGUMENTS

Two rules hold for the whole run:

- Do not open by asking where the app is or what to test. Look first; section
  1 says where.
- Find and report. Do not edit the application's code unless the user asked
  for a fix, and never before you have closed the session and reported.

## 1. Settle the scope yourself

- **Address.** Take it from the arguments or the conversation. Otherwise find
  it, in this order: a dev server you or the user already started, the
  README, the project's start script and its port (`package.json`,
  `Makefile`, `docker-compose.yml`), or the framework default. Environment
  files such as `.env` hold credentials and tokens: do not print or read one
  whole. Only if nothing else gives the address, look up the single host or
  port variable you need (for example with `grep -E '^(HOST|PORT)='`) and
  leave every other value out of the conversation. If the app is not running
  and starting it is part of the work you were given, start it with the
  project's own command. Ask only when none of this gives an address.
- **Goals.** Turn the request into three to six user journeys. For "test the
  app", cover the main flows. For a feature that was just built or changed,
  cover that feature and the flows next to it. Each journey should include
  what a person would really do: the normal path, a wrong or empty input, a
  change of state (add, edit, delete, toggle), and a reload to see whether the
  change stayed.
- **Budget.** Pass `time_budget_minutes` (15 is a good default; less for one
  feature) and stop when it is spent. Report what was not reached.
- **Authority.** Stay inside what the user already allowed. Do not buy, send
  messages, publish, or delete real data, and do not test a production system,
  unless the user said so; record such a path as blocked and go on. Ask the
  user only for something you cannot get any other way: a login you were not
  given, or a decision outside the task.

## 2. Start

Call `start_session` with the address, goals, constraints and budget. Setup
does not need the user:

- The first session downloads the browser (one time, about 150 MB). If the
  result says the download is still running, wait a minute and call
  `start_session` again, for up to five minutes.
- If the browser still cannot start, install it into the environment the
  server runs in, then call `start_session` again:

  ```bash
  uv run --isolated --project "${CLAUDE_PLUGIN_ROOT}" --locked --python 3.12 python -m playwright install chromium
  ```

- If the address cannot be reached, the app is not running: start it as in
  section 1 and try again.
- For any other setup failure, run the same command with `argus-mcp --doctor` in place of
  `python -m playwright install chromium`.
  It prints the fix for each failed web check; the macOS screen grants it
  lists are not needed for web testing.

Tell the user about a setup problem only when the fix is theirs to make: no
network to download from, or system libraries that need administrator rights.

If the result says earlier findings are journaled for this site and the user
asked to re-test after a fix, go to section 5.

## 3. Test

Follow the protocol that `start_session` returns. In short: mark the goals you
are about to walk `in_progress` with `coverage_update` and walk each journey with
real state. For a click that should change something (add, complete, delete,
save), use `test_action` with an `expect` prediction, such as
`{"removes": "Buy groceries"}` or `{"count": {"label": "tasks", "delta": 1}}`.
A SURPRISE is a lead to verify, not yet a bug.

Text alone hides many problems, so look at each key page as a user would at
least once per journey: take a `screenshot` and judge it. Watch for the main
action styled weaker than a secondary one, urgency, stock or discount claims
that the prices do not support, odd field order, labels that contradict each
other (a field marked required but labelled optional), and prices or totals
that disagree between pages. Run `check_layout` for overflow and clipped text.
Record such judgments with `record_observation`; use `record_bug` with `verify`
only when a text check on a fresh load can confirm the symptom.

Check persistence after writes
with `verify_persistence`, and record only reproducible, user-affecting bugs
with `record_bug`. Use `verify` (or the
`suggested_verify` from a persistence mismatch) so Argus rechecks the symptom on
a fresh load. Use `record_observation` for visual or usability judgments.
Never repeat a write or use `replay` only to obtain a receipt.

The two tools read `expect` differently. `verify_persistence` takes the state
that should hold (a deleted row is `absent`). `record_bug`'s `verify` takes the
symptom, what the page shows while the bug is there (the deleted row is still
`present`). When a persistence check fails, record it straight away, before
any other action, passing the `suggested_verify` that check returned. If
`record_bug` answers with a `suggested_verify` of its own, the finding is not
confirmed yet: Argus never applies it for you. When the finding is that
persistence failure, call `record_bug` again with its `finding_id`, the same
title and severity, and that `verify`.

Finding a bug is not a reason to stop or to start fixing. Record it, finish
the other journeys, close the session and report.

Report what you found, not how much. A page with no defects is a normal
result; do not record style preferences or possible improvements as bugs to
fill the list.

### When something goes wrong

Handle these yourself; none of them is a reason to stop or to ask the user.

- **The element is gone or the description is ambiguous.** The page changed.
  Call `observe` and pick the target from what is there now.
- **The page is still loading.** Call `observe` again, at most three times,
  then treat the slow load as the finding it is.
- **A call timed out or failed after a write** (submit, save, delete, pay).
  The write may have happened. Look first (`observe`, or `verify_persistence`
  on the page that would show it) and repeat the action only if it did not
  take effect.
- **The session failed or was closed.** Call `end_session` so the report and
  the journal of verified findings are written, then `start_session` again
  with the goals that are not finished. Carry the earlier findings into your
  final report.
- **A journey needs a login you do not have.** Mark that goal `blocked` with
  the reason, finish the other goals, and ask for the account in your report.
- **A check comes back inconclusive.** Follow its reason once (check the page
  that really shows the content, or a filtered view of a long list). If it is
  still inconclusive, report it as inconclusive. Never restate it as passed or
  failed.

## 4. Deliver

**Only if the user asked for a regression test file** (to keep in CI, for
example), export it first, while the session is open. `export_test` reads the
findings of the current session, and `end_session` closes it: after that the
call fails and the finding would have to be reproduced and recorded again in
a new session. It works for a finding verified by a fresh-load text check and
writes a Playwright test that fails while the bug is present. Pass `run=true`
only when the user authorized repeating the journey's writes (for example on
throwaway data), and report the TODO steps it lists rather than guessing them.
Application values are private parameters: only set
`save_private_values=true` when the user explicitly wants to retain local
replay values; the JSON file it returns may contain credentials and must
never be published or committed. Without such a request, skip this step:
exporting is not part of every run.

Then close with `end_session`, passing the final `coverage_updates` for the
goals you exercised or found blocked, with the evidence you observed, and tell
the user, in plain language:

- What you tested: the journeys, and the address.
- Each bug: what happens, who it affects and how badly, the steps to see it,
  and where the evidence is (the screenshot and report paths from Argus).
  Group by verdict: verified, observed (agent judgment), not reproduced,
  inconclusive. Never present an observed finding as verified.
- What was not finished and why: goals blocked, not reached, or cut by the
  budget.
- If nothing was found, say so and say what was exercised. Completing the run
  does not mean the application passed everything; it means these journeys
  showed no defect.
- The paths of any test files you exported.

Do not change the application's code unless the user asked for that. If fixing
is part of your task, fix, then re-test as in section 5.

## 5. Re-test after a fix

Argus keeps verified findings in a journal per site, so nobody has to
configure anything to check them again.

1. `start_session` on the same address with `review_mode="regression"`.
2. If the bug was a change that did not stay (a delete that came back, a save
   that was lost), the old data is still there: do that action once on the
   fixed build first.
3. Call `regression_check`. It re-runs each journaled finding's fresh-load
   check: STILL-PRESENT, NO-LONGER-REPRODUCES or INCONCLUSIVE. It is
   deterministic and read-only, so use it for known findings instead of
   exploring again.
4. For a finding that no longer reproduces, make sure the feature now works,
   not only that the old symptom is gone, and look at the flows next to the
   fix for anything it broke.
5. `end_session`, then report per finding: fixed, still present, or
   inconclusive with the reason. If the journal has no entry for the bug (it
   was observed but not verified, or recorded elsewhere), say so and re-test
   it by hand from the earlier report.

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in testing →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.