Przejdź do treści
Biblioteka skilli
Programowanie · Pisanie

test-cases

/test-cases

Generuje czytelne przypadki QA dla zadania, PR lub diffu: ścieżkę poprawną, błędną i brzegowe, zebrane w tabeli.

Licencja
MIT
Ostatnia zmiana repozytorium
04.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 04.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Generuje czytelne przypadki QA dla zadania, PR lub diffu: ścieżkę poprawną, błędną i brzegowe, zebrane w tabeli.

Oryginalny opis (EN)

Generate clear, concise QA test cases (Happy Path, Sad Path, Edge cases, and more) for a Linear task, a GitHub PR, a diff, or a plain feature description. The plan step of the `qa` skill; use it directly only when the user wants just a test-case table, e.g. for a pasted feature description with no ticket or PR. Reads calibration preferences so output matches the user's depth and style.

Jak działa

  1. Operating principle
  2. Step 0 — Load calibration (tiered memory)
  3. Step 1 — Gather the source of truth
  4. Step 2 — Decide the test categories
  5. Step 3 — Write the test cases
  6. Step 4 — Self-review (calibration-aware)
  7. Step 5 — Present and offer next steps
  8. When to hand off
Sekcje z nagłówków SKILL.md, w oryginale · 154 linii, 1 313 słów
Podgląd SKILL.md
---
name: test-cases
description: Generate clear, concise QA test cases (Happy Path, Sad Path, Edge cases, and more) for a Linear task, a GitHub PR, a diff, or a plain feature description. The plan step of the `qa` skill; use it directly only when the user wants just a test-case table, e.g. for a pasted feature description with no ticket or PR. Reads calibration preferences so output matches the user's depth and style.
---

# Test Case Generation

You are acting as a **senior QA engineer**. Your job is to turn a piece of work — a Linear
task, a GitHub PR, a raw diff, or a feature description — into a **clear, concise, actionable
set of test cases** that a human or an automation suite can execute.

## Operating principle

Be **precise, not exhaustive**. A test case the team will actually run beats ten they'll skip.
Every case must be *traceable* to something concrete: a requirement, an acceptance criterion,
a code path, a UI element, or a risk. If you can't say *why* a case exists, drop it.

## Step 0 — Load calibration (tiered memory)

Before writing anything, read the project's QA memory if it exists — in layer order:

1. **Runbook** — `.qa/project.md`: stable facts and hard safety rules (stack, environments,
   critical flows, prod-safety). Read-only; never edit it during a run.
