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