Skip to content
Skills Library
Programming · Testing

write-qa

/write-qa

Write coverage-mapped QA deliverables. Use when asked for a test plan, manual test cases, a regression suite, or a bug report. Not for automated tests (tdd) or hunting bugs in code (bug-hunt).

Licence
MIT
Last repository change
27.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
5
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.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

Write coverage-mapped QA deliverables. Use when asked for a test plan, manual test cases, a regression suite, or a bug report. Not for automated tests (tdd) or hunting bugs in code (bug-hunt).

Original author description

Write coverage-mapped QA deliverables. Use when asked for a test plan, manual test cases, a regression suite, or a bug report. Not for automated tests (tdd) or hunting bugs in code (bug-hunt).

How it works

  1. Steps
  2. Test types
  3. Referencing
Original SKILL.md headings · 111 lines, 777 words
SKILL.md preview
---
name: write-qa
description: Write coverage-mapped QA deliverables. Use when asked for a test plan, manual test cases, a regression suite, or a bug report. Not for automated tests (tdd) or hunting bugs in code (bug-hunt).
---

# Write QA

Where a spec exists, its requirement IDs are the coverage map's spine ([write-specs](../write-specs/SKILL.md)); an observation that can be automated belongs to [tdd](../tdd/SKILL.md) — a manual case covers what only a human run can check.

## Steps

### 1. Route

| Ask                                      | Deliverable      | Template                                   |
| ---------------------------------------- | ---------------- | ------------------------------------------ |
| Test plan, feature plan, release plan    | Test plan        | [test-plan.md](test-plan.md)               |
| Manual test cases or scenarios           | Test case        | [test-case.md](test-case.md)               |
| Smoke, sanity, targeted, full regression | Regression suite | [regression-suite.md](regression-suite.md) |
| Bug report or defect write-up            | Bug report       | [bug-report.md](bug-report.md)             |

Ambiguous ask → ask which deliverable, once. Several requested → produce each and cross-link their **traceability**.

A regression suite also carries a level, which fixes its scope before intake:

| Level    | When                      | Scope                                            |
| -------- | ------------------------- | ------------------------------------------------ |
| Smoke    | Daily / build gate        | Critical paths only                              |
| Sanity   | After hotfix              | Narrow confirmation the fix holds                |
| Targeted | After a specific change   | Modified area plus blast radius                  |
| Full     | Release / major milestone | All in-scope functional and integration coverage |

Default to **Targeted** for a change set and **Full** for a release.

**Done when** every requested deliverable names its template, and any regression suite names its level.

### 2. Intake

Gather only what the routed deliverables need to be actionable:

- Requirements, acceptance criteria, or the observed failure
- Affected journeys, interfaces, services, data, integrations
- Environments, platforms, test data, constraints
- Changed behavior, designs, blast radius

Missing context the material cannot answer → ask the user; [grilling](../grilling/SKILL.md) is how. User says proceed anyway → fill the template's **Assumption Register** and set its **Readiness:** line to **Draft**. Every template carries both; with nothing assumed, the register holds one `None` row.

**Done when** every needed input is known, marked unknown, or sits in the Assumption Register.

### 3. Coverage map

For each in-scope requirement and surface:

1. Inventory states, transitions, contracts, dependencies, error/retry paths — fan out [research](../research/SKILL.md) where the surface is wide.
2. Name the risk and the test type that addresses it.
3. Map to a planned case, suite check, or justified gap, citing the requirement ID where a spec exists.
4. Keep the map inside the deliverable — plan and regression always; cases and bugs via **traceability**.

**Done when** every in-scope item maps to coverage or an explicit justified gap.

### 4. Draft

Read each routed template file, then fill it against the shared scales below.

#### Priority scale

| Priority | Meaning                                     |
| -------- | ------------------------------------------- |
| P0       | Release blocker / critical path — every run |
| P1       | High impact — before release                |
| P2       | Moderate — release or next cycle            |
| P3       | Low — when possible                         |

