Tesena Fest 2026, 24. - 25. 9., Prague

About the Workshop 

As release cycles get shorter, teams need test feedback they can trust quickly. GUI tests are valuable, but expensive. For many scenarios, API tests give better speed, lower cost, and more stable execution - which makes them a strong foundation for CI/CD feedback. 

In this hands-on workshop, we’ll use Claude Code and Superpowers to build a practical API testing workflow. We’ll start from a GitHub issue, let an AI coding agent inspect the API documentation and existing tests, then generate or update automated API tests. You’ll also try how AI can help with work that usually takes time: finding missing coverage, reviewing API contracts, and analysing failed pipeline runs from logs and test artifacts. 

The goal is not to replace your testing skills. The goal is to show how AI can handle part of the repetitive work, while you stay in control of the design, review, and final decision. 

What You’ll Learn 

• How to use Claude Code for API testing tasks  
• How to write GitHub issues that agents can work with  
• How to generate and review API tests from OpenAPI (or any other) documentation  
• How to find missing API test coverage  
• How to analyze failed API tests from CI logs and artifacts  
• How to use Superpowers for repeatable testing workflows  

Walk Away With 

• A working AI-assisted API testing workflow  
• Example GitHub issues for agent-based test automation  
• Reusable Superpower templates for API testing  
• A practical failure analysis workflow for broken API tests in CI  

Who Is This For? 

QA engineers, test automation engineers, developers, and anyone working with API testing. 

You don’t need to be an AI expert. But basic experience with APIs, Git, and automated tests will help. 

What You’ll Need 

Please bring your own laptop. You’ll also need: 

• Claude AI license, ideally Pro/Premium or higher.
• a GitHub account  
• Git installed  
• Node.js LTS installed  
• a code editor, ideally VS Code

If you don’t have a Claude Code licence, don’t worry - we’ll have a backup setup ready, so you’ll still be able to participate.

About the Workshop

The only constant in both our personal and working lives is change. Yet many people find dealing with change hard, even when the change is positive or clearly necessary.

In our experience, the most difficult part of any transformation is not the process, structure, or technology. It is the people part.

In the software testing and quality assurance domain, we are dealing with increasingly complex and fast-moving changes. These may involve centralisation or decentralisation, growing demand for automation, the adoption of AI, agile transformation, or a post-Agile transition towards Software Engineering or Product Engineering models.

If any of this sounds familiar, you are not alone, and you do not have to manage these changes without support.

This workshop focuses on the practical skills you need to lead teams through change with confidence. Through interactive exercises and discussions with peers, you will explore how to create the right conditions, communication practices, and team dynamics to make change a shared opportunity rather than a cause of friction or resistance.

Who is this workshop intended for?

This workshop is designed for anyone challenged with leading teams through change. It is especially relevant if you are moving beyond traditional testing to models that encourage stronger collaboration and shared ownership of quality across teams.

This may include, for example:

• Test Managers and QA Leads
• Engineering Managers
• Product Managers and Product Owners
• Delivery Managers and Project Managers
• Heads of QA and Heads of Engineering

Key Topics 

• Understanding change. Why do people struggle with change, even when it is positive or necessary?
• Changing roles. How to take the first step towards a different mindset, for example from Quality Gatekeeper to Quality Partner.
• Preventing misunderstandings. How to communicate clearly and make yourself understood.
• Strengthening team collaboration and communication. Exploring these through a practical and enjoyable game.
• Building team chemistry. How to create a strong cross-functional team and give it the space to work independently.
• Using feedback effectively. Why feedback is a cornerstone of effective teamwork and change.
• Enabling change. How to support people as they go through change.

What You Will Gain

This workshop gives you a practical space to reflect on how you currently lead your team through change, learn from peers facing similar challenges, and explore how to create the conditions in which change is understood, accepted, and supported rather than resisted.

 You will leave with practical knowledge, new perspectives, and ideas that can help you and your team move beyond simply reacting to change and become more confident and adaptable when facing future transformations.

Do you think you know test automation. You wrote the scripts. You fixed the locators. You survived the flaky pipelines. You thought you were fast. 

You had no idea. 

This is not a workshop about what AI might do to testing. This is a workshop about what it is already doing and why your current setup is about to look like a Honda Civic at a drag race. 

We go full throttle from minute one. Playwright. Playwright CLI. Playwright MCP. Wopee.io. AI coding agents writing your tests while you watch. AI testing agents running them while you sleep. API testing that does not wait for anyone. 

Same app. Different tools. Head-to-head. You pick the winner. 

Some tools will surprise you. Some will disappoint you. One will make you question every afternoon you spent chasing broken selectors. That moment. That specific moment. It is why you are here. 

