In our last post, we looked at how to evaluate the flood of AI-generated tests taking over modern pipelines. Given how fast AI developments are moving across software engineering, looking ahead to the next shift does not contradict what we discussed about test quality. It is simply a reflection of how quickly the ground is moving under our feet. While test generation is rapidly becoming table stakes, the next big area to pay attention to is how we actually run those tests.
For decades, test automation meant giving a machine exact coordinates and precise instructions. You told your framework to look for an element with a specific ID, wait two seconds, click it, type text into an input field, and assert an exact string.
If a developer renamed that element or moved the button two inches to the right, the script broke. QA teams ended up spending half their week fixing locator strategies instead of actually testing software. We talked about this maintenance trap in our post on harness engineering, where traditional automation frameworks end up requiring more upkeep than the application itself.
Executing Intent, Not Code
What is happening now is fundamentally different from traditional automation.
Instead of writing code that dictates every mouse movement, you hand an AI system a manual test case written in plain English. Something simple, like “Sign in as a standard user, open the account settings page, and update the profile picture.”
The AI system opens the browser and acts like a human tester. It looks at the rendered interface, reads the screen, figures out where the login button is, and carries out the workflow. It does not care if the button is a button tag or a clickable div, or if the CSS class changed during the last build. It understands what you are trying to accomplish and executes the steps dynamically.
Shifting Focus to System Goals
This shifts our focus from writing code to defining intent.
In a standard automation setup, your script is a rigid sequence of instructions. In an AI execution setup, your test case is a goal. As we explored in our post on re-engineering automated testing, modern software is becoming far too dynamic for rigid, step-by-step assertions. When an AI handles execution, it adapts to benign changes in the user interface just like a human tester would.
If a pop-up notice appears on the screen, a human QA engineer does not crash. They close the notice and continue testing. A traditional Selenium script, on the other hand, crashes immediately because an element was obscured. An AI execution agent handles that obstacle naturally because it interprets the screen visually and logically.
The Blurring Line of Manual and Automated
This changes where QA engineers spend their time.
Instead of spending days building complex locators and maintaining fragile automation frameworks, testers can focus on writing clear, meaningful user scenarios. The old line between manual testing and automated testing starts to blur. Your manual test suite, written in simple prose for human readability, effectively becomes your automated regression suite.
That does not mean human supervision disappears. As AI agents take over execution, keeping a clean system of record matters more than ever. You still need a central platform to manage your test cases, track execution history, and audit where the machine succeeded or got stuck.
We spent thirty years teaching machines to follow explicit code instructions. Now we are finally at the point where we can tell the machine what we want to achieve and let it figure out how to get there.