
Two years ago, half of what I test in a week barely existed. I now test features whose output is different every time I run them, where a changed answer is not automatically a wrong one. I test code an agent wrote, then test whether the agent’s own green run actually proves anything or whether it quietly loosened a test until it passed. Running something once and trusting the result is finished. When the thing under test is not consistent, one clean run tells you almost nothing.
I am not guessing about any of this. I use a few coding agents like a small team, and I built an entire mobile game with them. So when people ask me whether AI is going to take testing jobs, I answer from my own week, not from a prediction I picked up somewhere. The job is not going away. It is changing, the change is real, and the shape of it is already sitting in my work: AI produces more, faster, and the value moves to whoever decides what to trust.
What that looks like in my actual week comes down to three things: how I test now, the new work AI put in front of me, and what I would do if I were the one feeling nervous.
What actually changed in how I test
A few years ago, a lot of my day was mechanical. Writing out test cases, building edge case lists, setting up test data, reading through logs line by line, scripting the same kind of test for the hundredth time. AI is genuinely good at that part, and I hand it over now without thinking twice. I ask it to draft scenarios for a feature, to comb a thousand log lines for the one that matters, to find what is common across a batch of flaky failures, to write a first pass at a test, to explain an error I have not seen before. It is fast, it does not get bored, and it frees me up.
What it did not do is replace the part of the job that was always the actual job. AI hands me a list of checkout scenarios in seconds. It cannot tell me which of them matter for this product, what the real risk is behind each one, or how much evidence is enough before I am comfortable saying ship it. It will happily write a test that passes and quietly checks the wrong thing. It cannot look at a screen and feel that something is off. When I built my game, the agents could prove the backend was correct, but they could not tell me the win screen felt flat or that a button was too small under a thumb on a small phone. That part was mine, and it stayed mine.
So the shape of my day changed. Less typing, more deciding. Here is roughly how the work splits now.
| AI is strong, I hand this over | Human required, I keep this |
|---|---|
| Drafting test scenarios and edge case lists | Deciding which ones actually matter for this product |
| Combing through logs and large amounts of data | The visual and feel call: is this screen actually right |
| A first pass at a test or some test data | The real end to end user flow, the way a person moves through it |
| Spotting patterns across flaky failures | Exploratory testing, finding the risk nobody wrote down |
| Explaining an error or summarising a release | The decision: is this good enough to ship |
I go deeper on how I run agents day to day in working with coding agents as a QA engineer, and on why that division holds in the QA control layer for AI-assisted development, so I will not repeat all of it here.
AI took the mechanical half and handed me more of the half that was always the point.
The new things I actually have to test now
The more interesting change is not that AI helps me test. It is that AI put new things in front of me that need testing, things that barely existed a few years ago.
AI features inside the products themselves. When a feature’s output is generated instead of fixed, my old habit of “expected result equals this exact string” falls apart. The same input can give a slightly different answer every time, and different is not the same as wrong. You have to test whether the behaviour is acceptable, not whether it matches a saved value, and that is a genuinely different skill. I wrote up how I do it in how to test AI features with non-deterministic output.
Software that acts on its own. More products now have an agent inside them that takes actions for the user, not just answers a question. Two habits keep me honest here. I run the same scenario many times, because with something inconsistent a single good pass proves very little. And I test the guardrails rather than the agent’s good intentions: what I actually care about is whether something bad can happen when the agent is talked into trying it, so I check that the system underneath refuses the dangerous action on its own.
The code itself. More of it is written by AI now, and AI-written code has a tell. It is usually clean, it usually runs, and it sounds confident even when it is wrong. I have watched an agent “fix” a failing test by loosening the assertion until it went green, leaving the bug exactly where it was. So I review what an agent writes the way I would review a fast, eager junior’s work. I read the diff, not the summary, and I make it show me the failure before I trust the fix. That is its own piece, is that green checkmark real.
None of these are exotic. They are the same testing instincts I already had, pointed at a new kind of thing. But they are real work, and the testers who are already doing them are going to look like they saw it coming.
What I would tell a tester who is worried
If you are reading this a little nervous about where you fit, here is what I actually believe, and I am not saying it just to be kind.
The part of testing that AI is taking is the part that was never really you. Nobody got into this work because they loved writing the same regression script for the tenth time. The part that is left, deciding what is risky, noticing what nobody specified, judging whether the thing is actually good, and being the person who can say “not yet” and explain why, is the part that was always the craft. It is getting more valuable, not less, because everyone now has a machine that produces a lot of plausible output quickly.
Someone has to be able to tell useful evidence from confident nonsense. That someone is a good tester.
What I would not do is try to learn everything at once. That is how people freeze. Start with whatever is closest to what you already ship.
- APIs. If your team lives on them, get properly deep on API and service testing.
- Mobile. If your product is on phones, learn real device and network testing, not just the simulator.
- Releases. If they are painful, learn your pipeline and how to choose which tests run when.
- Working with agents. Whatever you build, get genuinely comfortable directing an AI agent, because the people who do that well are going to stand out.
You do not have to become an expert in all of it, and trying to will just stall you. Pick one, go deep, and let the rest come later. If you want a concrete route from manual testing toward this kind of work, I laid one out in from manual QA to AI-augmented SDET.
Where I land
The future of QA is not testers against AI. In my own work it looks like a partnership, where the machine does the fast, mechanical, high volume work and I do the judging. I would much rather drive these tools than be flattened by them, and the way you stay in the driver’s seat is judgment. The thing that made you valuable was never how many tests you could write. It was whether the team could trust you when you said something was ready, or trust you more when you said it was not. AI does not do that part. It makes it matter more.
So do not try to out-type the machine. Get better at the judgment it cannot copy. Pick the one area closest to what you build, go deep, and learn to work alongside an agent. If you want to see that wired up end to end, I sketch the full agentic QA loop you can hand the busywork to, from a Slack message to a pull request, with you still owning the call.
And keep being the person in the room who tells the truth about whether the software is actually good. That tester has a future. I am not worried about her at all.





Comments 0
Share your thoughts, ask questions, or add to the conversation.