Today, you can find tools that generate code and AI-assisted test automation tools that will handle the quality assurance part. Is it the death of traditional manual testing? In this article, Rimpal Mistry reminds us that human validation is still needed to provide the final check of delivered software.
Author: Rimpal Mistry, Co-Founder & VP Operations @ Testscenario
Over the past few weeks, we have been watching something interesting happen on some of our projects.
Let’s take one specific project that has reached a stage where 100% of the code is being written by AI, with no direct human intervention in development.
Features are being built by AI. Bugs are being investigated and fixed by AI. Code reviews are handled through automation. Deployments are automated too.
From development to deployment, there is now very little direct human involvement.
That part is impressive.
But the more interesting part for us is what happened to QA.
The requirement for manual testing did not go down. It actually grew.
It Still Starts With a Requirement
The process still starts normally.
Someone needs a feature, change, or fix.
Earlier, a developer would read the requirement, understand the codebase, build the feature, test it, fix issues, and send the change for review.
Now much of that can go directly to an AI coding system.
The AI reads the requirement, looks at the existing code, identifies what needs to change, and starts building.
Humans still decide what needs to be built. But once that direction is clear, the implementation itself can happen with very little developer involvement.
This has moved far beyond autocomplete.
AI can make changes across multiple files, update APIs, modify business logic, follow existing patterns, and complete an entire development task.
Bugs, Reviews, and Deployment Follow
The interesting part is that AI does not necessarily stop once the feature is written.
A test fails. An API returns the wrong result. A change affects an existing flow.
AI can investigate the failure, check the surrounding code, make another change, rerun the checks, and continue.
The usual build, test, debug, fix cycle can happen with very little human involvement.
The review stage is becoming more automated too. Static analysis, automated tests, security checks, linting, and AI-assisted review can inspect the change before it moves forward.
Then CI/CD takes over.
The build is created, checks run, and the application moves into the next environment.
Put it together and the flow starts looking very different:
Requirement comes in.
AI builds the feature.
AI fixes the problems.
Automation reviews the change.
The pipeline deploys it.
At this point, you might expect QA to simply become another fully automated stage.
That has not been our experience.
Then a Human Tester Gets the Build
The automated checks can all be green.
The code can pass review.
The deployment can complete successfully.
And the feature can technically work.
Then manual QA starts using it.
That is often where a different set of questions appears.
Does this flow actually make sense?
What happens if the user does things in a different order?
What happens with old data?
What happens if another service fails?
Does this new behaviour affect another part of the application?
Is the feature technically correct but confusing to use?
These are not new testing questions.
What is new is that they are being asked after a process where very few humans may have looked closely at the product behaviour during development.
AI Can Build What We Asked For
That does not mean we asked for everything.
Take a simple requirement:
Allow a customer to change their delivery address after placing an order.
AI can build it correctly.
The address changes. The database updates. The API works. Automated tests confirm that everything is saved.
Then QA starts testing.
What if the order has already shipped?
Can the customer change the country?
Should shipping charges change?
What happens to tax?
Has the warehouse already received the old address?
The AI may have built exactly what was requested.
The problem is that the requirement did not describe every real-world situation.
That is not unique to AI. Human developers work with incomplete requirements too.
The difference is that AI can turn those assumptions into working software much faster.
Which means the software can reach QA much faster too.
We Have Heard “QA Is Dead” Before
There is another reason I am cautious whenever someone says AI will finally remove the need for testers.
People have been predicting the end of QA for years.
Automation was supposed to do it.
Then continuous testing.
Then AI.
The year changes, the technology changes, and the same prediction comes back.
Versions of “QA is dead” were being discussed as early as 2012, and we are hearing them again in 2026. I would not be surprised if we hear the same thing in 2029, 2031, and 2035.
What actually changes is the work.
Some repetitive testing work disappears or gets automated. Other parts move towards exploratory testing, business logic, risk, product understanding, and automation itself.
So the useful question is not whether QA dies.
It is:
Which parts of QA still matter when more of software delivery becomes automated?
We Are Not Seeing Less Demand for Manual Testing
This is the part that surprised us most.
As development became more automated, the need for manual testing did not disappear.
In some cases, companies wanted more of it.
That does not mean everything should suddenly be tested manually.
Regression checks, API testing, compatibility checks, repeated validations, and performance tests should be automated wherever possible.
AI should be used in QA too. It can help with test data, logs, failure analysis, scenario generation, and automation maintenance.
There is no reason to protect repetitive manual work.
But that is not where manual QA is most useful anyway.
Its value is in looking at the product without assuming that everything before it was correct.
The tester is no longer only checking what a developer wrote.
In this kind of project, they are checking what an increasingly automated development process produced.
The Final Line of Defense
We do not know how far autonomous development will go.
AI development tools will improve. AI testing tools will improve too. More testing work will become automated.
But this is what we are seeing right now.
AI can build the feature.
AI can fix the bugs.
Automation can review the change.
The pipeline can deploy it.
Almost the entire development-to-deployment flow can happen with very little direct human involvement.
And after all of that, companies still want a human to use the product before their users do.
That is the part worth paying attention to.
The interesting part is that manual testing is still the final line of defense.
About the Author
Rimpal Mistry is Co-Founder and VP of Operations at Testscenario, where she leads a 50+ member QA team serving clients across multiple industries. Her expertise spans manual testing, test automation, real-device testing, and QA operations for mobile and web applications.
Leave a Reply