How to Write Test Cases with AI — Complete 2026 Guide for SDETs

Learning how to write test cases with AI is the highest-leverage skill a QA engineer can develop in 2026 — and most guides stop halfway through the process.

This guide goes further. I will show you how to write test cases with AI using proven prompt templates, how to map the output directly into a Selenium POM framework, and how to evaluate AI-generated test cases programmatically so you know they are actually correct.

How to write test cases with AI: To write test cases with AI, feed the AI your user story or requirements, specify the output format (steps, expected results, BDD Gherkin), and validate the output before use. The fastest approach uses ChatGPT or Claude with a structured prompt template. AI generates test cases 60–80% faster than manual writing but always requires human review for business logic and edge case accuracy.

Why AI Changes How QA Engineers Write Test Cases

Traditional test case writing starts with a requirement document, manually identifies scenarios, writes steps line by line, and adds expected results one at a time. A complete test suite for a login feature takes 2–4 hours.

AI test case generation takes 10–15 minutes for the same coverage. The AI reads your user story, identifies test scenarios including edge cases you might miss, and outputs structured test cases in your preferred format.

Over 70% of QA teams in 2026 are using some form of AI for test case generation. Engineers who learn how to write test cases with AI effectively are 3–5x more productive than those who still write manually.

The critical point every guide misses: AI generates the draft. You provide the judgment. The two together produce better test cases than either produces alone.

Step 1 — Choose Your AI Tool

Before learning how to write test cases with AI, you need to pick the right tool for your workflow.

My recommendation for SDETs starting out: Use ChatGPT GPT-4o or Claude free tier. Both handle how to write test cases with AI effectively at zero cost. GitHub Copilot is worth adding once you are comfortable — it generates test code directly in your IDE without switching tools.

Step 2 — The Prompt Template System

This is the section missing from every other guide on how to write test cases with AI. Vague prompts produce vague test cases. Structured prompts produce structured, executable test cases.

Prompt Template 1 — From User Story to Test Cases

Use this for standard feature testing:

You are a senior QA engineer. Convert the following user story 
into a complete test case suite.

USER STORY:
[Paste your user story here]

OUTPUT FORMAT:
For each test case provide:
- Test Case ID (TC_001, TC_002, etc.)
- Test Case Title (one line description)
- Preconditions (what must be true before test runs)
- Test Steps (numbered, specific, actionable)
- Expected Result (precise, measurable outcome)
- Test Type (Positive / Negative / Edge Case)

Requirements:
- Include at least 3 positive test cases
- Include at least 3 negative test cases
- Include boundary value test cases
- Include at least 2 edge cases
- Do not reference UI elements that may not exist

Real Example — Login Feature

Input (user story):

As a registered user, I want to log in with my email and password so that I can access my account dashboard.

Output from ChatGPT using the template above:

TC_001
Title: Successful login with valid credentials
Preconditions: User account exists with email test@example.com
Test Steps:
  1. Navigate to login page
  2. Enter valid email: test@example.com
  3. Enter valid password: ValidPass123!
  4. Click Login button
Expected Result: User redirected to dashboard. Username visible in header.
Test Type: Positive

TC_002
Title: Login fails with incorrect password
Preconditions: User account exists with email test@example.com
Test Steps:
  1. Navigate to login page
  2. Enter valid email: test@example.com
  3. Enter incorrect password: WrongPass123!
  4. Click Login button
Expected Result: Error message displayed: "Invalid email or password"
Test Type: Negative

TC_003
Title: Login fails with empty email field
Preconditions: None
Test Steps:
  1. Navigate to login page
  2. Leave email field empty
  3. Enter any password
  4. Click Login button
Expected Result: Validation error displayed on email field
Test Type: Negative

TC_004
Title: Login fails with email exceeding maximum length
Preconditions: None
Test Steps:
  1. Navigate to login page
  2. Enter email with 256 characters in the email field
  3. Enter valid password
  4. Click Login button
Expected Result: Input rejected or error shown. Max 255 characters accepted.
Test Type: Edge Case

This output is immediate and covers scenarios that manual writers often miss — the 256-character boundary value test case (TC_004) is a genuine edge case that most QA engineers skip.

Prompt Template 2 — BDD Gherkin Format

Use this when your team uses Cucumber, SpecFlow, or pytest-bdd:

Convert the following requirement into BDD test scenarios 
using Gherkin syntax (Given/When/Then).

REQUIREMENT:
[Paste requirement here]

Rules:
- Use formal Gherkin syntax with Feature, Scenario, Given, When, Then, And
- Create separate scenarios for positive, negative, and edge cases
- Use Scenario Outline with Examples table for data-driven scenarios
- Keep each step to one clear action or assertion
- Do not use vague language like "appropriate" or "correct"

