use case

AI web testing for QA teams: write the test in English, let an agent run it

the short answer

AI web testing lets a QA team describe a flow in plain English — "go to the pricing page, click 'start free trial', verify the url contains /signup" — and an AI agent translates it into executable steps and runs them in a sandboxed headless browser, returning pass/fail, execution logs, and a screenshot on failure; because the agent re-resolves your intent against the live page each run instead of following a hard-coded selector, the test survives UI changes that would break a static Selenium or Playwright script.

Most QA teams lose more time keeping tests alive than to the bugs the tests are meant to catch. A button moves, a class name changes, a wrapper div gets added — and a suite of static end-to-end scripts lights up red, none of it because the app actually broke. The team spends the morning re-pointing selectors, and the suite slowly earns a reputation for crying wolf. assertly is built for the other path: you describe the flow in plain English, and an AI agent figures out how to execute it against the page as it exists right now.

What an AI testing agent actually does

You write a test the way you'd describe it to a teammate: "open the homepage, click 'learn more', verify the url contains /about". assertly hands that to an AI agent, which translates the intent into concrete browser steps and runs them in a sandboxed headless browser — Playwright under the hood — then reports back pass or fail, the execution log of what it did at each step, and a screenshot captured at the point of failure so you can see exactly what the page looked like when it broke.

The difference from a recorded or hand-coded script is where the brittleness goes. A static script stores "click the element at button.cta-primary > span". The agent stores "click 'learn more'" and resolves that against the actual page each run. So when the markup shifts under it — a renamed class, a reordered DOM, a new wrapper — the agent still finds the right thing, and your test stays green because the user-facing behaviour didn't change. That's the whole wedge: the test describes intent, not implementation.

Where it pays off for a QA team

The clearest win is regression coverage on the flows a team re-checks constantly: signup, login, checkout, search, the contact form. Those are exactly the flows that get touched by every redesign, so they're exactly the static tests that break most. Describing them in English once, then re-running on demand, turns a maintenance liability into a few saved tests you can fire whenever a change lands.

The second win is reach. Plenty of teams have flows that nobody ever automated because writing the Playwright was more work than it was worth — an internal admin screen, a rarely-touched settings page, a marketing landing route. Plain-English authoring lowers that bar enough that a product manager or designer can write the test themselves, no framework, no selectors. assertly keeps a short run history per saved test, so a flow you wrote in a slow week is still there, one click from a fresh run, when you need to confirm a release didn't disturb it.

The honest boundaries

AI web testing is not a silver bullet, and pretending otherwise is how teams get burned. assertly is web-only for the MVP: it drives a browser, so it doesn't test native mobile apps or raw API endpoints. It has no CI/CD integration yet — you run tests from the app, not from a pipeline gate (that's on the roadmap, not in the box today). And it is not a record-and-playback tool; you author intent in words rather than clicking through a recorder.

The most important caveat is judgement. An agent that resolves intent flexibly is a feature for surviving cosmetic changes and a risk for masking real ones — if a flow genuinely changes, you want the test to fail, not to cleverly route around the problem. So treat generated steps the way you'd treat any generated code: review them for your critical paths, watch the failure screenshots, and keep a human in the loop where a missed regression would actually hurt. Used that way, the agent absorbs the maintenance grind while you keep the calls that matter.

frequently asked

Do I still need Playwright or Selenium knowledge?

No. You write the test in plain English and the agent generates and runs the browser steps for you — Playwright is the engine underneath, not something you script directly. That's the point: the people who understand the flow can write the test without first learning a framework. For critical paths, knowing what good coverage looks like still helps you review the generated steps.

How is this different from a static Selenium or Playwright script?

A static script pins each step to a specific selector, so it breaks when the markup changes even if the behaviour didn't. assertly stores intent ("click 'learn more'") and re-resolves it against the live page each run, so cosmetic UI changes don't turn the suite red. The deeper comparison is its own page — see agentic-testing-vs-selenium.

Can the whole QA team's flows live in here?

Web flows, yes — save a test per flow, re-run on demand, and keep a short run history on each. The boundary is scope: web-only for the MVP, no native-mobile or API testing, and no CI/CD pipeline gate yet. It's strongest as fast, low-friction regression coverage for the browser flows a team re-checks every release.

Is there a free tier to try it on a real flow?

Yes. The free tier includes a limited number of monthly test runs — enough to author a flow, run it, and see the pass/fail, logs, and failure screenshot for yourself. Pro is $29/mo for more runs plus parallel execution when you want several tests to run at once rather than in sequence.

Last updated June 20, 2026

ready to try assertly?

write a test