AI Prompts for Writing Better Website Test Cases
How AI Can Help With Website Test Cases
Writing good website test cases takes more than listing a few obvious actions.
A tester needs to think about:
- successful user journeys;
- validation;
- failure states;
- boundary conditions;
- browsers;
- devices;
- permissions;
- integrations;
- accessibility;
- data;
- regression risk.
AI can help generate, organize, and challenge these ideas.
Used well, it can reduce the time spent staring at a requirement and asking:
What else should I test?
But AI should support the QA process rather than replace it.
The tester still needs to decide:
- whether a scenario is relevant;
- whether the requirement was interpreted correctly;
- which risks matter;
- which cases deserve execution;
- whether the actual website behaves correctly.
For the broader role of AI in testing, see How to Use AI for Website QA Without Replacing Human Testing.
What Makes an AI Prompt Useful for QA?
A vague prompt usually produces vague test cases.
For example:
Write tests for a checkout page.
The AI has to guess:
- what payment methods exist;
- whether guest checkout is supported;
- whether coupons exist;
- which countries are supported;
- whether tax is calculated;
- what devices matter.
A stronger prompt provides context.
For example:
Create functional test scenarios for a B2C e-commerce checkout. The store supports guest checkout, registered users, coupon codes, standard and express shipping, VAT, Stripe card payments, and mobile Safari. Focus on high-risk positive, negative, and boundary scenarios. Do not invent features not listed.
This gives AI:
context + scope + constraints + expected output
That usually produces much better QA material.
The Basic Structure of a Good QA Prompt
A practical AI prompt can include five parts:
1. Feature
What are you testing?
Example:
Password reset flow.
2. Context
How does the feature work?
Example:
Users request a reset email, open a tokenized link, choose a new password, and then log in.
3. Scope
What kind of testing do you want?
Example:
Functional and negative testing only.
4. Constraints
What should AI avoid?
Example:
Do not include penetration testing or features not described.
5. Output
How should the results be structured?
Example:
Return test cases with Preconditions, Steps, Expected Result, Priority, and Risk.
This structure can be reused across almost any website project.
Prompt 1: Turn a Requirement Into Test Cases
This is one of the most useful starting prompts.
I am testing the following website requirement:
[PASTE REQUIREMENT]
Convert it into practical manual QA test cases.
For each test case include:
- Test Case Title
- Preconditions
- Steps
- Expected Result
- Priority
Include positive, negative, and boundary scenarios.
Do not invent functionality that is not stated in the requirement.
List any assumptions separately.
This is particularly useful when requirements are written as short acceptance criteria.
Example: Contact Form Requirement
Suppose the requirement says:
The Contact form contains Name, Email, Phone and Message. Name, Email and Message are required. After a successful submission, the user should see a confirmation message and the enquiry should be sent to the support inbox.
AI may suggest cases such as:
- valid submission;
- missing Name;
- missing Email;
- missing Message;
- invalid email;
- optional Phone empty;
- confirmation message;
- email delivery.
The tester then reviews whether these cases match the actual product.
AI creates the draft.
QA validates the coverage.
Prompt 2: Generate Positive Test Cases
Sometimes you want to isolate the expected successful paths.
Use:
Generate positive manual test cases for the following website feature:
[FEATURE DESCRIPTION]
Focus only on valid user behavior and successful workflows.
Include:
- normal user journey;
- supported variations;
- successful completion;
- expected confirmation state.
Do not include negative or security testing.
This can be useful when building the basic happy-path regression suite.
Prompt 3: Generate Negative Test Cases
Negative testing asks:
What happens when the user does something invalid or the system cannot complete the expected action?
Prompt:
Generate negative QA scenarios for:
[FEATURE]
Consider:
- missing required data;
- invalid formats;
- unsupported values;
- failed requests;
- repeated actions;
- expired states;
- incorrect user state.
Prioritize realistic user and system failures.
Do not include destructive security attacks.
This is useful for forms, authentication, checkout, and integrations.
Prompt 4: Find Boundary Cases
Boundary defects are common.
If a field allows a maximum of 100 characters, useful values include:
99, 100, 101
Prompt:
Identify boundary-value test cases for this requirement:
[REQUIREMENT]
For every numeric, date, quantity, length, or threshold rule, identify:
- just below the boundary;
- exactly at the boundary;
- just above the boundary.
Explain why each boundary matters.
This works especially well for:
- quantity limits;
- coupons;
- shipping thresholds;
- passwords;
- upload sizes;
- character limits.
Prompt 5: Challenge Existing Test Coverage
One of the best uses of AI is reviewing a test set you already created.
Instead of asking AI to start from zero, ask it to find gaps.
Here is my current QA coverage:
[PASTE TEST CASES]
Review it as a senior website QA tester.
Identify the most important missing scenarios.
Do not repeat anything already covered.
Rank missing scenarios by:
- business impact;
- likelihood of failure;
- user impact.
Return only the highest-value gaps.
This can be more useful than asking for another 50 generic test cases.
Prompt 6: Prioritize Test Cases by Risk
Not every test case deserves the same priority.
Use:
Review these website test cases:
[PASTE TEST CASES]
Classify them as:
- Critical
- High
- Medium
- Low
Base the ranking on:
- business impact;
- user frequency;
- likelihood of regression;
- data or financial impact;
- dependency on external systems.
Explain each Critical and High classification briefly.
This helps turn a large test list into a more practical execution order.
For broader planning, see How to Define QA Scope for a Website Project.
Prompt 7: Build Test Cases From a User Journey
Sometimes it is more useful to start with the real user journey rather than isolated requirements.
Prompt:
Build manual QA scenarios for this user journey:
[USER JOURNEY]
Example format:
Homepage → Pricing → Signup → Email Verification → Login
Include:
- successful journey;
- failure at each major step;
- state transitions;
- navigation issues;
- retry behavior;
- mobile considerations.
Prioritize scenarios that could stop the user from completing the journey.
This helps QA stay focused on actual outcomes.
Prompt 8: Create Authentication Test Cases
Authentication has many states that can easily be overlooked.
Use:
Generate manual QA test cases for an authentication flow containing:
- signup;
- email verification;
- login;
- logout;
- password reset.
Include:
- valid flows;
- invalid credentials;
- duplicate accounts;
- expired links;
- reused reset links;
- session behavior;
- error states;
- mobile behavior.
Do not include penetration testing.
Separate functional tests from security sanity checks.
For a complete authentication framework, see How to Test Login, Signup and Password Reset Flows.
Prompt 9: Create E-commerce Checkout Test Cases
Checkout contains many interacting rules.
Prompt:
Generate high-risk manual QA test cases for an e-commerce checkout with:
- guest checkout;
- registered users;
- coupons;
- shipping options;
- taxes;
- card payments;
- order confirmation.
Cover:
- happy path;
- validation;
- failed payment;
- retry;
- duplicate submission;
- shipping thresholds;
- pricing consistency;
- mobile checkout.
Group the scenarios by checkout stage.
For deeper checkout coverage, see How to Test an E-commerce Checkout Flow.
Prompt 10: Generate WordPress Regression Tests
WordPress projects often depend on themes, plugins, forms, caching, and configuration.
Prompt:
Create a focused WordPress regression checklist after this change:
[PLUGIN/THEME/WORDPRESS CHANGE]
Identify:
- directly affected functionality;
- dependent functionality;
- high-risk regression areas;
- responsive checks;
- browser checks;
- production smoke tests.
Do not recommend retesting the entire website unless the change justifies it.
For plugin-specific QA, see How to Test a WordPress Website After Plugin Updates.
Prompt 11: Generate SaaS Test Cases
SaaS testing often requires state and permission coverage.
Use:
Generate manual test scenarios for this SaaS feature:
[FEATURE DESCRIPTION]
Consider:
- user roles;
- create/read/update/delete behavior;
- data persistence;
- permissions;
- empty states;
- validation;
- session behavior;
- multiple tabs;
- integrations.
Separate core regression cases from lower-priority edge cases.
For broader SaaS coverage, see SaaS QA Checklist: What to Test in a Web Application.
Prompt 12: Generate Browser-Specific Test Ideas
Cross-browser QA can also benefit from AI-assisted planning.
Prompt:
I need browser compatibility test ideas for this feature:
[FEATURE]
Supported environments:
- Chrome / Windows
- Safari / iPhone
- Edge / Windows
- Firefox / Windows
Identify browser-sensitive behavior worth checking.
Do not invent known bugs.
Separate:
- general cross-browser checks;
- Safari/mobile-specific risks;
- responsive checks.
The wording “do not invent known bugs” matters.
AI should suggest areas to inspect, not claim that a browser definitely has a defect.
For broader guidance, see Cross-Browser Testing Guide: How to Test Websites Across Browsers.
Prompt 13: Review a Browser and Device Matrix
If you already have a matrix:
Review this browser/device test matrix:
[PASTE MATRIX]
Product type:
[MARKETING / E-COMMERCE / SAAS / OTHER]
Audience data:
[OPTIONAL ANALYTICS]
Identify:
- missing high-value environments;
- unnecessary duplication;
- environments that deserve deeper coverage.
Explain recommendations using user traffic and business risk.
For building the matrix itself, see Browser and Device Test Matrix: How to Choose What to Test.
Prompt 14: Generate Accessibility Test Cases
AI can help structure accessibility coverage.
Use:
Generate practical manual accessibility QA scenarios for:
[PAGE OR COMPONENT]
Cover:
- keyboard navigation;
- visible focus;
- focus order;
- form labels;
- validation errors;
- zoom/reflow;
- color-independent communication;
- mobile interaction.
Separate:
- automated checks;
- manual checks.
Do not claim WCAG compliance.
That last line is important.
AI-generated checks are not evidence of conformance.
For deeper coverage, see Website Accessibility Testing Checklist: A Practical QA Guide.
Prompt 15: Generate Security Sanity Checks
Security prompts require careful scope.
For routine QA, use:
Generate basic security sanity test cases for this website feature:
[FEATURE]
Limit coverage to:
- authentication;
- authorization;
- protected routes;
- session behavior;
- sensitive-data exposure;
- error handling;
- production configuration.
Do not include exploit instructions, penetration-testing techniques, or destructive testing.
This keeps the output aligned with routine website QA.
For the distinction between standard security checks and deeper specialist work, see Security Testing vs Penetration Testing: What’s the Difference?.
Prompt 16: Convert Bugs Into Regression Test Cases
A fixed defect can become useful regression coverage.
Prompt:
Convert this confirmed bug into one or more regression test cases:
[PASTE BUG REPORT]
Preserve the original failure condition.
Include:
- setup;
- reproduction scenario;
- expected result after the fix;
- related regression areas worth checking.
Do not invent details missing from the bug report.
This helps QA turn production or staging defects into permanent learning.
For defect structure, see Bug Report Template: What Every Defect Report Should Include.
Prompt 17: Simplify a Large Test Suite
Sometimes AI produces too much.
Use:
Here are 75 test cases:
[PASTE TEST CASES]
Reduce them to the smallest useful regression suite that still covers:
- critical user journeys;
- high-risk validation;
- major failure states;
- recent regression risks.
Remove duplicates and low-value variations.
Explain which scenarios were consolidated.
This is a valuable prompt because more test cases do not automatically mean better QA.
Prompt 18: Find Duplicate Test Cases
Use:
Review these test cases for duplication:
[PASTE CASES]
Identify:
- exact duplicates;
- scenarios testing the same underlying behavior;
- cases that can be combined without reducing meaningful coverage.
Return:
Original Cases → Recommended Consolidated Case.
This can make a growing regression suite much easier to maintain.
Prompt 19: Improve Test Case Wording
A test may be valid but poorly written.
Prompt:
Rewrite these test cases so another tester can execute them without additional explanation:
[PASTE CASES]
Improve:
- title clarity;
- preconditions;
- steps;
- expected result.
Preserve all facts.
Do not invent missing product behavior.
This is one of the safest and most effective uses of AI.
Prompt 20: Separate Preconditions From Steps
Poorly written cases often mix setup and execution.
Use:
Review this test case:
[TEST CASE]
Separate:
- Preconditions
- Test Data
- Steps
- Expected Result
Remove redundant steps but preserve the original meaning.
This makes test cases easier to execute and maintain.
Prompt 21: Create Exploratory Testing Charters
Not every QA activity needs detailed scripted cases.
AI can also help with exploratory testing.
Prompt:
Create five exploratory testing charters for:
[FEATURE]
Each charter should include:
- mission;
- risk area;
- test ideas;
- evidence to capture.
Focus on different perspectives rather than repeating the same workflow.
This can help testers move beyond rigid scripts.
Prompt 22: Ask AI What You Forgot
A very simple but powerful prompt is:
Assume my current test coverage is technically correct.
What important categories of risk have I not considered?
Do not generate dozens of individual test cases.
Identify only the major missing dimensions.
Possible gaps may include:
- permissions;
- mobile;
- state persistence;
- integrations;
- accessibility;
- error handling.
This can act as a final planning review.
Prompt 23: Generate Test Cases From Acceptance Criteria
If a development ticket contains acceptance criteria:
These are the acceptance criteria:
[PASTE CRITERIA]
Create manual QA scenarios that map directly to each criterion.
Label each scenario with the acceptance criterion it validates.
Then identify any important risk scenarios not explicitly covered by the criteria.
Keep requirement-based cases separate from suggested exploratory cases.
This makes traceability much clearer.
Prompt 24: Create Smoke Test Cases
For fast post-deployment verification:
Create a focused smoke test for this release:
Changed areas:
[CHANGES]
Critical user journeys:
[JOURNEYS]
Limit the suite to checks required to determine whether the release is fundamentally operational.
Do not turn it into a full regression suite.
For post-release execution, see Post-Deployment Smoke Testing: What to Check After Release.
Prompt 25: Create Release-Specific Regression Coverage
This is useful when you already have a baseline suite.
Existing regression baseline:
[BASELINE]
Changes in this release:
[CHANGE LIST]
Identify additional release-specific tests that should be added.
Do not duplicate baseline coverage.
Focus on:
- directly changed areas;
- dependencies;
- high-risk regression paths.
This creates a practical model:
Baseline Regression + Change-Specific Testing
Give AI the Actual Product Context
AI produces better test ideas when it understands the website.
Useful information may include:
- project type;
- audience;
- user roles;
- supported browsers;
- important integrations;
- business-critical workflows;
- requirements;
- known limitations.
For example:
This is a B2B SaaS application primarily used on Chrome and Edge desktop. Users have Admin and Agent roles. The feature allows agents to assign contacts to owners and tags.
That is much more useful than:
Test this dropdown.
Tell AI What Is Out of Scope
Explicit exclusions improve output.
Examples:
Do not include performance testing.
Do not include penetration testing.
Do not include unsupported browsers.
Do not invent API behavior.
Do not include automated tests.
This prevents the AI from expanding the test scope unnecessarily.
For broader scope planning, see How to Define QA Scope for a Website Project.
Ask AI to Separate Facts From Assumptions
One of the most important prompt instructions is:
Do not treat missing information as fact. List assumptions separately.
Without this, AI may fill gaps with plausible but unsupported behavior.
For example, it might assume:
- password links expire after 30 minutes;
- a checkout supports guest users;
- a field allows 255 characters.
These may sound reasonable.
They may also be wrong.
Use Placeholders for Missing Information
If important information is unavailable, tell AI to use placeholders.
Example:
If browser version is unknown, write
[Browser version required]instead of inventing one.
This is especially useful when generating:
- test cases;
- bug reports;
- QA reports.
Ask for Risk, Not Just Volume
Avoid:
Generate 100 test cases.
Prefer:
Generate the 15 highest-risk test cases.
The second prompt forces prioritization.
A hundred generic cases can create more maintenance than value.
Do Not Publish AI-Generated Tests Without Review
AI output can contain:
- duplicate scenarios;
- irrelevant cases;
- unsupported assumptions;
- inaccurate expected results.
Every generated test should be reviewed by someone who understands the product.
The correct workflow is:
AI Draft → Human Review → Approved Test Coverage
not:
AI Draft → Immediate Execution
Test Cases Should Be Based on Requirements
AI should not become the source of product truth.
Requirements may come from:
- tickets;
- specifications;
- acceptance criteria;
- design;
- existing product behavior;
- business rules.
AI can help interpret and expand them.
It should not silently redefine them.
Separate Requirement Tests From Exploratory Ideas
This distinction is useful.
Requirement-Based Case
Verifies documented expected behavior.
Exploratory Scenario
Investigates potential risk beyond the explicit requirement.
Both are valuable.
But they are not the same thing.
Ask AI to label them separately.
Do Not Let AI Invent Expected Results
Suppose the requirement says:
User can cancel their subscription.
AI should not automatically decide:
Access remains active until the end of the billing period.
That may be common.
It is still an assumption unless the product requirement says so.
Use:
Expected result: [Confirm cancellation behavior]
until the business rule is known.
Use AI to Improve Test Case Quality
A strong manual test case usually has:
Clear Title
Relevant Preconditions
Minimal Reproduction Steps
Specific Expected Result
AI can help improve all four.
But the tester should confirm that the expected result reflects reality.
Avoid Over-Specifying Simple Test Cases
Not every test needs 15 steps.
Example:
Poor:
- Open browser.
- Type URL.
- Press Enter.
- Wait for page.
- Find Login.
- Click Login.
Better:
- Open the Login page.
- Enter valid credentials.
- Submit the form.
Write only the detail necessary for reproducibility.
You can explicitly tell AI:
Remove steps that do not add testing value.
Include Test Data Only When It Matters
For example:
Email: qa-test@example.com
may be useful.
But hard-coding unnecessary test data can make cases harder to reuse.
Ask AI to separate:
- required test data;
- example data.
AI Can Help With Test Case Maintenance
As the product evolves, old test cases become outdated.
AI can help compare:
- previous requirement;
- new requirement;
- current test suite.
Prompt:
Compare this old requirement, new requirement, and current tests.
Identify which tests should be:
- kept;
- updated;
- removed;
- added.
This can save time during large product changes.
AI Can Help Turn Production Bugs Into Better Coverage
When a defect escapes to production, ask:
What testing gap allowed this defect to escape?
Then use AI to suggest:
- regression cases;
- related scenarios;
- additional environments;
- boundary tests.
Do not use this to blame testers.
Use it to improve the QA system.
A Practical AI-Assisted Test Case Workflow
A reliable process can look like:
Step 1 — Define Scope
Human identifies what should be tested.
Step 2 — Provide Requirements
Give AI verified product information.
Step 3 — Generate Candidate Scenarios
AI helps brainstorm coverage.
Step 4 — Review Assumptions
Human removes unsupported ideas.
Step 5 — Prioritize by Risk
Keep the highest-value scenarios.
Step 6 — Execute on the Real Website
Actual browsers and devices remain the source of evidence.
Step 7 — Convert Important Bugs Into Regression Tests
The suite improves over time.
This combines AI speed with human judgment.
A Reusable Master Prompt
You can use this as a starting template for many website features:
You are helping me plan manual website QA.
Feature:
[FEATURE]
Requirements:
[REQUIREMENTS]
User roles:
[ROLES]
Supported browsers/devices:
[ENVIRONMENTS]
Critical user journey:
[JOURNEY]
Generate practical test cases covering:
- happy path;
- negative cases;
- boundary conditions;
- state changes;
- error handling;
- relevant browser/mobile risks.
For each case include:
- Title
- Preconditions
- Steps
- Expected Result
- Priority
- Risk Area
Rules:
- Do not invent features.
- Do not invent expected behavior.
- List assumptions separately.
- Do not duplicate scenarios.
- Prioritize business-critical coverage.
- Keep the test cases concise and executable.
This is a much stronger starting point than:
Write tests for this page.
A Quick AI Prompt Checklist
Before submitting a QA prompt, ask:
- Did I explain what the feature does?
- Did I provide the relevant requirements?
- Did I define the user role?
- Did I define important environments?
- Did I identify the critical user journey?
- Did I define the type of testing I want?
- Did I state what is out of scope?
- Did I tell AI not to invent missing behavior?
- Did I request assumptions separately?
- Did I ask for useful structure?
- Did I prioritize risk over volume?
If most of these are clear, the output will usually be substantially more useful.
Connect AI Test Planning to the QA Test Plan
AI-generated scenarios should fit inside the project’s wider QA strategy.
The test plan still needs to define:
- scope;
- environments;
- responsibilities;
- risks;
- entry criteria;
- exit criteria.
For that structure, see How to Create a Website QA Test Plan.
AI helps generate coverage.
The test plan defines how that coverage fits into the release.
Connect Test Cases to Release Readiness
Not every test failure has the same importance.
When a test fails, ask:
- Is this a critical workflow?
- How many users are affected?
- Is there a workaround?
- Does it block release?
For release decisions, see Go/No-Go Checklist: Is Your Website Ready to Launch?.
This is why test-case generation should include risk and priority whenever possible.
Use AI Carefully With Sensitive Data
Do not place unnecessary sensitive information into prompts.
Avoid sharing:
- passwords;
- API keys;
- private tokens;
- customer records;
- confidential production data.
Use anonymized or synthetic test information where possible.
The usefulness of an AI-generated test case does not depend on exposing real secrets.
AI Should Make Testers More Effective, Not Passive
The danger of AI-assisted QA is not only incorrect output.
It is also passive acceptance.
If a tester simply executes whatever AI generated, they may stop asking important questions.
Use AI to create more questions.
Not fewer.
A useful mindset is:
AI suggested this scenario. Does it actually matter for this product?
That is still a QA decision.
Make AI-Assisted Test Planning Repeatable
A mature workflow can be:
Requirement → AI Coverage Draft → QA Review → Risk Prioritization → Execution → Defects → Regression Update
This gives AI a useful role without making it the source of truth.
Qualavo Professional includes structured AI prompt resources alongside broader website QA workflows for planning, defect reporting, release readiness, accessibility, SaaS, e-commerce, and client reporting.
Final Thoughts
The best AI prompts for website QA do not simply ask:
Give me some test cases.
They provide:
context, requirements, scope, constraints, risk, and an expected output format.
Use AI to help:
- generate candidate scenarios;
- discover edge cases;
- challenge existing coverage;
- prioritize risk;
- improve test-case wording;
- maintain regression suites.
But keep humans responsible for:
- requirements;
- assumptions;
- expected results;
- prioritization;
- execution;
- release decisions.
AI can make test-case design faster.
It can also make it broader and more systematic.
But the quality of the final QA coverage still depends on the tester asking the right questions.