By the end of the day you will have built something real, broken something on purpose, and learned more about the new testing stack in eight hours than most teams figure out in a year. 

What you will do 

• Run Playwright the traditional way, then via CLI, then via MCP and see exactly what changes at each step 
• Experiment with Wopee.io as a purpose-built AI testing agent on the same app, same task direct comparison. 
• Wire an AI coding agent to generate, run, and interpret tests autonomously 
• Write a SKILL.md that encodes your team’s testing knowledge so any agent can reuse it 
• Get hands-on with AI-assisted API testing. Same agent concepts, one layer below the UI 
• Build a working test suite your team can actually use next week 

What you will walk away with 

• First-hand experience with the tools shaping web app testing in 2026 
• A working AI-assisted test suite you built yourself 
• A SKILL.md your agent can run cold, without handholding 
• A clear answer to the question your team keeps asking: where do we actually start? 

How the day runs: No death by slides. The day has 4 gears. 

1. The Zoo: 4 exhibits. Same demo app. Playwright CLI, Playwright MCP, an AI coding agent, and Wopee.io. One at a time, side by side. Every tool gets the same fair test.
   
   
2. Teams and mission: Before lunch you get assigned to a team and handed a mission card. Lunch is yours. But your team is already talking.
   
   
3. Build 1 thing: 90 minutes to build a real AI-assisted test suite. Including a reusable capability your agent can run cold, without guidance. This is the thing you take home.
   
   
4. Speed gap battle: 3 new features just shipped on the demo app. Your suite is your only weapon. 45 minutes. Maximum coverage wins.
   
   

Not a fit for you if… 

You have never written an automated test before. This workshop moves fast and assumes basic Playwright or Cypress experience. 

You are looking for a vendor comparison or a product demo. Every tool gets the same fair treatment. Including the ones we built. 

About the Workshop

This updated version of our workshop shifts the focus more firmly toward practical quality engineering skills you can apply immediately. While the core idea remains the same - building quality into your process rather than testing it at the end - we now place greater emphasis on hands-on exercises and real-world application.

You’ll work through a series of focused activities designed to reflect common delivery challenges: balancing speed and quality, working within constraints, improving flow, and making better engineering decisions under pressure. Short theory inputs will frame each topic, but most of the day is dedicated to practice, discussion, and applying ideas to realistic scenarios.

Because every group moves at a different pace, the exact mix of topics will adapt during the day. This allows us to go deeper where it matters most, rather than covering everything superficially.

What to Expect

A dynamic, exercise-driven workshop combining:

• Short, targeted theory segments to introduce key concepts
• Practical group exercises focused on real delivery problems
• Facilitated discussions to connect ideas to your own context

You’ll explore how to:

• Improve flow and reduce inefficiencies in your process
• Identify and manage quality risks early
• Apply modern engineering practices that support quality at speed
• Strengthen team collaboration around quality

Three Things You’ll Take Away:

Practical Quality Engineering Skills
 Techniques you can start using immediately in your team - not just theory.

Better Decision-Making Under Constraints
 How to balance speed, risk, and quality in real delivery situations.

A Clearer Path to Building Quality In
 Concrete ideas for evolving your current approach toward quality engineering.

Why This Workshop?

You won’t just talk about quality - you’ll think about quality differently. You'll leave with the experience and approaches that you can start applying in your own team and environment.

AI can write code, draft content, and answer almost anything in seconds. What it hasn’t earned yet is judgment: knowing when a technically correct answer is still unsafe, incomplete, biased, or wrong for the moment. In this session, we’ll look at what AI genuinely changes, where human judgment still makes the difference, and what quality leaders need to validate before putting AI in front of real users.

You’ll learn:

• Where AI is a force multiplier, and where it isn’t

• What separates AI capability from AI trustworthiness

• What quality leaders need to test and validate before AI reaches real users

• How the human role is changing as AI gets embedded deeper into software

In the fast-paced world of software development, the question 'Quis custodiet Ipsos custodes?' or 'Who watches the watchmen?' resonates strongly. While automated tests serve as vigilant guardians of software quality, it's vital to ensure that they too are effectively monitored. This talk explores how trivago employs a suite of powerful tools to oversee test performance and outcomes.

We will look at the integration of tools like Cluecumber reporting, Kafka, the Elastic Stack, Grafana, and Slack to create a dynamic monitoring environment. Discover how these tools help us gain real-time insights, swiftly identify issues, and maintain the high quality of our software. Beyond traditional monitoring, this solid data foundation has recently proven its value in a new way: enabling AI-driven test failure analysis that turns raw test signals into actionable insights and drives meaningful quality improvements.

Participants will gather ideas on how to set up a comprehensive test monitoring system using our tried-and-tested methods and tools.

