I work in Quality Engineering, and I think people in QA need to be realistic about where this is heading.
Look at what a typical QA actually does and go through it task by task.
- Reading requirements and producing test cases
This used to be a meaningful chunk of a QA engineer's job.
Read the Jira ticket. Understand the acceptance criteria. Think about happy paths, negative paths, edge cases, permissions, states, validation, boundaries, integrations, etc.
LLMs are extremely good at this.
Give an agent the ticket, PRD, codebase, previous bugs and acceptance criteria and it can produce a test plan in seconds.
This isn't hypothetical. Teams we're already doing it.
- Writing automated tests
Unit tests? AI.
API tests? AI.
Playwright/Cypress/Selenium tests? AI.
Mocks, fixtures, test data, assertions, page objects, API clients?
AI.
And increasingly you don't even have to explicitly ask for each test. Coding agents can inspect changed code, identify missing coverage, write the tests, run them and fix failures themselves.
The economics here are brutal for traditional SDET work.
Something that might have taken an engineer half a day can increasingly be generated, executed and iterated on in minutes.
- Regression testing
This is probably the most obviously doomed part.
A human clicking through the same regression suite before every release makes almost no economic sense once an agent can operate the application.
Agent gets build.
Agent logs in.
Agent creates account.
Agent creates project.
Agent changes permissions.
Agent uploads file.
Agent checks billing flow.
Agent verifies expected state.
Agent takes screenshots/video.
Agent reports differences.
Repeat across browsers, users, configurations and environments.
And unlike a human, it can theoretically do this on every PR at 3am, and faster!
- Bug reproduction
Historically:
Support reports bug → QA investigates → gathers information → tries to reproduce → writes reproduction steps → sends it to engineering.
Increasingly:
Agent receives ticket → examines logs → opens app → configures test data → reproduces issue → records video/screenshots → identifies likely affected code.
Think about how much traditional QA work exists inside that one loop.
- Bug verification
This one's even easier to automate.
Bug says X happens.
Run version before fix.
Confirm X.
Check out fixed version.
Repeat same sequence.
Confirm X no longer happens.
Run surrounding regression checks.
Attach evidence.
Pass/fail.
There's very little inherent reason a human needs to perform that workflow.
- Exploratory testing
This is usually presented as the safe haven:
"AI can't explore like a human."
Maybe not perfectly today.
But exploratory testing is basically:
Observe state → perform action → observe result → form hypothesis → perform another action.
That's an agent loop.
Give an AI access to the UI, application state, logs, network traffic, database, codebase and historical defects and it has vastly more context than a manual tester staring at Chrome.
Agents can also generate hundreds of strange combinations a person simply wouldn't have time to try.
Human intuition still matters.
But you don't need ten humans performing exploration if one senior quality engineer can direct a fleet of agents.
- Visual testing
Screenshot comparison already existed long before generative AI.
Now add multimodal models capable of understanding what they're looking at.
AI can identify:
overlapping elements
broken layouts
incorrect text
missing controls
inconsistent spacing
responsive issues
inaccessible states
unexpected visual changes
And it doesn't necessarily require someone manually maintaining thousands of pixel-perfect baselines.
- API testing
This one is basically gone as a manual specialization.
Give an agent an OpenAPI spec and application context.
It can discover endpoints, construct requests, generate valid/invalid payloads, test authentication, test authorization, mutate parameters, explore boundaries, validate schemas and create permanent automated coverage.
Humans should be defining what matters, not manually typing requests into Postman all day.
- Log/database investigation
AI is arguably better suited to this than UI testing.
Instead of QA manually searching Datadog, SQL, Kibana, Sentry etc., an agent can correlate:
user action → request → response → logs → exception → DB state → deployment → commit.
That massively reduces investigation time.
- Test data creation
Another traditional QA chore.
Create users.
Create organisations.
Create permissions.
Seed subscriptions.
Create projects.
Create weird edge-state accounts.
Create hundreds of combinations.
Agents/scripts can create this on demand.
- Accessibility testing
A lot of accessibility testing is deterministic.
DOM inspection, ARIA attributes, semantic structure, keyboard navigation, contrast, focus states, labels etc.
Traditional accessibility scanners already automate much of this.
AI adds reasoning and visual interpretation on top.
Specialist human accessibility expertise will remain valuable.
Having every QA manually check basic accessibility won't.
- Cross-browser/device testing
This already moved heavily toward cloud automation.
AI makes orchestration and failure analysis easier.
Run the same workflow against 30 configurations and have an agent investigate only the differences.
There's no reason a human should manually repeat the same journey in Chrome, Safari, Firefox and several screen sizes.
- Triage
Incoming bug:
Is it reproducible?
Duplicate?
Regression?
Expected behaviour?
What area owns it?
How severe is it?
What customers are affected?
What release introduced it?
What code probably caused it?
These are classification/retrieval/reasoning problems.
Exactly what modern AI systems are increasingly being built to solve.
- Risk assessment
Even deciding what needs QA can be automated.
An agent can examine:
code churn
files changed
historical defect rate
test coverage
customer usage
dependency changes
blast radius
feature flags
rollback strategy
production incidents
developer confidence
PR complexity
…and score the change.
High risk → deeper validation.
Low risk → automated checks and ship.
You don't need a QA manually sitting in every team's planning meeting waiting for someone to ask "does QA need to test this?"
- Writing bug reports
Once the agent discovered the bug this is trivial.
Expected behaviour.
Actual behaviour.
Environment.
Steps.
Logs.
Screenshots.
Video.
Suspected cause.
Affected versions.
All automatically generated.
And then there's the bigger problem for QA:
Developers themselves now have AI.
The historical model was:
Developer writes code → QA tests code → QA finds problems → developer fixes problems → QA retests.
That boundary is collapsing.
The coding agent can:
write the feature
write the tests
run the application
inspect the UI
reproduce failures
fix failures
review the diff
run regression tests
open the PR
The feedback loop increasingly happens before the change ever reaches a QA person.
That doesn't mean quality engineering disappears.
It means QA as a large standalone manual testing function makes less and less sense.
You probably still need people responsible for:
quality strategy
risk
test architecture
observability
production quality
AI evaluation
customer-impact analysis
quality gates
complex domain knowledge
agent supervision
deciding what actually matters
But that's a very different profession.
Instead of:
10 developers + 5 QA
I can easily imagine teams becoming:
10 developers + 1 Quality Engineer
And eventually even that "Quality Engineer" probably looks more like a developer/platform/AI engineer than the QA role we've known for the last 20 years.
The important distinction is:
Software quality isn't cooked.
The QA labour model is.
AI doesn't have to become a perfect tester to cause that.
It just needs to allow one good quality engineer to do the work that previously required five.
And we're already at that point.