Alan Richardson speaks to Toby Sears and Krisztian Fischer about AI and Testing.

This episode is also available as a YouTube video on the Tech League channel, full details in the full show notes link.

We cover:

- Introduce Dragan Spiridonov and his work

- Introduce Agent Based Testing and Development

- Introduce and explain Agentic QE tooling

- Explain difference between Agentic QE tooling and Base Claude

- How has working on this changed Dragan's view of his skillsets and role

- How to learn: AI, Agentic AI, Agentic QE?

- Lessons learned from building and using AI that we can apply to any AI tooling

- Future of Agentic QE Tooling

- Future of AI in Testing and Development

Links:

- https://forge-quality.dev/

- https://www.linkedin.com/in/dragan-spiridonov/

- https://spiridonovdragan.com/

- https://agentic-qe.dev/

- Overview of Agentic Quality Engineering Fleet: Revolutionizing Software Testing with AI Agents https://video.agentics.org/media/t/1_htfe35tu/370465892

- https://quantum-qe.dev/

- https://github.com/proffesor-for-testing/agentic-qe

- https://github.com/ruvnet/claude-flow

- https://agentics.org/ 

- for video archive https://video.agentics.org

00:00 - Introduction: Am I an AI Optimist or Pessimist?

02:16 - AI, Jobs, and Management Excuses

06:33 - How AI Changes Our Roles

10:49 - Human Connection vs. AI: Where I Refuse to Use It

16:27 - Building and Using AI Tools for Programming

22:46 - Automation, Testing, and the Human Factor

28:21 - The Future: Agentic AI, Fundamentals, and Looking Forward

00:00:00 Introduction

00:01:27 key early lesson about automatability?  

00:01:56 separating automation issues vs. design issues?  

00:03:49 is slow UI a testability or automatability problem?  

00:06:50 handling non-automatable third-party widgets?  

00:09:20 assessing automation readiness - any framework?  

00:11:23 common architectural patterns that break at scale?  

00:13:37 prioritizing testability vs. automation in sprints?  

00:16:51 do modern tools reduce the need for good design?  

00:19:32 explaining automatability as an investment?  

00:21:44 how do AI agents handle dynamic/third-party elements?  

00:23:17 early signs a feature will be flaky when automated?  

00:26:10 which microservice layers to automate first?  

00:29:16 high-ROI automatability fixes for small budgets?  

00:30:55 early dev–test collaboration to prevent rework?  

00:34:08 thinking about automatability in continuous delivery?

Join the BrowserStack Discord community and discover more AMA sessions https://www.browserstack.com/community

Welcome to The Evil Tester Show! In this episode, host Alan Richardson dives into the complex world of test automation migrations. Have you ever wondered what it really takes to move your automated test execution code from one tool or language to another—like switching from WebDriver to Playwright, or migrating from Java to TypeScript? Alan breaks down the pitfalls, challenges, and best practices you need to consider before taking the leap. He explains why migrating isn’t just about copying test cases, how abstraction layers can save you time and headaches, and why using AI and solid design principles can streamline your transition. Whether you’re facing unsupported tools, evolving frameworks, or strategic changes in your testing approach, this episode offers practical advice to plan and execute a seamless migration—without burying new problems beneath old ones.

00:00 Migration Challenges

02:43 Tool Evaluation

04:05 Migrating to Playwright: Considerations

06:00 Migration Process

06:25 Migrate: Easy First, Hardest Next

09:37 Effective Migration Strategies for Tests

10:23 Focusing Abstractions

14:39 Optimize Test Code Migration

15:44 Focus on Abstraction, Not Auto-Healing

**1. Why Migrate—And When You Really Shouldn’t** Before any big move, Alan urges teams to get their “why” straight. Is your current tool unsupported? Is your framework truly incompatible, or are you missing some hidden potential? Migrate for the right reasons and make sure your decision isn’t just papering over problems that could follow you to the next tool.

**2. Don’t Confuse Migration with a Rewrite** Too many teams treat migration like a rewrite—often with disastrous results. Alan emphasizes the importance of planning ahead, solving existing flakiness and coverage issues _before_ you move, and carefully evaluating all options (not just the shiny new tool you think you want).

**3. The Secret Weapon: Abstraction Layers** The podcast’s biggest takeaway: Don’t migrate “test cases”—migrate _abstractions_. If your tests are full of direct calls like `webdriver.openPage()`, you’ve got work to do. Build out robust abstraction layers (think page objects or logical user flows) and keep your tests clean. When it comes time to migrate, you’ll only need to move those underlying layers, not thousands of individual test case scripts.

