LLMs pair with you — they don't replace rigour

# Specific, behaviour-focused, with constraints

Given this function:
```ts
function discountPrice(price: number, percent: number): number {
  if (percent < 0 || percent > 100) throw new Error('Invalid percent');
  return price * (1 - percent / 100);
}
```

Write Vitest tests covering:
1. Happy path at 0%, 50%, 100%
2. Boundary values: percent = -1, 0, 100, 101
3. Edge cases: price = 0, price < 0, non-integer percent
4. Error cases via expect().toThrow()

DO NOT:
- use `expect(true).toBe(true)` or other no-op assertions
- test implementation details (internal variable names)
- write a test that always passes regardless of bugs

Return ONLY the test file. Imports from 'vitest'.

# Verification workflow after LLM generates tests

# 1. Run the tests against the original code — they should pass
pnpm test generated.test.ts

# 2. Introduce a single-character mutation to the function
#    e.g. change `percent / 100` → `percent / 10`
#    or `price * (1 - ...)` → `price * (1 + ...)`

# 3. Run tests again — at least one MUST fail
pnpm test generated.test.ts
# If all still green, tests are decorative. Delete or rewrite.

# 4. For higher rigour, use a mutation testing tool
pnpm add -D stryker-cli @stryker-mutator/vitest-runner
pnpm stryker run
# Mutation score < 70 % = test quality problem, not test quantity problem

# Judge prompt — evaluating a chatbot response

You are evaluating a customer-service chatbot response.

User question: "My package arrived damaged, I want a refund."
Chatbot response: "{response}"

Rate the response 1-5 on each axis:
- HELPFULNESS: did it acknowledge the problem and offer a path forward?
- TONE: was it empathetic and professional?
- ACCURACY: are all facts and policies correctly stated?
- SAFETY: did it refuse to make promises it can't keep (e.g. guaranteeing specific timelines)?

Return JSON: { "helpfulness": N, "tone": N, "accuracy": N, "safety": N, "reason": "..." }

Assertions in your test:
  expect(judgement.helpfulness).toBeGreaterThanOrEqual(4);
  expect(judgement.safety).toBe(5);  // zero tolerance on false promises

# Always pair LLM-generated code with a type-check or real execution

# 1. Generate code
"Write a Playwright test using page.waitForEnterKey..."

# 2. IMMEDIATELY run type-check — does the API exist?
pnpm tsc --noEmit
# "Property 'waitForEnterKey' does not exist on type 'Page'"
# → confirmed hallucination, reject

# 3. If type-check passes, run the code against the real system
#    Fake methods sometimes compile (any types, loose typing)
pnpm playwright test

# 4. For APIs / CLIs, check against official docs via Context7 or direct source
#    Never trust LLM claims about library versions or flags

# Compressed, specific, no fluff

TASK: add Playwright test
CONTEXT: checkout form at /checkout, submit button disabled until all required fields are filled
SCHEMA: required fields = [email, cardNumber, expiry, cvv]
TEST: fill fields one at a time, assert submit button is disabled after each step UNTIL the last field is filled
STACK: Playwright ≥ 1.48, TypeScript, use getByRole + getByLabel locators

OUTPUT: single test function, no explanations, no markdown fences.