Skip to content
Winter Sale from $619, until 31st December 2026 Book now
Agentic coding workshops iOS + Android

Agentic Testing Workshop: Coding Agents That Write, Run and Fix Your Tests

Coding agents can write unit tests, draft UI test flows, reproduce bugs and repair flaky tests – but they also produce tests that pass without proving anything. An agentic testing workshop teaches QA engineers and developers to hand agents the volume work while people keep control of what gets tested, how failures are judged and when a red test may be changed.

6 min read

Key takeaways

  • Agents are strong at test volume – edge cases, fixtures, characterisation tests for legacy code – and weak at deciding what correct behaviour is.
  • The most common failure is a test that mirrors the code instead of the requirement; reviewers must learn to spot it.
  • A bug-first workflow – the agent writes a failing test that reproduces the report before anyone fixes it – is the single most useful habit.
  • On mobile, agents need simulators, emulators and stable accessibility identifiers to work on UI tests; human testers on TestFlight and Play testing tracks remain essential.

Where agents help in testing – and where they hurt

Agents are good atAgents are risky at
Writing many unit tests for well-specified functionsDeciding what the correct behaviour is when the spec is silent
Characterisation tests that pin down legacy behaviour before a refactoringDistinguishing a bug from intended behaviour in that legacy code
Generating fixtures, test data builders and mocksMocking so much that the test checks nothing real
Reproducing a bug from a clear reportInterpreting a vague report without asking
Diagnosing a failing CI run from its logs"Fixing" the failure by changing the test
Drafting UI test flows from a written scenarioKeeping UI tests stable when selectors are fragile

The workshop is built around this split: use agents hard on the left column, put guardrails on the right.

Spotting weak agent-written tests

A green suite only helps if the tests can fail for the right reasons. Participants practise recognising the patterns that agents produce most often:

  • Mirror tests. The expected value is computed with the same logic as the code under test, so a bug in the logic passes.
  • Snapshot of the bug. The agent ran the code, saw the output and asserted it – including the defect.
  • Everything mocked. The test verifies that mocks were called, not that anything works.
  • Assertion-free tests. Code runs, nothing is checked; coverage rises, confidence shouldn't.
  • Silent weakening. A failing assertion loosened, a test skipped or a retry added to hide flakiness.

Mutation testing is a useful check here: tools such as PIT for JVM languages or Stryker for JavaScript and TypeScript change the code slightly and see whether any test notices. A suite of agent-written tests that survives many mutations needs a human look. Our article on reviewing agent-generated code adds the code-side view.

Talk to an AI Code Engineer about your agentic coding workshop.

In a free call we look at your team, your codebase and your goals and suggest a workshop format that fits – remote or on-site, in English or German.

The bug-first workflow

If the team takes only one habit home, it should be this one:

  1. A bug report comes in with steps to reproduce.
  2. The agent writes a test that reproduces it – and must show that the test fails on the current code.
  3. A person confirms the failing test describes the bug, not something else.
  4. Only then does the agent, or a developer, fix the code until the test passes, without changing the test.

This keeps agents honest, because the test is fixed before the fix exists, and it leaves a regression test behind for every bug. Teams also add a rule to their context file: the agent may never change a failing test and the code under test in the same step without saying so explicitly.

Workshop agenda

  1. Test strategy with agents – which layers to automate more now that writing tests is cheap, and which to keep manual.
  2. Unit and integration tests – generating tests from specs and acceptance criteria, then reviewing them for the weak patterns.
  3. Legacy safety nets – characterisation tests before a refactoring, with a human deciding which current behaviour is intended.
  4. Bug-first lab – real or prepared bug reports, worked through the four steps above.
  5. UI tests – agents drafting and maintaining UI flows on simulators, emulators or in the browser.
  6. CI and flaky tests – letting agents triage failures and propose fixes, with rules for what they may change.

Each block uses the participants' own repository where possible; the context file and rules they write during the day stay in it.

Mobile UI tests with agents

App teams get the most value – and the most frustration – from UI tests. A few conditions make agent help work:

  • A runnable environment. For iOS, XCTest and XCUITest need a Mac with Xcode and a simulator, either locally or on a macOS CI runner; a Linux-only cloud agent can't run them. Android instrumented tests with Espresso or Compose UI testing need an emulator or a device.
  • Stable selectors. Accessibility identifiers on every interactive element. Agents write far better UI tests when they don't have to guess which button is which – and accessibility improves as a side effect.
  • Readable flows. Cross-platform tools such as Maestro describe flows in YAML, which agents draft well and humans review quickly.
  • Device coverage elsewhere. Device clouds and Google Play's pre-launch report test builds on real hardware; agents don't replace that.

And human testers stay part of the loop. Our playbooks on TestFlight for AI-built apps and Google Play closed testing show how to turn tester feedback into tasks an agent can work on. For platform-specific setups, see the workshops for iOS developers and Android developers.

What changes for QA engineers

When agents write most test code, QA work shifts rather than shrinks. The valuable skills become test strategy, defining what "correct" means for unclear cases, designing test data, exploratory testing that finds what nobody specified, and reviewing agent-written tests with the same rigour as production code. QA engineers who can direct agents often end up with broader, more meaningful suites than before.

The workshop runs remotely or on-site, in English or German, for QA teams, developers or both together – mixed groups work well because the review habits need to be shared. It pairs naturally with the AI code review workshop. When the tests are green and the release is next, our AI Code Engineers can take over signing, store listings and review. Book a free call to adapt the agenda to your stack.

Rules for agent-written tests

  • Every bug fix starts with a failing test that reproduces the report.
  • Agents never change a failing test and the code under test in the same step without saying so.
  • Expected values come from the requirement, not from running the code.
  • Mocks replace external systems only, not the logic under test.
  • Skipped tests, loosened assertions and added retries are listed in the pull request description.
  • Interactive UI elements have stable accessibility identifiers.
  • Mutation testing or a human spot check runs on agent-written suites from time to time.

Frequently asked questions

Will coding agents replace QA engineers?

They replace much of the typing, not the judgement. Deciding what to test, what correct behaviour is and whether a test proves anything stays with people, and those tasks become more important when test code is cheap to produce.

Which test frameworks does the workshop cover?

The ones your team uses. Typical stacks are XCTest and XCUITest for iOS, JUnit, Espresso and Compose UI tests for Android, Jest or Vitest and Playwright for web parts, and Maestro for cross-platform mobile flows.

Can a cloud coding agent run our iOS UI tests?

Only if it runs on macOS with Xcode. Most cloud agents run on Linux, so they can write iOS tests but not execute them; the tests then run on a Mac or a macOS CI runner, and the agent works with the results.

Is code coverage a good measure for agent-written tests?

Coverage shows what code was executed, not whether anything was checked. Agents raise coverage easily, so combine it with review and occasional mutation testing to see whether the tests can actually fail.

Free, 15 minutes, no obligation

Plan your agentic coding workshop with us.

Our AI Code Engineers run hands-on workshops on Claude Code, OpenAI Codex, Cursor and AI app builders – and ship apps to the App Store and Google Play every week. Tell us about your team.

AI tools, store policies and requirements change quickly – always check the current documentation of the tools and stores you use. This article is independent advice and not affiliated with or endorsed by Apple, Google, Anthropic, OpenAI or any other company or product mentioned; all trademarks belong to their owners.

Workshop for your team?

Talk to an AI Code Engineer – free, 15 minutes, in English or German.

Book a call for free

Chat and hotline are open 24/7. Answers from our senior AI Code Engineers (real humans) usually take closer to 72 hours than 1 hour.