**4. Taming Flakiness and the Risks of Retries** Migration is not the time to rely on self-healing tests or retries. Any test flakiness _must_ be rooted out and fixed before porting code. Bringing instability into a new stack only multiplies headaches later.

**5. Harnessing AI—But Stay in Control** AI-assisted migration really shines at mapping old code to new, but Alan warns against “agentic” (hands-off) approaches. Use AI as a powerful tool, not as the driver—you need understanding and control to ensure things work reliably in CI/CD pipelines.

**6. Learn Fast: Tackle the Hardest Stuff Early** Pro tip: Once you’re ready, start your migration with the simplest test, just to get going—then dive into the hardest, flakiest, most complex workflows. You’ll uncover potential blockers early and kick-start team learning.

“We’re not migrating test cases when we change a tool. We’re migrating the physical interaction layer with our application... ”

It really depends on the recruitment process. But... if I'm recruiting, and you have a profile then I will have looked at it. So it better be good.

Most Software Developers and Testers don't have public portfolios so that means you can really stand out.

We'll cover the difference between different types of projects: A breakdown of project types: Learning Projects, Personal Projects, Portfolio Projects.

Lots of tips on how to adjust your Github profile and promote your projects.

00:00 Value of Portfolio

02:59 Stand Out Skills

09:19 Project Types

12:27 Showcase Projects

19:39 Promoting Yourself

21:44 Final Advice

Ever feel like you’re not getting the respect that you deserve in your job? This episode dives deep into the topic of Respect in tech, especially focusing on software testing versus programming.

We look at why some roles seem to earn more respect, what that means for workplace culture, and how you can change things for yourself and your team. Respect isn’t just about manners or titles - it’s about how the system works and how we show up in our roles.

If you’ve worked in agile projects, you might have heard, "Everyone is a developer." But some roles seem to get more recognition than others. Is this because of how we define our jobs, or is it just baked into the way our workplaces run? This episode is a call to action, urging everyone to look at respect both at a personal, process and craft level.

We’re breaking down the difference between self-respect, respect for others, and respect built into your team’s process. You'll see why just doing your job isn’t enough. You have to own your craft, communicate what you do, and make your contributions visible to earn genuine respect. By the end of this episode, you'll have practical steps to make respect part of your daily work, whether you’re writing code, testing, building products, or managing.

00:00 Respect Dilemma

02:41 Human Level Respect

06:31 Self-Respect First

10:17 Respect Cycle

15:37 Knowledge Sharing

18:53 Respectful Organizations

21:26 Final Thoughts

In this packed hour-long conversation, we cover everything from market trends, LinkedIn networking, and the recruitment pipeline, to building a career roadmap and even the AI hype machine. Grab your notebook, settle in, and get ready for real insights you can use – plus a few stories from the trenches and actionable tips for every step of your job hunt.

In this conversation, your host Alan Richardson chats with James about the essence of practice in software testing, exploring how exercises and real-world scenarios can enrich our skills. James shares insights on his weekly online practice sessions and the interactive Test Lab concept, offering a dynamic playground for testers.

Discover how practice blends with rehearsal and learning, and delve into the intriguing intersection of testing and development. With firsthand experiences in software experiments, fencing, and scientific investigation, James and Alan discuss the art of modeling and exploring software systems. Whether you're refining your testing techniques or embracing new perspectives with AI, this episode offers a wealth of wisdom for testers at all levels.

Join us as we learn, laugh, and explore the world of testing practice. We hope you find inspiration for your own practice sessions. Don't forget to check out James's resources at https://workroom-productions.com for more testing challenges and exercises.

In this episode of The Evil Tester Show, host Alan Richardson describes context-driven testing. Is there really such a thing as context-driven testing, or is it just a phrase we use to describe our testing approach? Alan explores the intricacies of context in testing, discussing its evolving nature, the impact of context on testing practices, and the challenges in defining it.

From the origins of the term by James Bach, Brian Marick, Brett Petichord, and Cem Kaner, to Alan’s personal insights on systems within systems and how context impacts our testing methodologies, this episode provides a comprehensive look at how context affects software testing. Alan also critiques the principles of context-driven testing and emphasizes the importance of adapting to projects without being swayed by ideologies.

We explore how to navigate context in testing environments, adapt our approaches, and effectively challenge and evolve systems. Discover the importance of context-driven testing in software development, exploring models, adaptability, and useful practices.

