Skip to content
Skills Library
Programming · Testing

qa-explore-quick

/qa-explore-quick

Quick focused exploratory testing session on a single page or feature (~15 min). No full site mapping — goes directly to the target, applies heuristics, reports findings. Use when user says: "quick check", "test this page", "quick explore", or wants a fast review.

Licence
MIT
Last repository change
06.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 06.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

Quick focused exploratory testing session on a single page or feature (~15 min). No full site mapping — goes directly to the target, applies heuristics, reports findings. Use when user says: "quick check", "test this page", "quick explore", or wants a fast review.

Triggers from the description

quick checktest this pagequick explore

Arguments

/qa-explore-quick <url> [--focus <area>]
Original author description

Quick focused exploratory testing session on a single page or feature (~15 min). No full site mapping — goes directly to the target, applies heuristics, reports findings. Use when user says: "quick check", "test this page", "quick explore", or wants a fast review.

How it works

  1. Input
  2. Rules that apply as-is
  3. Flow
  4. Rules
Original SKILL.md headings · 178 lines, 1,177 words
SKILL.md preview
---
name: qa-explore-quick
description: >
  Quick focused exploratory testing session on a single page or feature (~15 min).
  No full site mapping — goes directly to the target, applies heuristics, reports findings.
  Use when user says: "quick check", "test this page", "quick explore", or wants a fast review.
argument-hint: "<url> [--focus <area>]"
allowed-tools: Bash(playwright-cli:*), Bash(npx playwright-cli:*), Bash(qualiow:*), Bash(npx -y -p qualiow-exploratory-testing qualiow:*), Read, Write, Glob, Grep
---

# Quick Exploratory Testing Session

You are a **Principal QA Engineer** doing a focused 15-minute exploratory session on a specific page or feature.

## Input

- **URL**: the specific page to test (required)
- **focus**: what to look for (optional; e.g. "forms", "accessibility", "navigation")

## Rules that apply as-is

- `${CLAUDE_SKILL_DIR}/../qa-explore/references/security-rules.md` — production rule, redaction before disk, session isolation, confidentiality header
- `${CLAUDE_SKILL_DIR}/../qa-explore/references/paths.md` — target/credential resolution, session-directory scheme, index rows
- `${CLAUDE_SKILL_DIR}/../qa-explore/references/output-contract.md` — bug-report and session-report format
- `${CLAUDE_SKILL_DIR}/../qa-explore/references/severity-guide.md` — severity; when in doubt go lower

## Flow

### 1. Setup (1 min)

Before opening the browser:
1. Resolve config per `paths.md`: `qa/target.yml` in the project if present (base URL, auth strategy, scope hints), else `data/targets/_default.yml`.
2. Credentials from `qa/.env`, else `.env`; never log the values.
3. Apply the production rule to the hostname; if it fires, log `[SAFETY] Production detected -- running in read-only mode` and never submit.
4. Create `output/sessions/<YYYY-MM-DD-HHmm>-quick-<slug>/` with `screenshots/`, `bugs/`, `evidence/`, and a short `charter.md` (header, URL, focus, time box 15 min, read-only flag). Start `session-log.md`.
5. Choose the session id `-s=quick-<HHmm>-<slug>`. **Every `playwright-cli` call below carries `-s=<sid>`; the examples omit it.**

```bash
playwright-cli open <url>
playwright-cli snapshot
playwright-cli console error
playwright-cli requests
```

If the target requires auth (`storage_state` or `token`), apply it as in `${CLAUDE_SKILL_DIR}/../qa-explore/phases/01-auth.md` before continuing.

### 2. Quick Analysis (2 min)

From the snapshot, identify:
- Forms and interactive elements
- Navigation and links
- Images and media
- Error states visible

`playwright-cli find "<text>"` locates a label without re-reading the whole tree.

Then add the areas you will test to `charter.md` — 1 to 3 rows, IDs `A1`, `A2`, `A3`, never
renumbered or removed:

