The Third Era of Software Testing: From Manual to Vibe Testing
We've been through two eras: manual testing, then the automation that scared everyone. Now the third has begun: testing with agents. How your job is changing, and what you need to learn starting now.
Software testing has been through two eras, and the third one has now begun.
Every time, someone came out and said "this will eliminate the tester". And every time, what got eliminated wasn't the tester. It was a particular kind of work. And the people who didn't develop themselves went with the old kind.
The first era: manual testing
Everything was done by hand. You read the requirement, wrote the test cases, opened the app, and tried it step by step. A tester's value was in their critical eye and their patience: spotting the small detail everyone else missed.
And the problem was obvious: every time there was a change, you had to go back and redo the same checks from scratch. Regression ate up all the time.
The second era: automation, and the first fear
Then automation arrived, and with it the line we heard so often: "Automation will eliminate testers."
That's not what happened. What happened is that the required skills changed, and testers had to learn things that weren't part of their job before:
- Programming: Java, JavaScript or Python, at least enough to write a test and maintain it
- Framework design: Page Object Model, and how to build a framework that doesn't collapse after 300 tests
- CI/CD: tests running on their own on every pull request, not on your machine
- Shift Left: getting involved from the start of the project, not waiting until development is done
The people who invested the time and learned these things got promoted and became the backbone of the team. And the people who kept saying "I'm a manual tester, full stop" weren't suddenly fired. Quite the opposite: demand for them dropped gradually until it disappeared. That point matters, because the same pattern is going to repeat.
The third era: Vibe Testing
Now we've reached the era I like to call Vibe Testing: working with agents that multiply your productivity many times over, rather than writing every line yourself.
And let's be precise: an agent isn't a model that chats with you. It's a model connected to your tools, working in a loop until the task is done. The difference shows when you connect it to your real systems.
1. It understands the requirement with you, not instead of you
Connect the agent to Jira. It reads the story, analyses it, and within seconds comes back to you with:
- Risk points: where this change could break something
- Regression points: what you need to retest because of this change
- Acceptance criteria that are missing or ambiguous
- The questions you need to ask in refinement before development starts
2. Connect it to the code too: this is where the difference gets real
When it has Jira and GitHub together, it jumps to a completely different level. Because now it's no longer working on the theoretical logic in the story; it's seeing how the thing was actually built.
It compares the description with the implementation, understands the business logic from the code itself, and tells you where things might go wrong: edge cases nobody thought of, paths that weren't covered, and critical test cases worth your time.
3. Teach it your way of working
This is the point people underestimate the most. You can teach the agent:
- The format of the test cases you write
- Your automation style, and how you design your framework
- The shape of your pipeline and how the tests run
- How you work as a team
After that, with its access to Jira and the code, it builds the automation and runs it, opens the test environment and works on it with tools like Playwright CLI. It's not suggesting code for you to copy; it's doing the work.
4. Connect it to the logs, and this is where you see the magic
This example alone is worth the whole era. Give it access to your monitoring tool (Dynatrace or whatever logging tool you use), and then give it a single sentence:
"This User ID ran into a problem: they couldn't add the product to the cart. Find out what happened."
What does it do? It goes into the logs, looks up the user, traces every API call across all the services, checks the code to understand the logic, and goes back to the stories in Jira to find out what's supposed to happen. And within seconds it tells you exactly where the fault was and why, and suggests a fix.
That work used to take you half a day, across three teams.
The same story, for the third time
In the second era, the people who learned programming and CI/CD got stronger. And those who didn't saw demand for them quietly drop until it disappeared.
Now is exactly the same moment. Agents won't eliminate testers, but the tester who knows how to run them will do the work of ten, and the one who ignores them will find themselves competing with someone who gets a week's work done in a day.
Someone will say: "Well, if the agent writes the test cases and builds the automation, what's left for me?" Exactly the same question was asked about automation in 2015. And the answer is the same: the tool takes the execution, and leaves you the judgement. An agent can suggest fifty test cases in a minute, but who decides which ten of them are worth the time? And who knows that this particular screen is the one the client's management looks at every morning, so a small defect there is more dangerous than a big one somewhere else? That's you, not the agent.
Your role in the future
The good part: the new role is more important than the old one, not less.
| Your role | What it means in practice |
|---|---|
| Building the knowledge base | Documenting the business logic, the team's decisions and the testing approach: this is what makes the agent understand your product, not a generic one |
| Connecting tools and building skills | Hooking up Jira, the code and the logs, and writing the skills that teach the agent how you work |
| Enabling the team | Getting the whole team working this way, not just you |
| Refinement and debugging | And this is your most important role of all: the final judgement, the right questions, and understanding the fault when it happens |
And why has debugging in particular become the most important? Because when the agent does the work ten times faster, the mistakes also come out ten times faster. At that point all the value shifts to someone who knows how to read the result and judge it: is this a real defect, or did the agent misunderstand the requirement? Nobody can make that call for you.
Notice what shifted: from executing the tests to designing the system that executes them. And that's harder, more valuable work, because it needs something the agent doesn't have: knowing your product, your users, and what it means for something to "work correctly" in your particular context.
Be ready for the new era
You don't need to turn into an AI engineer. Start with the smallest thing: take a testing task you do every week and write it down step by step, the way you'd explain it to a new hire. That's your agent's first skill. Then open one door for it: Jira first, then the code.
The people who invested in automation in 2015 didn't regret it. This is the same moment.