# Writing a simple test plan for a small tool

URL: https://ekom.blog/writing-a-simple-test-plan-for-a-small-tool/
Published: 2026-07-08
Author: Ekom
Topics: Build with AI

> A one-page test plan for small tools: what to check before every release, how to use AI to draft it and how to keep it short enough that you will actually run it.

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:

- The happy path. The normal use. Open, enter data, get a result.

- The unhappy paths. What people do wrong or by accident: empty fields, letters in a number box, clicking twice, closing halfway.

- 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:

- Fix it.

- Re-run the whole plan, not just the failed check. Fixes break neighbours.

- 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:

- [ ] Main job works with normal input

- [ ] Empty input handled

- [ ] Wrong type of input handled (letters, symbols, negatives)

- [ ] Very large and very small values

- [ ] Long text and non-English characters

- [ ] Refresh and reopen behaviour

- [ ] Phone-sized screen

- [ ] Second browser

- [ ] Fresh profile, no saved data

- [ ] Failure of any outside service

- [ ] No keys, passwords or personal data visible in the page source or console

- [ ] Wording makes sense to someone who has never seen 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.

## Related reading

- Testing your AI-built tool with real users

- Logging: knowing what your tool did

- From prompt to product: building a tool people will pay for

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.

---

From Ekom (https://ekom.blog/). More: https://ekom.blog/llms.txt