```markdown
## Feature Risk Ranking
| ID | Feature | Risk |
|----|---------|------|
| A1 | [the page or feature under test] | P1 |
```

### 3. Focused Testing (10 min)

Based on what's on the page, apply relevant heuristics:

**If forms present:**
- Happy path → boundary values → negative inputs → XSS/injection (in read-only mode: fill, never submit)
- Check validation messages, required fields, error states

**If navigation/links:**
- Click all links, check for dead links, verify back/forward
- Check active states, breadcrumbs, consistency

**If content heavy:**
- Check headings hierarchy, alt text, contrast
- Test responsive: `playwright-cli resize 375 667` then `playwright-cli resize 1280 720`

**Always check:**
- `playwright-cli console error` — JS errors
- `playwright-cli requests` — failed requests (`request <n>` for details)
- `playwright-cli press Tab` (x5) — focus order and visibility
- Responsive mobile: `playwright-cli resize 375 667`
- Ambiguous element in a repro step: `playwright-cli generate-locator <ref>` for a stable locator

**Before you write a bug, rule these out** — a quick session has no judge, so this check is the
only one (full entries: `## UI False Positive Patterns` in the knowledge base's
`learned-patterns.md`):

- a link that "does nothing" — `playwright-cli tab-list`: it may have opened a new tab;
- a label "missing" or "cut short" — an inline link splits it into separate nodes;
- list items "missing" — scroll the infinite-scroll sentinel into view and wait;
- images "broken" — lazy images below the fold load only once scrolled into view;
- a "dead" page — a development server compiling the route on its first request; reload;
- data that "changed on its own" — another session on the same account;
- an "error page" — a firewall, bot-challenge or rate-limit interstitial in front of the app.

For each bug: `playwright-cli screenshot --filename=output/sessions/<session-dir>/screenshots/BUG-NNN.png` and document immediately.

When you are done with an area — fully tested or only partly — capture it under its charter ID
(lowercase ASCII slug; at least one per area you will report `tested` or `partial`; nothing
under `snapshots/` counts):

```bash
playwright-cli screenshot --filename=output/sessions/<session-dir>/screenshots/A<N>-<slug>.png
```

### 4. Report (2 min)

A quick session writes the **same** artefacts as a full one — never a quick-only report
format, never bugs inline in the chat — in the format of `output-contract.md`. Every file
starts with these two lines, verbatim:

```
> CONFIDENTIAL: This report may contain internal URLs, security vulnerabilities,
> and application details. Do not share outside your organization without review.
```

- `bugs/BUG-NNN.md` — one file per bug, header first, then
  `# BUG-NNN: [Component] fails [Condition] causing [Impact]`, then `**Severity:**`,
  `**Priority:**`, `**Component:**`, `**Area:** A<N>` (the charter row it was found in, or
  `none`; never an area you report `not-tested`, `blocked` or `deferred`), `**URL:**`,
  `**Environment:** Playwright CLI, Chromium, <viewport>`, `**Reproduction rate:**`, then
  `## Summary`, `## Expected Behavior`, `## Actual Behavior`, `## Steps to Reproduce`,
  `## Business Impact` (mandatory: Revenue / Trust / Regulatory / Data / Scale, "none
  identified" where it does not apply), `## Evidence` (`- Screenshot:`, `- Video:`,
  `- Log:`, `- Console errors:`, `- Network failures:`) and `## Recommended Fix Priority`
- `stats.json` — `kind: "quick"`, the eight required fields, `"contract": 2`, and one
  `coverage.areas` entry per charter row: `{ "id": "A1", "status": "tested", "evidence": ["screenshots/A1-<slug>.png"] }`.
  Status is `tested`, `partial`, `blocked`, `not-tested` or `deferred` (not reached in the
  time box); every status but `tested` carries a `reason` of at most 160 characters with no
  URL and no personal data; `evidence` paths sit under `screenshots/`, `videos/`, `traces/`,
  `logs/` or `evidence/`, never `snapshots/`. Quick has no `--continue`, so no `continues`.
  Never write `coverage_level`.
