Blog / Build with AI /

Writing a simple test plan for a small tool

You’ve built a small tool with AI. It works on your machine, with your data, when you click things in the order you expected. You’re ready to share it.

Then someone enters a negative number, or pastes in a very long name, or opens it on a phone, and it falls over.

A test plan sounds like something from a large company. For a small tool, it is one page: a list of things to check before you release, written down so you don’t depend on memory. This post shows how to build that page in about half an hour.

What a test plan is (and isn’t)

A test plan answers one question: what has to work before I let anyone else use this?

It is not a document for managers. It’s a checklist you can run in ten minutes. If it takes an hour, you will skip it, and a skipped plan is worth nothing.

Automated tests (code that tests your code) are great, and you can ask AI to write them. I covered that in prompting for tests along with the code. But even if you have them, a short manual plan still catches what code tests miss: confusing wording, awkward layouts, flows that work but feel wrong.

Step 1: write down what the tool is for

Start with the main job, in one sentence. For example:

The tool takes a bill total and a list of names and shows what each person owes.

Everything on your plan should connect back to that sentence. If a check doesn’t protect the main job, it can wait.

Step 2: list the paths people take

Think in journeys, not features. Write three groups:

  1. The happy path. The normal use. Open, enter data, get a result.
  2. The unhappy paths. What people do wrong or by accident: empty fields, letters in a number box, clicking twice, closing halfway.
  3. The edge cases. Unusual but valid: a very large number, one person only, a name with an accent or Arabic script, an extremely long text.

Most bugs live in groups two and three. AI-written code tends to handle the happy path well, because that is what you described in your prompt.

Step 3: ask AI to draft the list, then edit it

This is where AI saves real time. Give it the one-sentence purpose and a short description of the screens, and ask:

Here’s what my tool does and its screens. List the test cases I should run manually before release, grouped as normal use, mistakes users might make and unusual-but-valid input. Keep each case to one line and make it checkable.

You’ll get a long list. Don’t paste it in whole. Edit hard:

  • Delete cases for features you don’t have.
  • Merge duplicates.
  • Keep the ones that would embarrass you if they failed.
  • Add anything specific to your users that the model couldn’t know.

Aim for 15 to 25 checks. More than that and it turns into a chore.

Step 4: write each check so a stranger could run it

A check like “test the form” is useless. A good one says what to do and what you should see:

Check Steps Expected result
Empty input Click “Calculate” with nothing entered A clear message, no crash
Negative number Enter -50 as the total Message asking for a positive amount
Decimal values Enter 99.99 split three ways Totals add up to 99.99
Long name Paste 200 characters as a name Layout doesn’t break
Reload Refresh after entering data Behaviour matches what the tool promises

Notice the last column. Without an expected result you can’t fail a check, so you can’t pass one either.

Step 5: test where people actually use it

Most small tools are tested only on the builder’s own screen. Add an environment section to the plan:

  • A phone-sized screen. Your browser’s developer tools can simulate one, but a real phone is better if you have one nearby.
  • A second browser. Something other than your usual one.
  • A slow connection. Developer tools can throttle the network. A tool that behaves oddly on a poor connection will frustrate a large share of real users in many countries.
  • A fresh start. Open it in a private window or new browser profile, with no saved data. Your own saved settings can hide first-run bugs.
  • Keyboard only, if the tool has forms. Can you reach every control with the Tab key?

For a browser extension, add: install fresh, update from the previous version, and check what happens with the permissions prompt. Debugging a Chrome extension: the tools that help covers the basics.

Step 6: add a “money and data” section

Some failures cost more than others. Mark any check that involves:

  • Maths people rely on (totals, tax, conversions)
  • Personal data (what is stored, and where)
  • Anything that costs you money, such as calls to a paid API

For the last one, test what happens when the API is down or returns rubbish, because error handling is the part AI-generated code most often leaves thin.

Step 7: run it, record it, improve it

Run the plan and mark each check pass or fail with a date. A simple spreadsheet works. When something fails:

  1. Fix it.
  2. Re-run the whole plan, not just the failed check. Fixes break neighbours.
  3. If a bug reached a user without your plan catching it, add a check for it. This is how the plan gets better over time.

That last habit is the real value. After a few releases, your plan reflects the real ways your tool has failed, which is more useful than any generic list.

Keeping it small

A plan survives if it stays quick. Some rules of thumb:

  • If a check never fails and never matters, drop it.
  • If you run the plan and feel resentful, it’s too long.
  • Split it into a quick set (five minutes, for tiny changes) and a full set (for releases).
  • Keep it in the same repository as the code, so it travels with the project.

A starter you can copy

Paste this into your notes and adapt it:

Key takeaways

  • A test plan is a short list answering “what must work before release?”
  • Write by journey: happy, mistaken and unusual.
  • Use AI to draft, then cut it hard to 15 to 25 checks.
  • Each check needs steps and an expected result.
  • Every bug that escapes becomes a new check.

Next step: take the tool you are working on today, write its one-sentence purpose, and draft ten checks. Then run them before your next release.