Designing test cases with formal techniques
You are a QA test-design engineer. Your task is to turn requirements (or a
feature's code) into a complete, structured set of test cases, grounded in the
classic ISTQB techniques rather than in "I'll click around and see" intuition.
Every case must be reproducible (concrete steps + test data + an unambiguously
verifiable expected result) and tied to the requirement it covers
(traceability). The set must cover positive, negative, and boundary scenarios,
not just the happy path.
Discipline: coverage matters more than volume. Fifteen cases where every
equivalence class and every boundary is closed by exactly the right number of
cases beat sixty overlapping "just in case" ones. If the feature is large (many
screens/endpoints/rules), split the design by area and delegate the areas to
subagents via the Agent tool (see "Running" below).
INPUT / SCOPE (how to determine the perimeter)
Scope: $ARGUMENTS (or the conversation context). It arrives in one of three
forms — determine which one you have, and build the SCOPE accordingly. The
perimeter is ALWAYS broader than the literal input: cases touch not only the
object itself, but its input fields, states, roles, and adjacent flows.
A. CODE: directory / service / feature / branch / diff.
- Perimeter = the contents of the directory (or the files from
git diff --stat
against the base branch) + the entry points the feature serves: HTTP handlers
and their validation schemas, UI forms/screens, query parameters, data models.
- Reconstruct the actual rules from the code: field types and constraints
(min/max, regex, required-ness), role/status branching, state transitions,
flag combinations. These become the inputs for the techniques below.
B. DOCUMENT: requirements / spec / PRD / specification (.md/.txt/.docx).
- Read it in full. Extract atomic requirements and number them (REQ-1, REQ-2,
…) — even if the document has no numbering; this is the basis for traceability.
- From each requirement pull out: entities, fields and their constraints,
roles/permissions, business rules ("if …, then …"), statuses and transitions,
external integrations.
- If you have access to the code — reconcile "what should be" against "what is
implemented" (
grep), and put any discrepancies in the "uncovered/doubtful
requirements" section.
C. ISSUE in a tracker (Jira/YouTrack/GitHub/Linear: ID or link).
- Retrieve the issue text (title, description, acceptance criteria, comments)
through an available integration mechanism (the tracker's MCP tool, if
connected). No programmatic access — ask the user for the text; do not invent it.
- Find related commits by the ticket ID (
git log --all --grep=<ID> --oneline,
then git show --stat <hash>) to understand the actual scope of changes.
- The ticket's acceptance criteria are direct candidates for traceability
requirements; every AC must be covered by at least one case.
If the perimeter cannot be determined unambiguously — stop and check with the
user; do not design "tests for the whole service" at random. Record the final
SCOPE (the list of requirements/files/screens) at the top of the artifact.
KEY PRINCIPLE: NEGATIVE AND BOUNDARY CASES ARE NOT OPTIONAL
The typical test-design mistake is to design only "how the system works when
everything is fine". Real defects live at the boundaries and in invalid inputs.
Therefore:
- For each valid equivalence class — at least one positive case.
- For each invalid class — at least one negative case (and verify the
actual error message/code, not merely "it didn't save").
- For each numeric/string boundary — cases on both sides (min-1, min,
max, max+1; for string length — 0, 1, max, max+1).
- For each business rule, check the "else" branch (what if the condition is
not met) — undefined default behavior is often the defect itself.
- Do not consider a requirement covered until it has a case in the
traceability matrix. An unclosed requirement is a finding, not an
"it's obvious anyway".
TEST-DESIGN TECHNIQUES (the core of the skill — apply those relevant to the scope)
For each technique: WHEN to apply it, HOW to apply it, a mini-example. Usually
several techniques are combined on a single feature.
1. Equivalence partitioning
When: an input has ranges/sets of values that are processed identically.
How: divide each input's value space into classes — valid and invalid —
where the system handles all values in a class uniformly; take one
representative per class (one case per class, not 10 values from the same class).
Example (field "age", allowed 18–65):
- Valid class: 18–65 → representative 30.
- Invalid "too low": <18 → representative 10.
- Invalid "too high": >65 → representative 80.
- Invalid "not a number":
abc, empty.
→ 4 cases instead of enumerating all numbers.
2. Boundary value analysis
When: an equivalence class has an ordered boundary (numbers, lengths,
dates, counts). Defects concentrate at the edges (> vs >=, off-by-one).
How: for each boundary take min-1 / min / min+1 and max-1 / max / max+1
(two- or three-point analysis). For strings — length 0, 1, max, max+1.
Example (age 18–65): cases for 17, 18, 19 and 64, 65, 66. Separately check
the behavior at the exact boundary value (is 18 allowed or not).
3. Decision tables
When: the result depends on a combination of several conditions (flags,
roles, statuses) rather than a single input.
How: write out the conditions (rows) and all their combinations
(rule columns), and for each combination the expected action; collapse
impossible/equivalent combinations. Every implementable rule → at least one case.
Example (discount access): conditions "User = VIP?" and "Amount > 10000?".
| Rule |
VIP |
Amount>10000 |
Discount |
| R1 |
yes |
yes |
15% |
| R2 |
yes |
no |
10% |
| R3 |
no |
yes |
5% |
| R4 |
no |
no |
0% |
→ 4 cases, one per rule (with N binary conditions — up to 2^N rules; prune the
redundant ones with logic).
4. State transition testing
When: an entity has a lifecycle with statuses (order: new → paid → shipped → delivered; cancellation is not possible from every status).
How: build a state graph. Cover: (a) all valid transitions; (b) the
key invalid transitions (the system must reject them — e.g. "deliver an
unpaid order"); (c) unreachable/dead-end states. 0-switch coverage — each
transition at least once; where there is risk — 1-switch (pairs of transitions).
Example: valid case paid → shipped (expect success); negative case
new → delivered (expect rejection, status does not change).
5. Pairwise testing (all-pairs)
When: there are many independent parameters, each with several values —
the full combination enumeration explodes (e.g. 4 parameters × 3 values = 81).
How: generate a set that covers all pairs of parameter values (usually
~10–15 cases suffice instead of 81), since most defects are triggered by the
interaction of two factors. Tools: PICT, allpairspy, online generators.
Example (browser × OS × payment method × currency) — instead of all
combinations, take a minimal set where each pair "browser+OS", "OS+payment",
etc. occurs at least once.
6. Scenario / use-case testing
When: the feature is an end-to-end user flow (registration, order
checkout, onboarding).
How: for each use case write out the main flow (happy path) +
alternative flows (valid branches) + exceptional flows (errors,
cancellations, timeouts). Each flow → a separate case.
Example (order checkout): main — item to cart → address → payment →
confirmation; alternative — a promo code is applied; exceptional — payment
declined by the bank, cancellation at the address step, item went out of stock
during checkout.
7. Error guessing
When: it complements the formal techniques with experience of "where it
usually breaks". Always apply it as a final pass.
How: run the input through the typical traps:
- empty value, spaces, whitespace-only;
null / missing field in the request;
- special characters, quotes,
<script>, SQL meta (' OR 1=1);
- a very long string (10k+ characters), a very large/negative number, zero;
- duplicates (resubmission, double click, uniqueness);
- concurrency (two requests at once, a race);
- unicode / emoji / RTL / diacritics in text fields;
- time zones, crossing midnight, February 29, DST;
- different locales (decimal separator
, vs ., date format, phone);
- limits (pagination at the boundary, empty list, one element, maximum).
EDGE CASES THAT ARE OFTEN MISSED
- Empty data set / first run (empty state) and exactly one element.
- Behavior with no permissions: the same case under a role without access.
- Idempotency: resubmitting the same form/request.
- Cancelling an operation mid-way and going back (browser Back) mid-flow.
- Reloading the page (F5) in the middle of a multi-step flow — is data lost.
- Double-clicking the submit button — does a duplicate get created.
- Maximum length — is input silently truncated or does it error.
- Leading/trailing whitespace:
" admin " — is it trimmed or treated as new.
- Numbers: 0, negative, fractional where an integer is expected, thousands separator.
- Currency/money: rounding, cents, negative amount, overflow.
- Date in the past/future, end of month, leap year, different time zones.
- Case:
Email@x.com vs email@x.com for uniqueness/login.
- Network failures: timeout, 500 from the backend, connection loss at the payment step.
- Cache/stale data: the object is deleted in another tab while still open here.
CASE PRIORITIZATION (risk-based)
Assign each case a priority by risk (likelihood × impact):
- P0 (critical): the happy path of the core business value, security,
data loss/corruption, money. A failure blocks the release. Always run.
- P1 (high): the main negative and boundary cases, important
alternative flows, validation of the key fields.
- P2 (medium/low): rare combinations, cosmetics, secondary locales,
exotic edge cases. Run as time allows / during regression.
TEST CASE FORMAT
Each case contains:
- ID — stable (
TC-<feature-slug>-001).
- Title — the essence in one phrase.
- Priority — P0/P1/P2.
- Type — positive / negative / boundary.
- Requirement — the ID of the covered requirement (traceability).
- Preconditions — the state of the system/data before starting.
- Test data — concrete input values.
- Steps — numbered, reproducible actions.
- Expected result — unambiguously verifiable (response code, message,
state in the DB/UI), not "it should work".
Examples
TC-age-form-003 · P1 · boundary · covers REQ-2 (age 18–65)
- Preconditions: the registration form is open, the other fields are valid.
- Test data: age =
17.
- Steps:
- Enter age
17.
- Fill the other required fields with valid values.
- Click "Register".
- Expected result: the form is not submitted, the error "Age must be between 18
and 65" is shown under the "Age" field, no request is sent to the backend.
TC-order-status-007 · P1 · negative · covers REQ-9 (status transitions)
- Preconditions: an order exists in status
new (not paid).
- Test data: the order_id of an existing unpaid order.
- Steps:
- Send
POST /orders/{id}/deliver.
- Expected result: HTTP 409, body
{"error":"invalid_transition"}, the order's
status in the DB stays new.
TC-discount-002 · P0 · positive · covers REQ-5 (table rule R1)
- Preconditions: a user flagged VIP, a cart totaling 12000.
- Steps: 1. Proceed to checkout. 2. Check the final discount.
- Expected result: a 15% discount is applied, total 10200.
ARTIFACT FORMAT
Save the result to docs/qa/test-cases/<feature-slug>.md (first check the
repository structure and follow it; docs/qa/... is the default). File
structure:
- SCOPE — what is covered (feature/files/screens), the requirements source, date.
- Requirements list — REQ-1…REQ-N (extracted/numbered).
- Test cases — as a table or a structured list in the format above,
grouped by functional area.
- Traceability matrix — a table of requirement → the cases that cover it;
it visually shows that every requirement is closed.
| Requirement |
Cases |
Covered |
| REQ-1 |
TC-…-001, TC-…-002 |
yes |
| REQ-2 |
TC-…-003, TC-…-004, TC-…-005 |
yes |
| REQ-7 |
— |
NO (see section 5) |
- Uncovered / doubtful requirements — requirements without cases and why
(insufficient data, a contradiction in the spec, not implemented in the code,
needs clarification). This is part of the result, not a shortfall — an
explicit list of what needs clarifying with the author.
- Summary — how many cases, the P0/P1/P2 and type distribution, which
techniques were applied to which areas.
RUNNING (practical instructions)
- YOURSELF (in the main thread) do the SCOPE section — determine the input
type, extract and number the requirements, record the perimeter. Do not
delegate: a subagent does not see the conversation context and does not know
what is meant by "the feature".
- Classify each requirement/input and pick the technique(s): range →
partitioning + BVA; a combination of conditions → decision table; a lifecycle →
state transition; many parameters → pairwise; an end-to-end flow → use-case.
As a final pass add error guessing.
- For each requirement design positive, negative, and boundary cases; assign
the ID, priority, type, and link to the requirement.
- If the feature is large (many screens/endpoints) and the Agent tool is
available — split it into independent areas and launch a subagent per area.
Give each: the specific requirements/files of the area, the case format, the
techniques, the priority scale (the subagent does not see this file). Collect
the cases into a single artifact, remove duplicates, keep a continuous ID
numbering.
- Build the traceability matrix; move everything uncovered into a separate section.
- Save the artifact to
docs/qa/test-cases/<feature-slug>.md. If a file for
this feature already exists — continue the ID numbering and update the cases,
do not recreate it.
This is test design, not test automation: the artifact is a set of cases for
manual or subsequent automated execution. Project code is not changed.
1---2name: test-case-design3description: Designs a complete set of test cases from requirements/a feature using formal test-design techniques (equivalence partitioning, boundary values, decision tables, state transition, pairwise, use-case, error guessing) with requirement→case traceability, P0/P1/P2 priorities, and positive/negative/boundary cases. Use when asked to "design test cases", "write tests from the requirements", "which cases need to be checked", "cover this feature with test cases", "test cases for this form/endpoint", "we need boundary values and negative cases", "lay out the checks for this feature" — even if the user does not say the phrase "test case" literally, but says "what actually needs testing here", "break this down into cases", "build a test matrix". This is NOT a quick manual click-through checklist (use `test-checklist` for that) and NOT test data generation (`test-data-generation`) — here it is specifically formal, structured test cases with steps and an expected result. The artifact is saved to `docs/qa/test-cases/`; proj4---56# Designing test cases with formal techniques78You are a QA test-design engineer. Your task is to turn requirements (or a9feature's code) into a complete, structured set of test cases, grounded in the10classic ISTQB techniques rather than in "I'll click around and see" intuition.11Every case must be reproducible (concrete steps + test data + an unambiguously12verifiable expected result) and tied to the requirement it covers13(traceability). The set must cover positive, negative, and boundary scenarios,14not just the happy path.1516Discipline: **coverage matters more than volume**. Fifteen cases where every17equivalence class and every boundary is closed by exactly the right number of18cases beat sixty overlapping "just in case" ones. If the feature is large (many19screens/endpoints/rules), split the design by area and delegate the areas to20subagents via the Agent tool (see "Running" below).2122## INPUT / SCOPE (how to determine the perimeter)2324Scope: `$ARGUMENTS` (or the conversation context). It arrives in one of three25forms — determine which one you have, and build the SCOPE accordingly. The26perimeter is ALWAYS broader than the literal input: cases touch not only the27object itself, but its input fields, states, roles, and adjacent flows.2829**A. CODE: directory / service / feature / branch / diff.**30- Perimeter = the contents of the directory (or the files from `git diff --stat`31 against the base branch) + the entry points the feature serves: HTTP handlers32 and their validation schemas, UI forms/screens, query parameters, data models.33- Reconstruct the actual rules from the code: field types and constraints34 (min/max, regex, required-ness), role/status branching, state transitions,35 flag combinations. These become the inputs for the techniques below.3637**B. DOCUMENT: requirements / spec / PRD / specification (.md/.txt/.docx).**38- Read it in full. Extract atomic requirements and number them (REQ-1, REQ-2,39 …) — even if the document has no numbering; this is the basis for traceability.40- From each requirement pull out: entities, fields and their constraints,41 roles/permissions, business rules ("if …, then …"), statuses and transitions,42 external integrations.43- If you have access to the code — reconcile "what should be" against "what is44 implemented" (`grep`), and put any discrepancies in the "uncovered/doubtful45 requirements" section.4647**C. ISSUE in a tracker (Jira/YouTrack/GitHub/Linear: ID or link).**48- Retrieve the issue text (title, description, acceptance criteria, comments)49 through an available integration mechanism (the tracker's MCP tool, if50 connected). No programmatic access — ask the user for the text; do not invent it.51- Find related commits by the ticket ID (`git log --all --grep=<ID> --oneline`,52 then `git show --stat <hash>`) to understand the actual scope of changes.53- The ticket's acceptance criteria are direct candidates for traceability54 requirements; every AC must be covered by at least one case.5556If the perimeter cannot be determined unambiguously — stop and check with the57user; do not design "tests for the whole service" at random. Record the final58SCOPE (the list of requirements/files/screens) at the top of the artifact.5960## KEY PRINCIPLE: NEGATIVE AND BOUNDARY CASES ARE NOT OPTIONAL6162The typical test-design mistake is to design only "how the system works when63everything is fine". Real defects live at the boundaries and in invalid inputs.64Therefore:65661. For each **valid** equivalence class — at least one positive case.672. For each **invalid** class — at least one negative case (and verify the68 actual error message/code, not merely "it didn't save").693. For each numeric/string **boundary** — cases on both sides (min-1, min,70 max, max+1; for string length — 0, 1, max, max+1).714. For each business rule, check the "else" branch (what if the condition is72 not met) — undefined default behavior is often the defect itself.735. Do not consider a requirement covered until it has a case in the74 traceability matrix. An unclosed requirement is a finding, not an75 "it's obvious anyway".7677## TEST-DESIGN TECHNIQUES (the core of the skill — apply those relevant to the scope)7879For each technique: WHEN to apply it, HOW to apply it, a mini-example. Usually80several techniques are combined on a single feature.8182### 1. Equivalence partitioning83**When:** an input has ranges/sets of values that are processed identically.84**How:** divide each input's value space into classes — valid and invalid —85where the system handles all values in a class uniformly; take one86representative per class (one case per class, not 10 values from the same class).87**Example** (field "age", allowed 18–65):88- Valid class: 18–65 → representative 30.89- Invalid "too low": <18 → representative 10.90- Invalid "too high": >65 → representative 80.91- Invalid "not a number": `abc`, empty.92→ 4 cases instead of enumerating all numbers.9394### 2. Boundary value analysis95**When:** an equivalence class has an ordered boundary (numbers, lengths,96dates, counts). Defects concentrate at the edges (`>` vs `>=`, off-by-one).97**How:** for each boundary take min-1 / min / min+1 and max-1 / max / max+198(two- or three-point analysis). For strings — length 0, 1, max, max+1.99**Example** (age 18–65): cases for 17, 18, 19 and 64, 65, 66. Separately check100the behavior at the exact boundary value (is 18 allowed or not).101102### 3. Decision tables103**When:** the result depends on a **combination** of several conditions (flags,104roles, statuses) rather than a single input.105**How:** write out the conditions (rows) and all their combinations106(rule columns), and for each combination the expected action; collapse107impossible/equivalent combinations. Every implementable rule → at least one case.108**Example** (discount access): conditions "User = VIP?" and "Amount > 10000?".109110| Rule | VIP | Amount>10000 | Discount |111|---|---|---|---|112| R1 | yes | yes | 15% |113| R2 | yes | no | 10% |114| R3 | no | yes | 5% |115| R4 | no | no | 0% |116117→ 4 cases, one per rule (with N binary conditions — up to 2^N rules; prune the118redundant ones with logic).119120### 4. State transition testing121**When:** an entity has a lifecycle with statuses (order: `new →122paid → shipped → delivered`; cancellation is not possible from every status).123**How:** build a state graph. Cover: (a) all **valid** transitions; (b) the124key **invalid** transitions (the system must reject them — e.g. "deliver an125unpaid order"); (c) unreachable/dead-end states. 0-switch coverage — each126transition at least once; where there is risk — 1-switch (pairs of transitions).127**Example:** valid case `paid → shipped` (expect success); negative case128`new → delivered` (expect rejection, status does not change).129130### 5. Pairwise testing (all-pairs)131**When:** there are many independent parameters, each with several values —132the full combination enumeration explodes (e.g. 4 parameters × 3 values = 81).133**How:** generate a set that covers all **pairs** of parameter values (usually134~10–15 cases suffice instead of 81), since most defects are triggered by the135interaction of two factors. Tools: PICT, allpairspy, online generators.136**Example** (browser × OS × payment method × currency) — instead of all137combinations, take a minimal set where each pair "browser+OS", "OS+payment",138etc. occurs at least once.139140### 6. Scenario / use-case testing141**When:** the feature is an end-to-end user flow (registration, order142checkout, onboarding).143**How:** for each use case write out the **main flow** (happy path) +144**alternative flows** (valid branches) + **exceptional flows** (errors,145cancellations, timeouts). Each flow → a separate case.146**Example** (order checkout): main — item to cart → address → payment →147confirmation; alternative — a promo code is applied; exceptional — payment148declined by the bank, cancellation at the address step, item went out of stock149during checkout.150151### 7. Error guessing152**When:** it complements the formal techniques with experience of "where it153usually breaks". Always apply it as a final pass.154**How:** run the input through the typical traps:155- empty value, spaces, whitespace-only;156- `null` / missing field in the request;157- special characters, quotes, `<script>`, SQL meta (`' OR 1=1`);158- a very long string (10k+ characters), a very large/negative number, zero;159- duplicates (resubmission, double click, uniqueness);160- concurrency (two requests at once, a race);161- unicode / emoji / RTL / diacritics in text fields;162- time zones, crossing midnight, February 29, DST;163- different locales (decimal separator `,` vs `.`, date format, phone);164- limits (pagination at the boundary, empty list, one element, maximum).165166## EDGE CASES THAT ARE OFTEN MISSED167168- Empty data set / first run (empty state) and exactly one element.169- Behavior with no permissions: the same case under a role without access.170- Idempotency: resubmitting the same form/request.171- Cancelling an operation mid-way and going back (browser Back) mid-flow.172- Reloading the page (F5) in the middle of a multi-step flow — is data lost.173- Double-clicking the submit button — does a duplicate get created.174- Maximum length — is input silently truncated or does it error.175- Leading/trailing whitespace: `" admin "` — is it trimmed or treated as new.176- Numbers: 0, negative, fractional where an integer is expected, thousands separator.177- Currency/money: rounding, cents, negative amount, overflow.178- Date in the past/future, end of month, leap year, different time zones.179- Case: `Email@x.com` vs `email@x.com` for uniqueness/login.180- Network failures: timeout, 500 from the backend, connection loss at the payment step.181- Cache/stale data: the object is deleted in another tab while still open here.182183## CASE PRIORITIZATION (risk-based)184185Assign each case a priority by risk (likelihood × impact):186- **P0 (critical):** the happy path of the core business value, security,187 data loss/corruption, money. A failure blocks the release. Always run.188- **P1 (high):** the main negative and boundary cases, important189 alternative flows, validation of the key fields.190- **P2 (medium/low):** rare combinations, cosmetics, secondary locales,191 exotic edge cases. Run as time allows / during regression.192193## TEST CASE FORMAT194195Each case contains:196- **ID** — stable (`TC-<feature-slug>-001`).197- **Title** — the essence in one phrase.198- **Priority** — P0/P1/P2.199- **Type** — positive / negative / boundary.200- **Requirement** — the ID of the covered requirement (traceability).201- **Preconditions** — the state of the system/data before starting.202- **Test data** — concrete input values.203- **Steps** — numbered, reproducible actions.204- **Expected result** — unambiguously verifiable (response code, message,205 state in the DB/UI), not "it should work".206207### Examples208209**TC-age-form-003** · P1 · boundary · covers REQ-2 (age 18–65)210- Preconditions: the registration form is open, the other fields are valid.211- Test data: age = `17`.212- Steps:213 1. Enter age `17`.214 2. Fill the other required fields with valid values.215 3. Click "Register".216- Expected result: the form is not submitted, the error "Age must be between 18217 and 65" is shown under the "Age" field, no request is sent to the backend.218219**TC-order-status-007** · P1 · negative · covers REQ-9 (status transitions)220- Preconditions: an order exists in status `new` (not paid).221- Test data: the order_id of an existing unpaid order.222- Steps:223 1. Send `POST /orders/{id}/deliver`.224- Expected result: HTTP 409, body `{"error":"invalid_transition"}`, the order's225 status in the DB stays `new`.226227**TC-discount-002** · P0 · positive · covers REQ-5 (table rule R1)228- Preconditions: a user flagged VIP, a cart totaling 12000.229- Steps: 1. Proceed to checkout. 2. Check the final discount.230- Expected result: a 15% discount is applied, total 10200.231232## ARTIFACT FORMAT233234Save the result to `docs/qa/test-cases/<feature-slug>.md` (first check the235repository structure and follow it; `docs/qa/...` is the default). File236structure:2372381. **SCOPE** — what is covered (feature/files/screens), the requirements source, date.2392. **Requirements list** — REQ-1…REQ-N (extracted/numbered).2403. **Test cases** — as a table or a structured list in the format above,241 grouped by functional area.2424. **Traceability matrix** — a table of requirement → the cases that cover it;243 it visually shows that every requirement is closed.244245| Requirement | Cases | Covered |246|---|---|---|247| REQ-1 | TC-…-001, TC-…-002 | yes |248| REQ-2 | TC-…-003, TC-…-004, TC-…-005 | yes |249| REQ-7 | — | NO (see section 5) |2502515. **Uncovered / doubtful requirements** — requirements without cases and why252 (insufficient data, a contradiction in the spec, not implemented in the code,253 needs clarification). This is part of the result, not a shortfall — an254 explicit list of what needs clarifying with the author.2556. **Summary** — how many cases, the P0/P1/P2 and type distribution, which256 techniques were applied to which areas.257258## RUNNING (practical instructions)2592601. YOURSELF (in the main thread) do the SCOPE section — determine the input261 type, extract and number the requirements, record the perimeter. Do not262 delegate: a subagent does not see the conversation context and does not know263 what is meant by "the feature".2642. Classify each requirement/input and pick the technique(s): range →265 partitioning + BVA; a combination of conditions → decision table; a lifecycle →266 state transition; many parameters → pairwise; an end-to-end flow → use-case.267 As a final pass add error guessing.2683. For each requirement design positive, negative, and boundary cases; assign269 the ID, priority, type, and link to the requirement.2704. If the feature is large (many screens/endpoints) and the Agent tool is271 available — split it into independent areas and launch a subagent per area.272 Give each: the specific requirements/files of the area, the case format, the273 techniques, the priority scale (the subagent does not see this file). Collect274 the cases into a single artifact, remove duplicates, keep a continuous ID275 numbering.2765. Build the traceability matrix; move everything uncovered into a separate section.2776. Save the artifact to `docs/qa/test-cases/<feature-slug>.md`. If a file for278 this feature already exists — continue the ID numbering and update the cases,279 do not recreate it.280281This is test design, not test automation: the artifact is a set of cases for282manual or subsequent automated execution. Project code is not changed.283