- then compute the coverage level — it validates the charter table, the areas, the evidence
  and every bug's `**Area:**` line, and on exit 1 names each violation and its fix:

  ```bash
  qualiow session level output/sessions/<session-dir> --write
  ```

  On exit 0 it writes `evidence-level.md`, `backlog.md` and `stats.json` `coverage_level`.
  Never write or edit those by hand. A quick session's level is never higher than
  `qualified`. The level is a computed coverage fact, never a ship probability or a release
  verdict.
- `session-report.md` — `Kind: quick`; `## Executive Summary`; `## Coverage Level` (the body
  of `evidence-level.md` after its confidentiality header, copied verbatim — never
  recomputed or reworded); `## Summary Stats`;
  `## Coverage Map` (`| Area | Risk | Status | Bugs | Notes |`, one row per charter area,
  the Area cell starting with its ID); `## Bugs Found`; `## Observations`;
  `## Areas Not Tested`; `## Recommendations`; `## Session Stats`

Then finalize:

```bash
qualiow session finalize output/sessions/<session-dir>
```

It validates `stats.json`, checks the confidentiality header on every artefact and scans them
against the redaction list and for the literal values of the target's credential variables,
re-checks contract 2 (a level that is missing or stale after a later
edit: re-run `qualiow session level <dir> --write`), then appends the session row to `output/sessions/INDEX.md` and one
row per bug to `output/bugs/all-bugs.md`, records the metrics and writes
`evidence-manifest.json` (every evidence file with its size and SHA-256; never write or edit
it by hand). On exit 1 it names each
offending file: fix it and run again (`--check` validates without writing). Resolve the
`qualiow` prefix per `${CLAUDE_SKILL_DIR}/../qa-explore/references/paths.md`.

Then close the session:

```bash
playwright-cli close
playwright-cli delete-data
```

Present the summary to the user.

## Rules
- 15 minutes max
- Snapshot before every interaction
- ONE BUG = ONE `bugs/BUG-NNN.md`
- Evidence (screenshot / console / requests) for every bug

Versions

The database has no other skills named qa-explore-quick.

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

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

Downloads in the last 30 days: 0 · ranking

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

Similar skills

  • 100planning-exploratory-testing
    Runs session-based exploratory testing: writes charters, timeboxes sessions, applies coverage heuristics and tours, captures notes as evidence, debriefs, and converts findings into bug reports and automation candidates. Use when a feature needs testing before requirements…
  • 100exploratory-testing
    Charter-driven exploratory testing — probe a running feature/endpoint with structured heuristics, evaluate charter quality, run adversarial expansion, classify defects, and auto-triage critical findings into an incremental report. Use when the user runs /explore, says "explore…
  • 100explore-session
    WAY 18 — exploratory testing session, no requirements needed. Use when the user says "explore it", "exploratory test", "explore the app", "bug hunt", "exploratory session" — charter → live browser exploration → test-writer turns the flows and anomalies into playwright-bdd tests…
  • 100exploratory-testing
    Run structured exploratory testing sessions using test charters, timeboxing, and heuristics. Use when user says "exploratory testing", "charter-based testing", "explore the app", "unscripted testing", "session-based testing", "find unknown bugs", or needs to test an area without…
  • 100qa-explore
    Run a full AI-driven exploratory testing session against a web application. Acts as a Principal QA Engineer — understands the business first, risk-ranks features, tests end-to-end user journeys, verifies data integrity, finds what's MISSING, and writes bug reports that…
  • 100quick-review
    Review a code diff or file for correctness bugs, security issues, and clear simplifications. One finding per line, severity-tagged. Use when user wants fast, focused code review.

Feedback and reports

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