#### Ready gates

| Deliverable      | **Ready** only when                                                                                                             |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| Test plan        | Objective, scope, environments, **coverage map**, entry/exit, and risks complete; every gap justified                           |
| Test case        | At least one **observable** step; priority, objective, preconditions, data, and **traceability** present or marked not required |
| Regression suite | Level, order, and pass/fail bar set, with `[N]` replaced by a number; every affected surface covered or gap justified           |
| Bug report       | At least one **repro** step; environment, expected, actual, severity, and priority set                                          |

**Done when** each deliverable passes its ready gate, or its **Readiness:** line reads **Draft**.

## Test types

One prefix per type, carried in the case ID.

| Type        | Prefix   | Example     |
| ----------- | -------- | ----------- |
| Functional  | TC-FUNC- | TC-FUNC-001 |
| UI          | TC-UI-   | TC-UI-045   |
| Integration | TC-INT-  | TC-INT-012  |
| Regression  | TC-REG-  | TC-REG-089  |
| Security    | TC-SEC-  | TC-SEC-005  |
| Performance | TC-PERF- | TC-PERF-023 |
| Smoke       | SMOKE-   | SMOKE-001   |
| Exploratory | —        | unscripted  |

## Referencing

Where a deliverable lives follows its lifetime, under the [referencing convention](../write-specs/SKILL.md#referencing).

Net-new here: standing QA filenames — bugs as `BUG-NNN-<slug>.md`, release and build-gate suites as `<release-or-gate>.regression.md`.

`<name>.cases.md` collects the whole set into one file (structure in `test-case.md`). Each case heading is the bare case ID, so a link to a case is the file plus `#` and the lowercased ID: `## TC-FUNC-001` resolves as `#tc-func-001`.

```markdown
case to requirement [`R2`](<name>.spec.md#requirements)
case to bug [`BUG-007`](../../../docs/qa/BUG-007-checkout-total-zero.md)
bug to spec [`auth spec`](../plan/2026-08-13-auth/auth.spec.md)
suite to case [`TC-FUNC-001`](../plan/2026-08-13-auth/auth.cases.md#tc-func-001)
```

A bug found while executing a case gets the next `BUG-` number and a link from the case's execution history.
Files in this package (5)
  • SKILL.md 6 KB
  • bug-report.md 4 KB
  • regression-suite.md 2 KB
  • test-case.md 4 KB
  • test-plan.md 3 KB

Versions

The database has no other skills named write-qa.

Database snapshot: 13.11.2026 · package version 3b572d7b4b3f (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

  • 100qa-manual-istqb
    Create QA artifacts from requirements: test plans, test conditions/cases, bug reports, regression suites, traceability, and exploratory charters. Use for test planning, test design, defects, coverage, or QA deliverables. Applies ISTQB risk-based techniques and loads templates…
  • 90write-tests
    WAY 4 — write test cases only, no execution. Use when the user says "write it", "write tests", "generate test cases" — requirements (text or a tracker issue), optional App/Spec/MR or PR → test files + test-plan issue.
  • 85playwright-qa
    QA engineering workflows on top of Playwright. Use when a QA engineer asks to design test cases from a ticket, PRD or acceptance criteria, decide what to automate, write a bug report from a failing test or trace, convert manual test cases (TestRail, Xray, CSV) into Playwright…
  • 90designing-functional-tests
    Designs risk-based functional test plans, manual test cases, regression slices, and automation handoff packs from requirements, URLs, or exploratory notes. Use when preparing manual QA coverage before automation, turning feature descriptions into scenario catalogs, or converting…
  • 100automate
    Convert manual test cases into automated tests (Playwright for UI, pytest/requests for API) and help build or extend a test automation framework. Use when the user wants to automate test cases, write Playwright/Selenium scripts, or set up test automation.
  • 86write-tests
    Use when the user asks to write, add or extend tests for some code (unit tests, regression test for a bug, coverage of a new feature).

Feedback and reports

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