Output example for login:

Feature: User Login

  Scenario: Successful login with valid credentials
    Given the user is on the login page
    When the user enters email "test@example.com"
    And the user enters password "ValidPass123!"
    And the user clicks the Login button
    Then the user should be redirected to the dashboard
    And the username should be visible in the page header

  Scenario Outline: Login fails with invalid credentials
    Given the user is on the login page
    When the user enters email "<email>"
    And the user enters password "<password>"
    And the user clicks the Login button
    Then the error message "<error_message>" should be displayed

    Examples:
      | email              | password       | error_message              |
      | wrong@email.com    | ValidPass123!  | Invalid email or password  |
      | test@example.com   | WrongPass!     | Invalid email or password  |
      |                    | ValidPass123!  | Email is required          |
      | test@example.com   |                | Password is required       |

This BDD output is directly executable in Cucumber without modification. That is the power of a structured prompt — AI-to-framework in one step.

Prompt Template 3 — API Test Cases

Use this for REST API endpoint testing:

You are a senior API QA engineer. Generate a complete test case 
suite for the following API endpoint.

ENDPOINT: [HTTP Method] [URL]
DESCRIPTION: [What the endpoint does]
REQUEST BODY: [Paste JSON schema or example]
AUTHENTICATION: [None / API Key / Bearer Token]

Generate test cases covering:
1. Happy path with valid request
2. Missing required fields (one per field)
3. Invalid data types for each field
4. Boundary values for numeric fields
5. Authentication failure scenarios
6. Response schema validation cases

Format each test case with: ID, Title, Request, Expected Status Code, 
Expected Response Body (key fields only)

Step 3 — Map AI Output Into a Selenium Framework

This is the step no competitor covers. Learning how to write test cases with AI is only half the skill. Mapping that output into executable automation is the other half.

Here is how to take TC_001 from our login example and implement it as a Selenium Python test using Page Object Model:

Step 1 — Create the Page Object:

# pages/login_page.py
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class LoginPage:
    URL = "https://www.saucedemo.com/"
    EMAIL_FIELD = (By.ID, "user-name")
    PASSWORD_FIELD = (By.ID, "password")
    LOGIN_BUTTON = (By.ID, "login-button")
    ERROR_MESSAGE = (By.CSS_SELECTOR, "[data-test='error']")

    def __init__(self, driver):
        self.driver = driver
        self.wait = WebDriverWait(driver, 10)

    def navigate(self):
        self.driver.get(self.URL)

    def login(self, username, password):
        self.wait.until(EC.presence_of_element_located(self.EMAIL_FIELD))
        self.driver.find_element(*self.EMAIL_FIELD).send_keys(username)
        self.driver.find_element(*self.PASSWORD_FIELD).send_keys(password)
        self.driver.find_element(*self.LOGIN_BUTTON).click()

    def get_error_message(self):
        return self.driver.find_element(*self.ERROR_MESSAGE).text

Step 2 — Write the test cases from AI output:

# tests/test_login.py
import pytest
from pages.login_page import LoginPage

class TestLogin:

    # TC_001: Successful login with valid credentials
    def test_valid_login(self, driver):
        page = LoginPage(driver)
        page.navigate()
        page.login("standard_user", "secret_sauce")
        assert "inventory" in driver.current_url

    # TC_002: Login fails with incorrect password
    def test_invalid_password(self, driver):
        page = LoginPage(driver)
        page.navigate()
        page.login("standard_user", "wrong_password")
        error = page.get_error_message()
        assert "Username and password do not match" in error

    # TC_003: Login fails with empty email
    def test_empty_email(self, driver):
        page = LoginPage(driver)
        page.navigate()
        page.login("", "secret_sauce")
        error = page.get_error_message()
        assert "Username is required" in error

    # TC_004: Edge case — very long username
    def test_max_length_username(self, driver):
        page = LoginPage(driver)
        page.navigate()
        page.login("a" * 256, "secret_sauce")
        # Assert either error shown or input truncated
        assert driver.current_url == LoginPage.URL or \
               page.get_error_message() != ""

The AI generated the test cases. You provided the framework structure. The combination produces executable, maintainable automation in under 30 minutes for a complete feature.

Step 4 — Evaluate AI-Generated Test Cases Programmatically

This section is completely missing from every competitor’s article on how to write test cases with AI.

AI generates test cases with errors — missing steps, incorrect expected results, hallucinated UI elements. Manual review catches some. Programmatic evaluation catches more.

You can explore the complete setup in the DeepEval official documentation:

# evaluate_test_cases.py
from deepeval import evaluate
from deepeval.test_case import LLMTestCase
from deepeval.metrics import AnswerRelevancyMetric, FaithfulnessMetric

# The requirement that was used as input
requirement = """
User story: As a registered user, I want to log in with my 
email and password so that I can access my account dashboard.
"""

# The AI-generated test case (as a string)
ai_output = """
TC_001: Successful login with valid credentials
Steps: 1. Enter email, 2. Enter password, 3. Click login
Expected: Dashboard loads
"""

# Evaluate using DeepEval
test_case = LLMTestCase(
    input=requirement,
    actual_output=ai_output,
    expected_output="Test case should include preconditions, numbered steps with specific test data, precise expected result, and test type classification"
)

relevancy_metric = AnswerRelevancyMetric(threshold=0.7)
evaluate([test_case], [relevancy_metric])

This automatically scores whether the AI output adequately addresses the requirement. Test cases scoring below 0.7 get flagged for manual review. This is how to write test cases with AI at scale — automated generation plus automated quality validation.

For a full LLM evaluation setup, see our DeepEval review.

Real-World Use Case — Writing Test Cases with AI for an HR System

Here is exactly how a QA engineer used this workflow on OrangeHRM — the free HR management demo application used in SDET practice.

The feature: Employee leave request submission. The manual test case writing estimate: 3 hours for complete coverage.

Prompt used:

You are a senior QA engineer testing an HR management system. Generate complete test cases for the employee leave request feature. The feature allows employees to: select leave type (annual, sick, casual), specify start and end dates, add a reason (optional, max 250 characters), and submit for manager approval. Include positive, negative, boundary, and edge cases. Format as: ID, Title, Preconditions, Steps, Expected Result.

AI output: 18 test cases in 45 seconds, covering:

• Valid leave request submission
• Overlapping date ranges
• Weekend-only date selection
• 251-character reason field (boundary)
• Past date selection
• End date before start date
• Leave request with no available balance

What was manually added: 3 business logic cases the AI could not know — company-specific blackout dates, manager delegation scenarios, and probationary period restrictions.

Total time: 20 minutes. Coverage: better than 3 hours of manual writing.

The AI Noise Problem — How to Handle Hallucinations

When learning how to write test cases with AI, you will encounter hallucinations — test cases that reference UI elements that do not exist, assert impossible outcomes, or contradict the requirements.

Three ways to reduce AI hallucinations in test case generation:

1. Provide UI context in your prompt Instead of just pasting a user story, add: “The login page has: an email text field, a password text field, a Login button, and an error message container below the form.” This specific context prevents AI from inventing UI elements.

2. Use a validation step After generating, ask: “Review these test cases for logical errors. Identify any steps that reference UI elements not mentioned in the requirements, any expected results that are impossible, and any missing preconditions.”

3. Implement Promptfoo evaluation For teams generating test cases at scale, Promptfoo can automatically flag generated test cases where the output does not match the input requirements. See our Promptfoo review for setup instructions.

The Career Impact — How This Skill Builds Your SDET Portfolio

Knowing how to write test cases with AI is a portfolio differentiator in 2026. Here is why.

Most QA engineers either write test cases manually (slow, traditional) or use AI naively without evaluation (fast but unreliable). The engineer who demonstrates a complete workflow — structured prompting, framework integration, programmatic evaluation — shows senior SDET thinking.

For your GitHub portfolio, create one repository that shows:

1. A requirements document (user story)
2. The AI-generated test cases with your prompt template
3. The Selenium POM framework executes those test cases
4. A DeepEval or Promptfoo evaluation script scoring the AI output

This single repository demonstrates: requirements analysis, prompt engineering, framework design, automation coding, and LLM evaluation. That is 5 senior SDET skills in one portfolio project.

For the complete SDET portfolio roadmap, see our how to become an SDET guide.

Final Thoughts

Knowing how to write test cases with AI is not about replacing your testing skills — it is about multiplying them. AI handles the generation speed. You handle the judgment, business logic, and framework integration.

The engineers who master this complete workflow — prompt engineering, Selenium integration, programmatic evaluation — are producing more coverage in less time and building stronger portfolios than anyone relying on manual test case writing alone.

Start with Prompt Template 1 today. Pick a feature you are currently testing, run it through ChatGPT, and compare the AI output to your manual test cases. You will find edge cases you missed. That is the value.

For more on AI-powered testing workflows, read our guide to testing LLM applications and our agentic testing guide.

This Selenium WebDriver with Python course on Udemy gives you the POM framework foundation needed to turn AI-generated test cases into production-ready automation.

Disclosure: This article contains affiliate links. If you purchase through these links I earn a small commission at no extra cost to you.

Frequently Asked Questions