I asked an AI assistant to help me with a database query. The code came back clean. Well-structured. It passed my first review. It also had a vulnerability that could have exposed our entire user database.

My first reaction wasn't, 'Let me check this carefully.' It was, 'This looks really good.'

That's still true. But it's not where the danger is anymore. In 2026, the attacks that matter don't come from what the AI wrote. They come from what it read, and what you let it touch.

This session is a detective hunt for testers, QA engineers, test leads, and anyone who reviews or approves AI output. One case. Three suspects. Real evidence from real 2026 breaches, up on screen. You try to spot what's wrong before the reveal. One of them you won't catch. Neither did the people it happened to.

What we'll cover:

• What a clean security scan actually proves
• How an attack reaches your AI agent without touching your code
• The three cognitive traps that make all of this easy to wave through

I've fallen for all three. Chances are, you have too.

You'll leave with:

• A better way to look at AI tools than 'does it look right'
• Three habits you can use without asking anyone's permission
• One question to raise the next time your team adds an AI tool

AI is changing how software gets built, but the real story is happening behind the scenes. As teams experiment, adapt, and rethink their workflows, not everything lives up to the promise.

This panel brings together a mix of engineering and leadership perspectives from top companies, offering a grounded view on what actually holds up across the software lifecycle from development to testing to delivery. Beyond the AI hype, it reflects real-world experience, trade-offs, and lessons learned under pressure.

Because the real question isn’t just what AI changes, but what else is quietly redefining how software gets built today.

99.59%.
That’s not uptime, not coverage - it’s our yearly stability rate of mobile end-to-end test runs. Almost perfect. Almost unbelievable. Especially after three years of endless debugging, failing builds, and a growing Slack thread titled #iHateMobile.

This talk is a story - but also a survival guide - for anyone who’s ever wanted to throw their test phone across the room. It’s about turning unreliable, flaky chaos into a system that’s fast, predictable, and trusted by developers and managers alike.

We’ll start where it hurts:

Phase 1 – The chaos. Appium and WebdriverIO giving us nightmares - element interaction timeouts, deep-layer selectors that vanish, “TouchableOpacity” not being so touchable. The usual suspects, multiplied by hundreds of test cases and dozens of devices. I’ll show how we diagnosed the real causes of instability and how small framework-level fixes snowballed into huge stability gains.

Then comes phase 2 - the great optimization. Once the framework stopped screaming, we focused on speed and cost. Data seeding through APIs instead of UI clicks. Custom app states and DB shortcuts. And our proudest creation - a homemade device-thread balancer that decides how many tests to run, where, and when, saving both time and money.

Next up, phase 3 - testops and devops join the party. We automated everything around testing: app building, downloading, device-farm uploads, CI triggers, even tagging pull requests to auto-launch tests. It’s where manual setup finally died, and “one-click testing” was born.

Finally, phase 4 - flexibility and trust. We added real-world smarts: handling conditional popups, feature flags, experiments, and 2FA flows that used to break everything. This turned our test suite from a rigid framework into something dynamic - something that works with the product, not against it.

And because tools alone don’t fix culture, the last part is about people - the skeptics who thought E2E testing was a waste, the processes that slowly built trust, and the moment when “just run it” became the team’s favorite phrase.

If you’ve ever struggled with flaky mobile tests, this talk will show you that the pain can end - with patience, curiosity, and a few clever hacks. You’ll leave with real techniques, architecture ideas, and maybe even the motivation to start your own “painful but worth it” journey toward outstanding stability.

1. Introduction to the case
A quick look at where we started, what stability really means in mobile E2E testing, and why it was such a painful problem to solve.

2. Phase 1: The chaos
Early challenges with Appium and WebdriverIO, the most common sources of flakiness, and how we started fighting back.

3. Phase 2: The great optimization
Speeding things up and cutting costs with smarter data handling, app state setup, and device management.

4. Phase 3: TestOps and DevOps join the party
Automating everything around testing, including builds, uploads, and CI triggers, and finally reaching the dream of one-click testing.

5. Phase 4: Flexibility and trust
Making the framework adaptive and reliable while building trust with developers and product teams.

6. Wrap-up
Key lessons, mistakes, and mindset shifts that turned chaos into confidence, and how others can follow the same path.

Key learnings:

• Root Cause Analysis: Techniques for diagnosing the real source of mobile flakiness (it's not always the device).
• Speed vs. Stability: How to use API seeding and backend shortcuts to stabilize frontend tests.
• DevOps Integration: Blueprints for a 'device-thread balancer' that optimizes cost and speed.

 Culture: How to build trust with developers so they treat E2E tests as an asset, not a blocker.