Write Test Cases in Plain English

Traditional test automation is a maintenance trap. You write a script in Selenium, Appium, or Cypress. It passes on day one. Three sprints later, the UI changes, a selector breaks, and now someone has to spend half a day debugging a test instead of shipping a feature.

The root cause is that traditional scripts describe how to test, not what to test. You're telling the computer: click element with ID btn-submit, wait 500ms, assert text equals "Success". That instruction breaks the moment the ID changes or the animation slows down. The test has no understanding of the goal. It just follows a recipe.

This is why flaky tests pile up. A 2026 survey by e2eAgent.io found that test fragility and maintenance overhead are the top two reasons teams abandon automated testing entirely (e2eAgent.io, 2026). Teams hit a wall where the cost of keeping tests green exceeds the value of running them.

Plain English test cases fix this at the source. When you write "Add the first product to the cart and complete checkout," the test captures intent. If the checkout button moves or gets relabeled, an AI agent can still find it because it understands the goal. The script does not.

See our AI vs Traditional Mobile Testing Tools: Key Differences breakdown if you want specifics on where the gap shows up most.

Plain English test cases are exactly what they sound like. No Gherkin syntax, no XPath selectors, no assertions written in a programming language. You write a sentence describing a user flow. The AI executes it.

Here is a concrete before/after:

Before (traditional script):

driver.findElement(By.id("email")).sendKeys("test@example.com");
driver.findElement(By.id("password")).sendKeys("password123");
driver.findElement(By.cssSelector(".btn-login")).click();
WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("dashboard")));
assertTrue(driver.findElement(By.id("dashboard")).isDisplayed());

After (plain English):

Log in with test@example.com and password123. Verify the dashboard loads.

Both tests check the same thing. One takes 20 minutes to write and breaks monthly. The other takes 20 seconds and adapts automatically when the login form changes.

This is the core proposition of natural language test automation: you write the intent, the AI agent resolves the mechanics. The agent uses computer vision to identify UI elements, a language model to interpret your instruction, and a feedback loop to retry when something does not match expectations.

BDD frameworks like Gherkin tried to do this with Given/When/Then syntax, but they still required developers to wire up step definitions in code. True plain English testing skips that layer entirely. You do not need a step library. You do not need a QA engineer who knows the framework. Anyone who can describe the feature can write the test.

Most "natural language testing" tools in 2026 are glorified test recorders. You describe a flow, they generate a script, and that script breaks like every other script. The description step is new. The output is not.

Autosana works differently. When you write test cases in plain English on the platform, Autosana's AI agents execute those descriptions directly against your iOS, Android, or web app. There is no intermediate code generation step. The agent reads your instruction, identifies the relevant UI state, takes the action, and reports back with screenshots at every step so you can see exactly what happened.

For example, you upload your Android APK, write "Open the app, tap Sign Up, fill in a valid email and password, and confirm the account creation screen appears," and the agent runs it. If the Sign Up button moves in the next build, the agent still finds it. That is the self-healing behavior: tests adapt to UI changes without manual updates.

This matters for mobile testing in particular. iOS and Android apps change constantly. Selectors that work against one build fail against the next. With Autosana, the test description stays the same across builds. The agent handles the navigation each time.

Autosana also covers web apps by URL with no build file required, which means you can test your full product stack from a single platform. CI/CD integration with GitHub Actions, Fastlane, and Expo EAS means these plain English tests run automatically as part of your deployment pipeline.

See the Autonomous QA for Android Apps: AI Testing Guide for a deeper look at how agentic execution differs from traditional automation on mobile.

Several tools now let you write test cases in plain English. They differ in how much execution intelligence they actually provide.

Virtuoso QA combines natural language programming with AI execution for end-to-end web testing. It has a well-documented approach to converting English descriptions into automated tests, though it is primarily web-focused (Virtuoso QA, 2026).

testRigor has been in this space since before the current AI wave. You write tests in plain English using a constrained syntax, and testRigor interprets and executes them. It supports mobile and web but requires learning its specific dialect of "plain English," which limits who can actually write tests without training.

TestQala claims 10x faster test creation by connecting plain language inputs with Jira and Figma, generating structured test cases automatically (TestQala, 2026). It is more of a test management layer than a full execution platform.

Cypress's cy.prompt feature, released in beta in 2026, lets you write plain English instructions directly in Cypress test files and have AI interpret them. This is interesting but requires you to stay in the Cypress ecosystem and have engineering involvement to configure (Cypress, 2026).

The distinction that matters: does the tool generate code from your English, or does the AI agent execute your English directly? Code generation still breaks. Direct execution with self-healing does not. Ask any vendor which category they fall into before signing a contract.

Autosana sits firmly in the direct execution category for iOS, Android, and web, which is why it handles UI changes without requiring a human to update test scripts after every sprint.

Not every plain English description produces a reliable test. Vague instructions produce vague results. Here is what separates test cases that run cleanly from ones that cause the agent to guess.

Describe outcomes, not clicks. "Verify the order confirmation email is sent" is better than "click the confirm button and wait for the email screen." The first tells the agent what success looks like. The second tells it a path that may have changed.

Include specific data where it matters. "Log in with test@example.com" is more reliable than "log in with a test account." The agent should not have to guess credentials.

One flow per test. Keep each test case focused on a single user scenario. "Sign up, log in, add a product, check out, and verify the receipt" is five tests jammed into one. Split them. Shorter, focused tests fail for clear reasons. Long compound tests fail for ambiguous ones.

Name the starting state. Tell the agent where the user begins. "From the home screen" or "after logging in" removes ambiguity that can cause an agent to start from the wrong place.

Test error paths too. Most teams only write happy path tests. "Enter an invalid credit card and verify the error message appears" is a one-sentence test that catches real bugs. Write the plain English version and let the agent handle the execution.

For teams running Autosana, the Agent Context feature lets you add app-level instructions, like how to handle biometric authentication prompts, so the agent has the context it needs without you repeating it in every test case.

For more on structuring tests that survive rapid development cycles, read Shift Left Testing With AI: Catch Bugs Earlier.

Traditional test automation required a QA engineer who could write code. That person was always a bottleneck. Developers did not want to write tests in a framework they did not own. Product managers could not write tests at all. The QA engineer got overwhelmed, coverage stayed low, and bugs reached production.

Plain English test cases remove the bottleneck. A product manager can write "Verify the promo code field accepts a valid code and applies the discount correctly" without knowing anything about how the app is built. A developer can write test cases in the same time it takes to write a Jira ticket. A designer can verify that the flow they designed actually works in the shipped app.

This is not hypothetical. TestQala reports that teams using AI-powered plain language test creation cut test maintenance by 90% and generate test coverage they previously could not staff (TestQala, 2026). The constraint was never knowledge of testing principles. It was the technical barrier of writing automation code.

For startups, this matters most. If you do not have a dedicated QA team, you cannot afford to build and maintain a Selenium or Appium suite. You can afford to spend 30 minutes writing plain English descriptions of your core flows and letting Autosana run them on every deploy. See QA Automation for Startups: Ship Without a QA Team for the startup-specific case.

For engineering managers, the ROI calculation shifts too. You are not paying an engineer to maintain test scripts. You are paying for coverage that runs automatically and reports back with screenshots.