AI takes over tasks in testing today, not the tester's job. Agents plan, generate, run and repair tests and scan a live interface. People decide what to test, question requirements, explore the product, judge user experience and answer for the release. This post argues that QA is becoming AI quality engineering: testers direct AI and check its work.
Will AI replace software testers? Commenters on one public testers’ forum say the question comes up there many times a day. This post separates what AI does in testing today from what still needs a person, with working testers’ views on both sides.
The table below shows how the work could shift, task by task.
| Task | Likely direction | Why |
|---|---|---|
| Writing a first test plan for a user flow | Shrinks | Agents explore the app and draft a plan; a person reviews it |
| Writing routine UI test code by hand | Shrinks | Coding assistants and agents generate test code from a plan |
| Fixing failing tests after UI changes | Shrinks | Agents run the suite and repair failing tests; a person checks the fix |
| Repetitive regression clicking | Shrinks | Automated and agent-run checks take the routine passes |
| Reviewing AI-drafted tests and code | Grows | Every draft needs a reader who knows the business rule |
| Risk analysis and refinement | Grows | Gaps in requirements show up before any code exists |
| Exploratory testing of AI-built features | Grows | More pull requests start with an agent's first draft |
| Designing quality gates in CI | Grows | A gate decides what ships when the volume of changes rises |
| Evaluating AI features themselves | Grows | AI features in a product need checks of their own |
| Owning review rules and tooling | Grows | Someone decides who reviews a draft and who owns the test |
Will AI replace QA testers? What working testers say
Working testers are split, and both sides give reasons. In a recent thread on a public QA forum, testers argued it both ways. What follows are their opinions, paraphrased.
The optimists start from AI-written code. One tester argues that QA is needed as much as ever, because AI-generated code now reaches production. Another says someone still has to run the prompts. A third argues that relying only on AI costs more, because firing QA raises the risk of shipping bugs.
In their view, testers who do risk-based testing and challenge analysts and developers need not worry. One commenter says that as long as an application has human users, someone tests its experience. Another points out that regulated companies, such as banks, need risk management and accountability.
The pessimists start from budgets. One commenter says short-term cost cutting for quarterly results can win over long-term cost. Another would move into software development, says crises hit QA harder and notes that many companies have no test team.
Some expect QA jobs to drop and suggest considering another trade. One commenter says a team was cut sharply after it adopted AI. The thread offers no way to check that account.
The two camps overlap in places. Even the optimists say pure click-through testing may be replaced; one puts it as QA always, but not low-skill QA. One commenter adds that AI output varies and contains bugs, so verification stays, and advises learning the AI tools.
Can AI do QA testing today?
Yes, for part of the work, and every output needs review. Playwright’s test agents show the range. A planner explores your app and produces a test plan. A generator turns the plan into executable Playwright tests. A healer runs the suite and repairs failing tests.
Developers already use AI this way. In the 2026 Stack Overflow Developer Survey, 58% of respondents named writing or improving tests. It was among the tasks they currently use AI or AI agents for (Stack Overflow, 2026). The survey’s authors add that technologists rate AI highly on technical problems with checkable answers, and lower on other everyday work.
Disclosure: the founders of Zapple.Tech built Testomat.io, a test management tool, and Testomat.ai, whose products include the agents Explorbot and Testeiya. The Zapple.Tech team uses Testeiya, Explorbot, Playwright MCP and Testomat.io.
Explorbot is an AI agent that scans a live UI, runs exploratory tests and generates Playwright code. Testeiya is a QA agent with built-in testing skills, workflows and automations. It works with Testomat.io, MCP, local workspaces, GitHub, GitLab and Jira. For how agents run full user journeys, see end-to-end testing with AI agents.
For a hands-on guide, see how to use AI in automation testing.
What this does not solve: every output has to be read, and reading takes time. A test that passes is not proof that it checks the right thing. The example further down shows why.
Can AI testing completely replace manual QA?
Not with today’s tools. Playwright’s test agents are documented for planning, generating, running and repairing tests. In this post’s view, deciding what matters to users is not on that list, and four parts of the job stay with people. Working testers make the case for each.
Can AI find what is wrong with requirements?
Refinement happens before code exists: questioning requirements, finding gaps in acceptance criteria and deciding what is risky. A senior tester in the thread says most of their own work happens there, long before any test runs.
They use an AI assistant daily, including to review an OpenAPI specification for gaps. In their view, though, AI cannot tell what is wrong with acceptance criteria or which questions a design should raise. A model reads the spec it is given. It has no way to know which business rule the spec left out.
Can AI do exploratory testing?
In part. Agents can scan an interface and run exploratory tests. In this post’s view, deciding whether odd behavior matters to real users, and following a hunch, stays with a tester. The same senior tester doubts that AI can anticipate the odd things real users do.
That judgment is the core of manual and exploratory testing. Exploratory testing is where a person follows the hunch.
Can AI judge user experience?
A test can confirm that a button works. It cannot tell you that users will miss it. People judge user experience, because people are the ones using the product. One commenter in the thread says that while an application has human users, someone tests its experience and whether it meets their expectations.
Who answers for risk in regulated work?
A commenter in the thread points out that regulated companies, such as banks, need risk management and accountability. An AI tool can produce evidence for a release decision. In this post’s view, accountability for that decision stays with a named person.
Do you still need QA when developers use AI coding assistants?
This post argues that you do, because more AI-written code means more change to verify. The volume is measurable. According to GitHub, more than 40% of pull requests on GitHub started with an agent’s first draft by September 2026. In March the figure was 17% (GitHub Octoverse, 2026).
The review side is where testers in the thread speak from experience. One works on a team that uses an AI agent harness. They describe developers shipping pull requests faster and approving them without proper review. The tester says they have filed many bug tickets and caught defects before production.
Others in the thread argue that more development volume creates more work to test. Another commenter says AI is non-deterministic and creates large amounts of buggy code.
Developers are cautious too. In the same survey, 48% of respondents said they trust AI when they can easily validate the answers (Stack Overflow, 2026). Testing is one way to make answers easy to validate. For teams whose code now comes partly from assistants, see QA for AI-generated code.
Should we cut QA because developers use AI coding tools?
In this post’s reasoning, cutting testers does not remove the checking; it moves it. Cutting testers saves salary now. The verification then has to happen in developers’ review time, or users meet the defects in production. Whether that trade pays depends on what a defect costs in your product.
The pessimists in the thread make a fair point here. In their view, short-term cost cutting can win anyway. Quarterly savings are visible; future defects are not.
What does a reviewer add to an automated UI test?
A reviewer checks the outcome where it is stored, not only where it is shown. Here is a small case, written for this post and run before publishing.
The app under test is a product page with a cart API, served by a small local Node.js server. The server has a bug.
The page sends quantity, the server reads qty and falls back to 1. The page still shows what the buyer typed.
The first test trusts the page. This is tests/cart-ui-only.spec.ts:
import { test, expect } from 'playwright/test';
// Before review: the test trusts the text the page shows.
test('adds two shirts to the cart', async ({ page }) => {
await page.goto('/');
await page.getByLabel('Quantity').fill('2');
await page.getByRole('button', { name: 'Add to cart' }).click();
await expect(page.getByRole('status')).toHaveText('Added 2 to cart');
});
Against the buggy server it passes (all output here is shortened):
$ BUGGY=1 npx --no-install playwright test tests/cart-ui-only.spec.ts
✓ 1 tests/cart-ui-only.spec.ts:4:1 › adds two shirts to the cart (315ms)
1 passed (989ms)
A reviewer makes two changes. The test reads the cart from the server’s API after the click. And a negative check confirms
that quantity 0 is refused and nothing is stored. This is tests/cart-reviewed.spec.ts:
import { test, expect } from 'playwright/test';
test.beforeEach(async ({ request }) => {
await request.delete('/api/cart');
});
// After review: check what the server stored, not only what the page says.
test('the server cart holds the quantity the buyer chose', async ({ page, request }) => {
await page.goto('/');
await page.getByLabel('Quantity').fill('2');
await page.getByRole('button', { name: 'Add to cart' }).click();
await expect(page.getByRole('status')).toHaveText('Added 2 to cart');
const cart = await (await request.get('/api/cart')).json();
expect(cart.items).toEqual([{ sku: 'TSHIRT-M', quantity: 2 }]);
});
// Added in review: a negative check. Quantity 0 is refused and nothing is stored.
test('quantity 0 is refused and the cart stays empty', async ({ page, request }) => {
await page.goto('/');
await page.getByLabel('Quantity').fill('0');
await page.getByRole('button', { name: 'Add to cart' }).click();
await expect(page.getByRole('status')).toHaveText('Quantity must be at least 1');
const cart = await (await request.get('/api/cart')).json();
expect(cart.items).toEqual([]);
});
Against the same buggy server, both reviewed tests fail:
$ BUGGY=1 npx --no-install playwright test tests/cart-reviewed.spec.ts
✘ 1 tests/cart-reviewed.spec.ts:8:1 › the server cart holds the quantity the buyer chose (203ms)
✘ 2 tests/cart-reviewed.spec.ts:18:1 › quantity 0 is refused and the cart stays empty (5.2s)
1) Error: expect(received).toEqual(expected) // deep equality
- "quantity": 2,
+ "quantity": 1,
2) Error: expect(locator).toHaveText(expected) failed
Expected: "Quantity must be at least 1"
Received: "Added 0 to cart"
2 failed
With the bug fixed, all three tests pass:
$ npx --no-install playwright test
✓ 1 tests/cart-reviewed.spec.ts:8:1 › the server cart holds the quantity the buyer chose (262ms)
✓ 2 tests/cart-reviewed.spec.ts:18:1 › quantity 0 is refused and the cart stays empty (209ms)
✓ 3 tests/cart-ui-only.spec.ts:4:1 › adds two shirts to the cart (155ms)
3 passed (1.3s)
Tested with Playwright 1.62.1 (the playwright package and its test runner), Chromium 151 and Node.js 26.13.1 on
2026-11-18.
What this shows, and what it does not. A check on stored state catches a bug that the page text hides. The weak test shows a common pattern; it is not a client case. Whoever drafts a test, a person or a tool, the review questions are the same. Before deciding on cuts, look at what a review has to catch:
- Does the assertion check the business rule, or only that something is visible? The first test above did not.
- Does the test fail when the feature is broken? Break it once on purpose and see, as the buggy server does here.
- Do the test data cover edge values, empty states and permissions, not only the happy path? Quantity 0 is one.
- Does the test wait for a real condition rather than a fixed delay?
- Would someone who knows the domain recognize the scenario as one users follow?
- Who owns the test once it is in the suite, and who fixes it when it fails?
If drafts fail these checks often, the time saved on writing goes into review. That time belongs in the decision.
If you want to test this on your own suite, start with a one-week AI readiness assessment.
Will the demand for software testers decrease?
The BLS projection does not show a decrease. For many readers, “will AI replace software testers” is a jobs question. The US Bureau of Labor Statistics projects 6% growth for software quality assurance analysts and testers from 2025 to 2035, from 187,600 to 198,200 jobs. The average for all occupations is 3% (BLS, 2026).
The Bureau links demand in the wider group, which includes developers, to the continued expansion of software development. It names AI, the Internet of Things and robotics. A projection is not a promise, and it covers the US only.
So is software testing still a good career? On the BLS numbers, the occupation is projected to grow in the US. On the forum, even testers who expect QA to stay say pure click-through work may go. They see risk-based testing as safer.
What is AI quality engineering, and what is the future of software testing?
AI quality engineering is QA work in which testers direct AI tools and agents and own the checks that decide what ships. The AI drafts; the tester decides.
In this model, QA runs beside development, not after it. Requirements become test cases before code is written. One agent automates the tests while another builds the feature. A quality gate decides what ships, and a mismatch goes back to requirements.
QA is involved at every stage of delivery: intent, requirements, spec, design, implementation, testing, release, deployment and support.
Is this the future of software testing? It is a direction, not a forecast. The parts exist today: agents that draft and repair tests, gates in CI and testers who review what both produce.
Which skills should testers build to stay relevant with AI?
Start with the work AI already touches, and keep people on the decisions. The first three steps suit any tester; the rest are team decisions for QA leads.
- Learn the AI tools your developers already use. You cannot review output from a tool you have never run.
- Move effort into refinement and risk. A gap found in the acceptance criteria never becomes code.
- Practice reviewing tests for stored outcomes. Ask where the result lives, and assert it there.
- Write review rules for AI-drafted tests. Decide who reviews a draft, and who owns a test once AI drafted it.
- Count review time, not only drafting time saved. A draft that takes longer to check than to write saves nothing.
- Put a quality gate in CI. Let the gate, not the author’s confidence, decide what ships.
- Run one bounded pilot on a real suite. Log each AI output as accepted, changed or rejected, and decide from the log. Keep exploratory sessions in the plan while it runs.
How do teams keep people in charge when they adopt AI?
With a few fixed practices, not reassurance. Every AI output passes a review gate. Each test has a named owner. A log records what was accepted, changed or rejected. At the end of the pilot, the team decides from that log, not from a demo.
Zapple.Tech helps QA teams set this up. It was founded by the founders of CodeceptJS and Codeception, open-source testing frameworks, and of Testomat.io and Testomat.ai. The company builds and tunes the AI layer for QA: skills, harnesses and agents, infrastructure tuning and monitoring. The page on AI adoption for QA teams sets out the approach.
So, will AI replace software testers? As tools stand today, AI takes over tasks, and the tester’s job moves toward directing and checking that work. To plan that shift for your team, tell us about your suite in the form below.
Sources
- US Bureau of Labor Statistics, Occupational Outlook Handbook: Software Developers, Quality Assurance Analysts, and Testers (last modified 2026-08-27)
- Stack Overflow, 2026 Developer Survey: AI (results published 2026-10-06)
- GitHub, Octoverse: Commits, pushes, reach new highs in 2026 as developers build with agents (published 2026-10-28, updated 2026-11-06)
- Playwright documentation: Test agents (current documentation, read 2026-11-18)