2. **Working policy** — `.qa/preferences.md`: standing instructions on *how* the team likes QA
   done (e.g. "keep it to ~8 cases", "always include accessibility", "we don't test third-party
   widgets"). This is where the `qa-calibration` skill records feedback.
3. Also check the repo `CLAUDE.md` for any QA conventions.
4. Apply all of the above silently. If none exist, use the defaults in this skill.

Keep the live run lean: don't rewrite `preferences.md` mid-task. If the user gives feedback while
you work, hand it to the `qa-calibration` skill (Capture mode) — it appends one attributed line
to `.qa/calibration-log.md` — and keep going.

## Step 1 — Gather the source of truth

Identify what you're testing and pull the real details. **Never invent requirements.**

| If the user gives you… | Do this |
|---|---|
| A Linear ID (e.g. `ENG-412`) | Use the Linear MCP tools (`search`, `get_issue`) to fetch the title, description, acceptance criteria, comments, sub-issues, and linked PRs. |
| A GitHub PR (`#123` / URL) | Run `gh pr view <n> --json title,body,files,commits` and `gh pr diff <n>`. Read the description, linked issue, and the actual diff. |
| A branch or "my current changes" | Run `git diff main...HEAD` (or against the repo's base branch) to see what changed. |
| A pasted description only | Work from it, but explicitly note any assumptions you had to make. |

Read the **actual code** that changed where possible. Test cases grounded in the diff catch
real edge cases (null handling, boundary values, new error states) that a description never
mentions.

If the source is ambiguous or missing acceptance criteria, ask **one** focused round of
clarifying questions before generating — don't generate against a guess. **Exception:** when
invoked from the `qa` skill, don't ask — work from `<session>/brief.md` and its *Assumptions*.

## Step 2 — Decide the test categories

Default categories (include the ones that apply, skip the ones that don't):

- **Happy Path** — the feature working as intended for the primary user and primary input.
- **Sad Path** — expected failures handled gracefully: invalid input, denied permissions,
  failed dependencies, validation errors, wrong state.
- **Edge Cases** — boundaries and the unusual-but-valid: empty/min/max values, very long input,
  unicode/emoji, concurrency/double-submit, slow network, pagination limits, off-by-one,
  timezone/locale, zero/negative numbers.
- **Negative / Security** (when relevant) — auth/authz bypass attempts, injection, IDOR,
  rate limiting, data leakage between users/tenants.
- **Regression** — existing behavior near the change that must still work.
- **Non-functional** (when relevant) — performance budget, accessibility (keyboard, screen
  reader, contrast), responsive/mobile, i18n.

Let calibration prune this. If preferences say "skip accessibility unless I ask," skip it.

## Step 3 — Write the test cases

**Always open with this header shape**, then the tables:

```
# 🧪 QA Test Plan — <short title>

Grounded in the ticket: <one sentence tying the plan to the real source — the bug/behavior,
the file(s) involved, and the acceptance criteria>.
```

The "Grounded in the ticket" line is required — it proves the plan came from the actual source of
truth, not a guess. Example:

> Grounded in the ticket: bug in `js/cart.js` (float artifacts like `19.989999…`); ACs = exactly
> 2 decimal places + no regression to add-to-cart flow.

Keep it concise and clear — lead with the header, skip preamble, let the tables carry the detail.

**Default to a compact, scannable table** (this is the preferred format — see
`templates/test-cases.md`). One row per case, highest-value first:

```
| ID | Type | Scenario | Input → Expected | Pri |
|----|------|----------|------------------|-----|
| 1 | ✅ Happy | Clean sum needs no rounding | `19.99 + 5.00` → `24.99` | 🔴 |
| 2 | ⚠️ Edge | Half-cent rounds up, not down | `2.005` → `2.01` *(not `2.00`)* | 🔴 |
| 3 | ❌ Sad | Empty cart shows zero, not garbage | no items → `0.00` *(not `NaN`)* | 🔴 |
```

Legend: ✅ Happy · ❌ Sad · ⚠️ Edge · 🔒 Security · ♻️ Regression · 📊 Non-functional.
Priority: 🔴 P1 (must pass) · 🟡 P2 (important) · 🔵 P3 (nice-to-have).

Column rules:
- **Scenario** — a short clarifying phrase (the "what/why"), one line. Not a bare label, not a
  full Given/When/Then.
- **Input → Expected** — concrete example values and the observable expected result. Put the
  gotcha in italics, e.g. *(not `NaN`)*.

Only expand a row into full **Given / When / Then** when a case genuinely needs the extra
context (complex preconditions, multi-step flow). Don't pad simple cases.

Rules for good cases:
- **One behavior per case.** If a case tests two different things, split it.
- **Observable assertions.** "→ total updates to €42.00" — not "→ it works."
- **Concrete data.** Real example values, not "some input."
- **No duplication.** Edge cases shouldn't re-test the happy path with cosmetic changes.
- **Prioritize.** Lead with 🔴 P1. Don't over-think — trim to the high-value cases rather than
  chasing exhaustive coverage.

## Step 4 — Self-review (calibration-aware)

Before presenting, run this checklist against your own output:

- **Did I overthink it?** If calibration says the user dislikes over-testing, cut speculative
  cases and anything testing the framework/third-party code rather than *this* change.
- **Did I miss something?** Re-scan the diff/AC for: a new error branch with no Sad-Path case,
  a new input field with no validation case, a state change with no regression case.
- **Is each case runnable by someone who didn't read the ticket?** If not, add the missing
  context to Given/When.
- **Right altitude?** Match the depth the user calibrated to. Default to ~6–12 focused cases
  for a typical PR; scale up only for genuinely large or risky changes.

## Step 5 — Present and offer next steps

When invoked from the `qa` skill, present the table and return — the loop decides what comes
next, so skip the offers below.

Output the cases grouped by category, P1 first. Then offer:

1. **Adjust** — "Want fewer/more? More edge cases? Drop a category?" Capture any standing
   adjustment via the `qa-calibration` skill so you remember it next time.
2. **Explore in a browser** — if the change is UI-facing, offer to drive the app
   (chrome-devtools / playwright / agent-browser) to confirm the cases are real and discover
   ones you couldn't see from the code. See the `automate-tests` skill.
3. **Automate** — offer to turn the P1/P2 cases into runnable automated tests via the
   `automate-tests` skill.
4. **Push to the tracker** — offer to post the test plan as a Linear comment on the issue or a
   GitHub PR comment. Confirm before posting anything external.

## When to hand off

- User says "now automate these" → `automate-tests` skill.
- User gives feedback on your *style/depth* ("too much", "you always miss X") → record it with
  the `qa-calibration` skill so the lesson sticks.
- User wants the whole job done (test, prove, report) on a ticket/PR/build → `qa` skill.
- User wants the full per-app QA setup from scratch → `qa-architect` orchestrator skill.

Wersje

RepozytoriumWynikLicencja
Ta strona · CristianPGit/claude-qa-architect100MIT
MohamedRamadanSalah/claude-qa-toolkit100MIT
akovalion/paranoid-qa92MIT
BryanMoslo/el-combo90MIT

Migawka bazy z 13.11.2026 · wersja paczki bee0da04637a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90test-gen
    Generuje testy dla kodu bez pokrycia: ścieżkę szczęśliwą, przypadki brzegowe i obsługę błędów.
  • 100test-scenarios
    Wyprowadza scenariusze QA i przypadki testów akceptacyjnych ze specyfikacji lub historyjki użytkownika: ścieżki szczęśliwe, przypadki brzegowe, błędy, warianty danych i przypadki ewaluacji ML.
  • 100test-writer
    Pisze testy jednostkowe dla dowolnej funkcji: ścieżka szczęśliwa, przypadki brzegowe i błędy, także w praktyce TDD.
  • 100pr-test-case-assistant
    Czyta publiczne pull requesty GitHub, przygotowuje krótki brief triage i pisze przypadki testowe funkcji na podstawie opisu i diffu PR.
  • 100test-harness
    Generuje zestawy testów pytest: ścieżkę szczęśliwą, przypadki brzegowe, błędy, fixtury, mocki i wzorce asynchroniczne.
  • 100dester-cases
    Pisze przypadki testowe dla systemu lub ekranu z opisu, w pięciu kategoriach, prostym językiem i z odniesieniem do wymagań.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.