Intermediate4 phases · 11 topics · ~8 weeks

AI-augmented QA engineer

Four phases from understanding what AI can and can't do for QA, to assembling a personal toolkit you actually rely on. Covers AI-assisted test authoring, Playwright MCP, Claude Code workflows, and the limits worth knowing before you delegate too much. Around 8 weeks at a steady pace. Assumes you already write automated tests in some language.

Phases
Phase 01

Foundations

AI is everywhere in QA discourse and most of it is noise. Build the mental model first so you can spot what's actually useful for your work.

A mental model for AI in QA

If you treat an LLM like a search engine, it'll disappoint you. If you treat it like a senior colleague who hallucinates 5% of the time, you'll get a lot done.

You'll learn to

  • Explain what an LLM does (and doesn't do) in one paragraph
  • Identify the QA tasks where AI gives 5x speedups, and where it gives nothing
  • Recognise hallucination patterns specific to test code
  • Decide when to trust AI output, when to verify, and when to discard
  • Frame AI as a force-multiplier, not a replacement

Prompting fundamentals for testing work

Most 'AI doesn't work for QA' complaints are really 'I asked it badly'. Prompting is a skill you can learn in an afternoon and refine for years.

You'll learn to

  • Structure prompts: context, task, constraints, examples
  • Use few-shot examples to anchor output style
  • Specify the test framework, language, and conventions explicitly
  • Iterate on output through follow-up turns, not single shots
  • Build reusable prompt templates for recurring tasks
Phase 02

AI-assisted test authoring

Where AI gives most testers their biggest day-one win: writing test code faster, from artefacts you already have.

Generate tests from requirements and specs

Most teams already have stories, acceptance criteria, or Gherkin scenarios sitting unused. AI turns them into real test code in seconds.

You'll learn to

  • Convert a user story into a Playwright or Cypress spec
  • Generate test data sets from a written description
  • Produce edge-case scenarios you would have missed
  • Match the output to your existing project's conventions
  • Review and refactor AI output before committing

Generate tests from screenshots and Figma

Visual artefacts carry intent that text often misses. Modern multimodal models read a mockup and produce a sensible first-pass test.

You'll learn to

  • Hand a screenshot to a multimodal model and get usable selectors back
  • Convert Figma flows into end-to-end test outlines
  • Spot what the model can and can't infer from a visual
  • Use the output as scaffolding, not finished code

Review and improve AI-generated tests

AI-generated test code is fast but often shallow. The senior skill is editing it into something maintainable.

You'll learn to

  • Spot brittle selectors and replace them with stable alternatives
  • Identify implicit waits, hard-coded timings, and other smells
  • Refactor toward the project's patterns (POM, fixtures, helpers)
  • Add assertions the model didn't think of
  • Catch hallucinated APIs and method calls before they break the build
Phase 03

MCP and agentic workflows

Stop copy-pasting between chat windows and your editor. Wire AI directly into your test runner, your repo, and your browser.

Playwright MCP for browser automation

MCP lets an AI agent drive a real browser, read pages, and take actions. The leap from 'AI suggests test code' to 'AI runs the test and reports back'.

You'll learn to

  • Set up the Playwright MCP server locally
  • Connect it to Claude Code, Cursor, or another MCP-aware client
  • Use the agent to explore an app and propose test cases
  • Have the agent run tests and read failure output
  • Know the limits: when MCP helps, when it adds friction

Claude Code for repo-wide QA tasks

When you need to refactor 200 test files, add coverage for a new feature across a service, or migrate from Cypress to Playwright — a chat window can't help. Claude Code can.

You'll learn to

  • Run Claude Code against a real test repo and stay in control
  • Delegate large refactors with clear acceptance criteria
  • Get the agent to read your code conventions before writing more
  • Review diffs critically — assume nothing without reading
  • Build a workflow where the agent reports progress at each step

Assemble your AI toolkit

The win isn't any one tool. It's the workflow: a code assistant in your editor, an MCP server for your stack, a prompt library you trust, and the judgement to know which to reach for.

You'll learn to

  • Pick a code assistant that fits your codebase and team
  • Set up MCP servers for the tools you actually use
  • Maintain a personal prompt library for recurring tasks
  • Know when to drop AI entirely and just write the code
  • Share the workflow with your team in a way they'll adopt
Phase 04

Quality, safety, and limits

Knowing where AI fails is what separates a serious adopter from a hype-driven one. This is the phase that makes you trusted, not just fast.

Validating AI-generated tests

An AI-generated test that runs green tells you nothing if the test asserts the wrong thing. Most failures hide in plausible-looking code that doesn't actually test the behaviour.

You'll learn to

  • Write a checklist for reviewing AI test output
  • Use mutation testing or similar to expose weak assertions
  • Catch silent failures: tests that pass when they should fail
  • Cross-check the generated test against the requirement
  • Decide what level of human review each AI artefact needs

What AI can't (and shouldn't) replace

Optional

Exploratory testing, ambiguity-spotting, stakeholder conversations — these are the parts of QA that resist automation. Knowing which is which protects your career as the tools improve.

You'll learn to

  • Name the QA work AI is bad at and explain why
  • Defend exploratory testing as a high-value human activity
  • Recognise when teams over-delegate and what they lose
  • Position yourself for the work AI makes more valuable, not less

Data privacy and code-leak risks

Pasting prod data or proprietary code into a hosted LLM is a security event waiting to happen. Knowing the policies and the alternatives matters.

You'll learn to

  • Read and apply your company's AI usage policy
  • Identify what can and can't be pasted into a hosted model
  • Use local or enterprise AI offerings when sensitivity demands
  • Mask or fake data before sharing it with any model
  • Recognise the difference between training-on-input and not

What's next