Writing Unit Tests Using AI Prompts

AI can write a unit test for almost any function in seconds. The catch is that, without guidance, it tends to write only the happy-path tests — the ones that prove nothing. A good prompt forces the AI to think about edge cases, error paths, and the behaviours that actually matter.

1. Introduction

Unit tests are one of the highest-leverage things AI can do for you as a developer. The patterns are repetitive, the boilerplate is verbose, and the cognitive cost of writing them is exactly what makes most teams skip them. AI removes that friction — but only if you steer it towards meaningful coverage instead of test-padding.

This tutorial gives you a prompt pattern based on the classic Arrange-Act-Assert structure, with explicit prompts for the edge cases AI tends to forget.

2. The Concept Explained

A unit test has three jobs: set up the world, call the thing under test, and verify what happened. That is the Arrange-Act-Assert pattern, and every solid test framework speaks it natively. When you prompt AI for tests, mirroring this structure in your instructions produces tests that read clearly and exercise the right boundaries.

Think of it like restaurant inspection: you set the table the way a customer would, ask the chef to cook, and check whether the dish is what was ordered. A bad inspector only orders the bestseller; a good one orders the spicy dish, the gluten-free request, and the one the chef is most likely to overcook.

3. The Problem Without This Technique

Without a structured prompt, AI generates one test that proves the function does something — usually the happy path — and stops there. That is worse than no test, because it lulls you into a false sense of safety.

write a unit test for this function

function divide(a, b) {
  return a / b;
}

4. The Solution

Test framework: Jest 29 with TypeScript
File under test: src/utils/divide.ts

```ts
export function divide(a: number, b: number): number {
  if (b === 0) throw new Error("Cannot divide by zero");
  return a / b;
}
```

Write a complete test suite using Arrange-Act-Assert.

Cover:
1. Happy path: positive integers, two cases including a non-evenly-dividing pair
2. Edge cases: zero numerator, negative numbers, floating-point precision
3. Error path: dividing by zero must throw with the exact error message
4. Type safety: ensure the return type is number

Use describe() per behaviour and it() per case. Each test should be one
clear arrange, act, assert. No setup/teardown unless required.

Output only the test file. No commentary.

5. Step-by-Step Breakdown

1. State the framework and version. Jest, Vitest, pytest, JUnit — they all have slightly different idioms. Naming the version avoids deprecated APIs.
2. Paste the exact code under test. Type signatures matter — they often imply behaviour the AI would otherwise have to guess.
3. List the kinds of coverage explicitly. Happy path, edge cases, error paths, and any domain-specific concerns. Numbering them prevents the AI from skipping.
4. Demand the AAA structure by name. Saying "use Arrange-Act-Assert" tells the AI to keep each test surgical and readable.
5. Request one behaviour per test case. This produces small, debuggable failures — not giant tests that fail for unclear reasons.
6. Tell it what to leave out. "No commentary, no setup unless needed" prevents bloated output.

Tip: After the AI writes the tests, ask a follow-up:

What behaviours of this function are NOT covered by these tests?

The answer is often more useful than the tests themselves.

6. Practice Exercises

7. Key Takeaways