From Manual Testing to AI Agents: Why QA Is Entering Its Most Important Decade

AI Now Writes the Code and the Tests. So What's Left for QA?

AI can generate a feature, write the unit tests for it, and open the pull request. If a machine can produce both the work and the check on the work, it's fair to ask what a human tester is still for. It's a real question, and we think the honest answer is more interesting than the one the industry usually gives.

The reflex answer is that nothing is changing and QA is safe. We don't fully believe that, and neither should you. Some of what QA has always done really is being handed over to software, and pretending otherwise doesn't help anyone. But the conclusion people tend to draw from there, that testing shrinks, is backward. Here is why.

The prediction that keeps being wrong

"Automation will replace manual testers" is not a new claim. It arrived with record-and-playback tools in the 1990s. It arrived again when Selenium made browser automation mainstream in the mid-2000s. It arrived with every CI pipeline that promised to catch everything before release. Each of those waves genuinely changed the job, but none of them made testers redundant. Demand for people who understand quality kept climbing, because the thing being tested kept getting more complicated.

That is the pattern worth holding onto. Automation has consistently changed what testers do without removing the need for them. Glenford Myers was writing about the discipline of testing back in 1979. Nearly fifty years later, the tools are unrecognizable, and the craft is still here.

What is genuinely new this time

Two shifts are happening at once, and their combination matters.

First, building software got dramatically cheaper. Tools like Claude Code turned code generation into a routine part of the workflow, and teams now ship features in the time it used to take to plan them. More features mean more user flows, more integrations, and more edge cases, which is more surface area that can break. The faster you build, the more there is to validate. Speed does not reduce the testing problem. It multiplies it.

Second, testing itself became automatable in a way it never was before. For years, automation could only touch what you could describe in advance: a selector, an API call, a scripted path. Anything that required actually interpreting the screen was off limits. That changed when vision-language models became good enough to read an interface.

When Anthropic shipped computer use in late 2024, and OpenAI released Operator in early 2025, the industry crossed a line. Software could now look at a screen, recognize a button, understand a dialog, and react to something it had not been told to expect. Parts of testing that were considered impossible to automate suddenly were not.

Put those two together, and the picture is clear. There is far more software to validate than before, and far more of the routine validation can now be delegated. The bottleneck moves. It does not disappear.

Where human judgment goes

If agents can run the regression suite and walk the happy paths, the scarce human work becomes everything the agent cannot be trusted to decide on its own. That means deciding what is actually worth testing, judging whether an AI-generated result is genuinely correct or only plausible, working out what an unexpected behavior really means, and understanding how much a given risk matters to the business. Someone still has to point the automation at the right targets and catch it when it is confidently wrong.

This is the same story other crafts are living through. Developers did not stop building when AI started writing code, they moved up a level. Designers did not stop designing when generative tools arrived. In each case, the tools raised the ceiling on what one person could accomplish, and expertise became more valuable rather than less. We expect QA to follow the same path, with less time spent executing and more spent deciding.

The part we are most excited about

The definition of testing is expanding. Modern products are not isolated apps anymore. They are webs of services, business workflows, AI models, and autonomous agents, all changing continuously. More and more, what you need to verify is not a single screen but a whole process held together end to end, sometimes with AI on both sides of the interaction.

That is the problem we started Duzz to solve. We are building for a world where software changes constantly, and AI is involved in both creating and running it, where validating a complete digital process matters more than checking any individual screen. We think this is the most interesting moment the field has had since it became a discipline, and we would rather help define what testing becomes than defend what it used to be.