This episode covers the Test Automation Pyramid, created by Mike Cohen in 2008-2009 in the book "Succeeding With Agile". We will go beyond the diagram and look at the model that supports it. Then deep dive into the model to explore it's meaning in relation to Automated Execution Coverage, not Testing.

- The model was created by Mike Cohen in 2008-2009 in the book "Succeeding With Agile."

- The original model focused on UI, service level, and unit level automation.

- Over the years, different interpretations and variations of the model have emerged.

- The term "service level" in the model has led to ambiguity and different interpretations.

- The diagram in the model is a simplified representation of a deeper underlying model.

- The focus should be on achieving coverage at the most appropriate level in the system.

- The model addresses the importance of avoiding duplication and redundancy in automated coverage.

- The process and team structure can impact the effectiveness of the model.

- The model can be reframed as an automated execution coverage pyramid.

The most common Testing Entities that I've encountered over the years are:

• Test Condition
• Test Scenario
• Test Case
• Test Script

In my Testing I pretty much now have:

• Test Idea
• Test Log (Execution Log)

Is there any value in the original Testing Entities? There might be if we view them as logical concepts, but not really as physical artifacts.

Top 3 Phrases that should carry trigger warnings for the Test Community:

- Manual Testing

- Test Automation

- Quality Assurance

In this episode I'm going to talk about Manual Testing.

So that's your Trigger Warning.

And I'm going to talk about what we might want to say instead of "Manual Testing"

Manual QA is dead. Companies are getting rid of their QA teams. Quality Control performed manually is phasing out of style. What can we do instead? Become coaches, assistants or advisors? We could become developers? Or we could be better testers. QA and Quality Control is not Testing. This might be how people learn.

In episode 16 of The Eviltester Show we are looking at Test Automation Biases, what they are, how to avoid them, and how to evaluate your own biases.

00:00 What is an Automation Bias?

00:29 Treat all opinions as biased

01:50 Automating a GUI is Slow and Flaky

03:36 Automate through the API

05:23 Code Free Automating is Bad

06:17 Tool X is Better than Y

07:04 Postman is Better than Insomnia

08:54 Python is Better than Java

10:24 Seeing Through Biases

12:52 Try it, then decide

13:17 Page Objects vs Screenplay

14:52 Take Responsibility

16:11 External Experience

17:02 Start Small, Make Progress

17:50 Do not ignore issues

20:34 Be Real rather than Believe

21:18 Keep Options Open

22:48 Be Aware of your biases

23:19 It takes time

In this episode we have a discussion of a UK government guide to exploratory testing.

• https://www.gov.uk/service-manual/technology/exploratory-testing

The aim is not to criticise the document, the aim is to use it as a base from which to see how far our thoughts diverge or overlap with the document. I want to know what I can learn.

Show notes are here:

https://www.eviltester.com/show/015-exploratory-testing-gov/

This podcast, was originally released to Patreon supporters in January of 2019,

• https://patreon.com/posts/what-is-testing-23907385

I read through the document and try to understand the intent and meaning behind statements and offer my own thoughts.

- remove as much ambiguity from your job spec as possible

  - someone like me, will read 'the worst' into your ambiguity

- send clear messages, not mixed messages, in the job spec

- help the applicant filter out roles that are not suitable for them

- when writing a job spec, review existing job specs in the world, critique them and then build on what is best from those

- start with a phone interview, never start face to face

- some people bluff, some people offer general answers

  - your job as an interviewer is to help them answer specifically and ask for more information when you want it

- Interviews as auditions, held by someone who knows how to do the activity being auditioned

- audition hands on with the actual code, or the actual system

- use your best people for the interviews, not just anyone that is free

Show Notes:

https://eviltester.com/show

We have more posts in our recruitment category:

- https://www.eviltester.com/categories/recruitment/

And our Career category:

- https://www.eviltester.com/categories/career-advice/

This video was originally released as a Patreon exclusive video back in January 2019

- https://www.patreon.com/posts/recruitment-tips-23896867

- Getting a Job is different from Doing the Job

- Persistence is key to getting a job

- Build an online portfolio on LinkedIn

- Apply for jobs slightly out of reach

- Amend your CV for each job that you really want

- You do not need to code to Test Software

- You might need coding skills on your CV to pass the interview filter

- Demonstrate that you can test software, even if you are looking for your first job in software testing.

Shownotes are available from https://eviltester.com/show

This is an audio/video episode and the video version is available on youtube:

https://youtu.be/QB8n5RXTV10

Direct Show Notes Link:

https://www.eviltester.com/show/013-how-to-get-a-job-in-testing/

More and more conferences are going online. Speakers will have to adapt. In this post I outline some recommendations based on years of online video, webinar and course creation.

If you only want the summary then...

- Presenting online over video is different.

- Practice will help.

- Practice with the kit you are going to use, and perform complete practice run throughs.

- Use an external microphone.

- Record your practice sessions and listen back to them to make sure your audio is good enough. 

For show notes, visit https://eviltester.com/show

And that's what I cover in this podcast.

Points:

- we should not have to think like this

- But - we need to get a job

- Getting a job is different from "What should I be..."

A full transcript of the show has been upload for Patreon supporters. https://www.patreon.com/posts/35209341

You can support this Podcast, and receive almost daily blog posts by signing up to https://Patreon.com/EvilTester for as little as $1 a month.

Show notes are available at https://eviltester.com/show

I receive a lot of concerned emails and messages from testers. People concerned that their testing skills will not be enough to keep them in work and that the future revolves around automation which they don't know how to do. No programming experience. And should they learn API or UI? What programming language should they learn? People do feel that their career is at risk.

And that's what I cover in this podcast to hopefully give you some tips if you do want to learn to program or code and start working on test automation, and some tips on what to do if you don't and think that software testers should not have to learn to code.

There are many paths to success in testing.

Show notes available at:

https://eviltester.com/show

"Why?" is an incredibly popular question. I think it has problems. I try to avoid it when I'm consulting. In this show we will examine "Why?" and under what circumstances I do use it. "Why?" is almost a default question because it can take the place of every other question. It is easy to ask. We don't even need to know what answer we want. It's also a very ambiguous question, and when we ask why there is a risk that people try to read into our motivation, and that people might take offence. Show notes will be available at https://eviltester.com/show

Have you ever built a tool list?

Yes? Me too. I don't any more. And in this show I explain why, and what I do instead.

Show notes are over on:

http://eviltester.com/show/007-finding-tools-2019/

---

You can support me on Patreon https://patreon.com/eviltester (and receive extra content)

Hire me for consultancy and buy my online books and training at:

- https://compendiumdev.co.uk

- https://eviltester.com

Have you ever used a workaround to get something done? You betcha. In this show I describe some examples and how important they have been in my testing and my career. And some of the risks you face when you use them. Show notes are over on: http://eviltester.com/show/006-workarounds-2018/ --- You can support me on Patreon https://patreon.com/eviltester (and receive extra content) Hire me for consultancy and buy my online books and training at: - https://compendiumdev.co.uk - http://eviltester.com - http://seleniumsimplified.com - http://javafortesters.com

You will receive rejection in many parts of your life. Happens to everyone. Everyone. The important thing is how you react to it. It is possible to allow a rejection to knock you flat and suck the motivation out of you so you give up. You have to understand that that reaction is a choice. And giving up, is probably the wrong choice.

In this podcast we will cover other choices you can make and strategies you can adopt to deal with and handle rejection.

* How to develop resilience

* How to handle rejection

* Sales is “get the right offer, in front of the right person, at the right time”.

* Rejection is built in to the sales process.

* Nature abhors a vacuum how to avoid doubts filling a confidence vacuum

---

You can support me on Patreon https://patreon.com/eviltester (and receive extra content)

In this show you will learn:

- What is a resolution?

- why do you want it?

- how your beliefs help you

- how your testing skills help you define goals and create action plans

- Big goals or small goals?

- how to explore progress on goals as value add chunks

- Prioritise and learn to say NO

- Books for Questioning - The Structure of Magic - vols 1 and 2

- see also "NLP for Testers" https://www.compendiumdev.co.uk/page/nlp

Show Notes at EvilTester.com.show

- What is provocative therapy?

- The Goals of provocative therapy

- Humour in provocative therapy

- How to use provocative therapy as a consultant

- What is the tester's role in modern software development?

- Why are people confused about a Tester's role on Agile?

- Why is Agile Testing Hard?

- Why will Quality Coaching help?

- What does a tester really do?

- What makes a good tester different from other people on an Agile team?

- What are the dangers with Test Coaches?

- How do we define our own role on Agile Projects?

- What does a tester do on Agile Projects?

- Can programmer's test their own code?

Show notes at http://eviltester.com/show

http://eviltester.com/show/002-provocative-2017