DEV Community: AutomationDataCamp

ISTQB CT-AI vs CT-GenAI: which AI certification should a tester take?

AutomationDataCamp — Fri, 02 Oct 2026 00:57:24 +0000

ISTQB offers two certifications around artificial intelligence, and their names are easy to mix up. CT-AI ("AI Testing") certifies the ability to test AI-based systems: data, machine learning models, generative AI systems. CT-GenAI ("Testing with Generative AI") certifies the ability to use generative AI to test: prompting, risk management, LLM-powered tools. CT-AI version 2.0, released on 17 April 2026, made that boundary clear. This guide compares both with official figures and helps you choose.

CT-AI = testing AI; CT-GenAI = testing with AI. Since CT-AI v2.0, "using AI for testing" belongs to CT-GenAI.
Same prerequisite: the CTFL (Foundation Level) certification.
Same exam format: 40 questions in 60 minutes; CT-AI v2.0 pass mark is 29 out of 44 points, CT-GenAI 30 out of 46.
CT-AI v1.0 is retiring: English exam until 21 April 2027, other languages until 21 October 2027; v1.0 certificates remain valid.

CT-AI vs CT-GenAI in one sentence

CT-AI is for testers whose product contains AI: a recommendation engine, a fraud detection model, an LLM-based chatbot. The question is "is this AI system reliable, fair, robust?". CT-GenAI is for testers who want to use generative AI in their own work: writing test cases, generating data, analysing results, building internal tools on top of an LLM. The question becomes "how do I use these assistants without lowering the quality of my tests?".

The two can complement each other. A tester can use an AI assistant (CT-GenAI) to test a product that itself embeds a model (CT-AI). But the skills assessed are different.

What does ISTQB CT-AI v2.0 cover?

The Certified Tester AI Testing v2.0 syllabus was released by the ISTQB General Assembly on 17 April 2026. It is a rewrite of the 2021 version 1.0: it goes from 11 to 7 chapters, and recommended training goes from four to three days. Content on using AI for testing was removed, with ISTQB pointing to CT-GenAI for that topic. The seven chapters, with the training time given in the syllabus:

Introduction to Artificial Intelligence (120 min)
Quality Characteristics for AI-Based Systems (45 min)
Machine Learning (375 min)
Testing AI-Based Systems (195 min), including a section on testing generative AI and large language models, with red teaming
Input Data Testing for Machine Learning Systems (180 min)
Model Testing for Machine Learning Systems (225 min)
Machine Learning Development Testing (30 min)

That is 1,170 minutes in total, about 19.5 hours. ISTQB's stated outcomes include understanding how neural networks work, knowing the ISO/IEC 25059 quality characteristics, calculating machine learning performance metrics, and designing and executing test cases for machine learning systems. Target audience: testers, test analysts, test engineers, test managers, consultants, data analysts, developers and UAT roles.

What does ISTQB CT-GenAI cover?

The Certified Tester – Testing with Generative AI syllabus was approved by the ISTQB General Assembly on 25 July 2025. The current version is 1.1, a minor update announced in April 2026 that, according to ISTQB, does not change the structure, learning objectives or scope. Its five chapters:

Introduction to Generative AI for Software Testing
Prompt Engineering for Effective Software Testing
Managing Risks of Generative AI in Software Testing (hallucinations, reasoning errors, bias, data privacy, energy consumption, regulation)
LLM-Powered Solutions for Software Testing
Deploying and Integrating Generative AI in Test Organizations

The v1.0 syllabus plans 815 minutes of training, about 13.5 hours, of which 365 minutes for prompt engineering alone: it is the practical core of the certification.

Side-by-side comparison

Criterion	CT-AI v2.0	CT-GenAI v1.1
Focus	Testing AI-based systems	Using generative AI to test
Prerequisite	CTFL	CTFL
Chapters	7	5
Training time in syllabus	1,170 min (about 3 days)	815 min (v1.0 syllabus)
Exam	40 questions, 60 min	40 questions, 60 min
Pass mark	29 out of 44 points	30 out of 46 points
Extra time	+25% for non-native speakers	+25% for non-native speakers
Typical profile	Tester of a product embedding ML or an LLM	Tester who wants to work with AI assistants

Sources: official ISTQB pages and syllabi, accessed on 2 October 2026 (list at the end).

Which one fits your profile?

You test a product that includes AI (scoring, recommendation, vision, chatbot, agent): CT-AI. You will learn to test data, models and generative AI systems, topics that classic test techniques do not cover.
You want to be more productive with ChatGPT, Claude or Copilot: CT-GenAI. It gives a method to write test prompts, check what the AI produces and manage its risks.
You are aiming for a test automation role: CT-GenAI is the most useful day to day, as coding assistants are now everyday tools (see our Playwright MCP guide). To go deeper into automation itself, ISTQB offers the advanced CTAL-TAE (Test Automation Engineering v2.0): it requires CTFL and sufficient practical experience, and its exam has 40 questions in 90 minutes, passed at 43 out of 66 points.
You are a test manager or consultant: both make sense. CT-GenAI covers the strategy for adopting generative AI in a test team, CT-AI the test strategy for an AI-based product.

CTFL first, in every case

CTFL v4.0 is the shared prerequisite. Its exam has 40 questions in 60 minutes and is passed at 26 out of 40 points. If you do not have it yet, start there. See all the certifications we prepare on our certifications page.

How to prepare with ADC

Our QA Automation & AI Tester programme, taught in French, includes preparation for the ISTQB CTFL and CT-GenAI exams, exams included. We do not prepare for CT-AI at this time. AutomationDataCamp is not an ISTQB-accredited training provider: we prepare candidates for the exams, which are delivered by official exam providers.

Frequently asked questions

What is the difference between ISTQB CT-AI and CT-GenAI?

CT-AI (AI Testing) teaches how to test AI-based systems: data, machine learning models and generative AI systems. CT-GenAI (Testing with Generative AI) teaches how to use generative AI to test: prompting, risks such as hallucinations, and LLM-powered tooling. Since CT-AI version 2.0, the 'using AI for testing' content was removed from CT-AI and points to CT-GenAI instead.

Do I need CTFL for CT-AI or CT-GenAI?

Yes. ISTQB requires the Certified Tester Foundation Level (CTFL) certification for both CT-AI v2.0 and CT-GenAI.

Is my CT-AI v1.0 certificate still valid?

Yes. According to ISTQB, certifications obtained under version 1.0 remain valid, with no requirement to retake the exam. The v1.0 exam stays available in English until 21 April 2027 and in other languages until 21 October 2027.

What are the CT-AI and CT-GenAI exams like?

Both have 40 questions in 60 minutes, with 25% extra time for candidates not taking the exam in their native language. CT-AI v2.0 is scored out of 44 points with a pass mark of 29; CT-GenAI out of 46 points with a pass mark of 30.

Which one should a beginner choose?

Start with CTFL, which is required for both. Then choose CT-GenAI if your goal is to be more productive with AI assistants day to day, and CT-AI if you test, or will test, a product that embeds machine learning or a language model.

Sources and references

Written with AI assistance; every figure was checked against the official ISTQB sources listed above, accessed on 2 October 2026. A French version is available: ISTQB CT-AI ou CT-GenAI.

Prepare for CTFL and CT-GenAI

Our programme prepares you for the ISTQB CTFL and CT-GenAI exams, exams included, with mock exams in the official format. Courses are taught in French. Programme details: automationdatacamp.com/en/formations.

Playwright MCP: let an AI assistant explore your app, then write the test (Claude Code, Copilot, Cursor)

AutomationDataCamp — Thu, 01 Oct 2026 23:36:52 +0000

Playwright MCP is Microsoft's official Model Context Protocol server for Playwright. It gives an AI assistant such as Claude Code, GitHub Copilot or Cursor the tools to drive a real browser: navigate, click, fill forms and read the page. The interesting part for testers: the assistant reads the page through structured accessibility snapshots, not screenshots, so no vision model is needed and it naturally "sees" the roles and accessible names that good Playwright locators are built on.

This post walks through installation, a first explore-then-generate scenario, how MCP compares with Playwright CLI and the Playwright Test Agents, and the rules we teach to keep AI-generated tests trustworthy.

Install it in one command

Node.js is the only prerequisite (the server runs with npx). The browser is headed by default, which is handy to watch what the assistant does.

Claude Code

claude mcp add playwright npx @playwright/mcp@latest

VS Code (GitHub Copilot agent mode)

code --add-mcp '{"name":"playwright","command":"npx","args":["@playwright/mcp@latest"]}'

Cursor and other MCP clients accept the standard JSON configuration:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

Options worth knowing (append them after @playwright/mcp@latest):

--headless: no visible browser (CI machines, containers)
--isolated: keep the profile in memory, start from a clean session every time
--storage-state <path>: start already logged in
--secrets <path>: a dotenv file, so credentials never appear in your prompt
--test-id-attribute: defaults to data-testid
--caps: optional capabilities such as testing (assertion and locator-generation tools), network (route mocking), storage, pdf, vision, devtools

A first scenario: explore, then generate

Step 1, exploration. Be precise in the prompt:

Using Playwright MCP, open http://localhost:3000/login.
Describe the fields, buttons and messages on the page.
Then try to log in with a wrong password and report the exact error message.
Do not submit any other form.

The assistant calls browser_navigate, browser_snapshot, browser_fill_form / browser_type and browser_click, then reads the page again. You get a report of the elements (with roles and accessible labels) and of the observed behaviour: a small, documented exploratory session.

Step 2, generation.

From what you observed, write tests/login.spec.ts with Playwright Test in TypeScript:
one successful login and one wrong-password case. Use getByRole and getByLabel only,
no CSS selectors, read credentials from environment variables.
Then run the tests and fix them if they fail.

A typical result (labels come from the demo app; yours will come from the real exploration):

import { test, expect } from '@playwright/test';

test.describe('Login', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/login');
  });

  test('a valid user reaches the dashboard', async ({ page }) => {
    await page.getByLabel('Email').fill(process.env.TEST_USER_EMAIL!);
    await page.getByLabel('Password').fill(process.env.TEST_USER_PASSWORD!);
    await page.getByRole('button', { name: 'Sign in' }).click();

    await expect(page).toHaveURL(/\/dashboard/);
    await expect(page.getByRole('heading', { name: 'Dashboard' })).toBeVisible();
  });

  test('a wrong password shows an error', async ({ page }) => {
    await page.getByLabel('Email').fill(process.env.TEST_USER_EMAIL!);
    await page.getByLabel('Password').fill('wrong-password');
    await page.getByRole('button', { name: 'Sign in' }).click();

    await expect(page.getByRole('alert')).toContainText('Invalid credentials');
    await expect(page).toHaveURL(/\/login/);
  });
});

Step 3, human review. Read it like a colleague's pull request. Do the assertions check a business outcome or just that a click happened? Does the error case also check the user is not logged in? Is an edge case missing (empty field, locked account)? Run it yourself and make it fail once on purpose to prove it catches a regression.

MCP, CLI or Test Agents?

Approach	How it works	Best for
Playwright MCP	The AI calls `browser_*` tools and reads accessibility snapshots	Exploration, self-healing tests, long autonomous loops with a persistent browser context
Playwright CLI + Skills	The coding agent runs short commands described by Skills	Coding agents juggling a large codebase: more token-efficient
Playwright Test Agents (1.56+)	Three agents: planner, generator, healer	Building or maintaining a Playwright Test suite with an assistant

The Playwright MCP README is explicit: for coding agents, CLI + Skills is often the better choice because it avoids loading large tool schemas and verbose accessibility trees into the context. MCP stays relevant when the agent needs to reason over page structure with persistent state.

Test Agents are set up in an existing project:

npx playwright init-agents --loop=claude   # or --loop=vscode, --loop=opencode

For Claude Code this writes agent definitions in .claude/agents/ and a .mcp.json that starts npx playwright run-test-mcp-server. The planner explores the app and writes a Markdown test plan, the generator turns it into test files, the healer runs the suite and repairs failing tests (as a last resort it marks a test test.fixme() with a comment). Re-run the command after each Playwright upgrade.

Rules we teach for AI-generated tests

Review every generated line. A passing test is not necessarily a good test. The AI checks what it sees; the tester defines what the business expects.
Demand accessible locators (getByRole, getByLabel, getByTestId) and say so in the prompt.
Own your test data. Dedicated accounts and datasets, recreated before each run.
Keep secrets out of prompts and code: --secrets for exploration, environment variables for tests.
Never point the agent at production. An assistant that clicks on its own can submit, delete or pay. Use a test environment and --isolated.
Watch token cost. Every snapshot and tool description fills the context. Scope the exploration to one flow.
Keep CI deterministic. AI writes and repairs tests; plain Playwright Test runs them in the pipeline.

What it changes for testers

Less time writing selectors and boilerplate, more time on test design (equivalence partitions, boundary values, decision tables), test data and code review. You still need to read and fix TypeScript: you can't review what you don't understand.

This article is adapted from our French guide Playwright MCP : tester avec l'IA. It was written with AI assistance; commands and options were checked against the official Playwright MCP and Playwright documentation.

AutomationDataCamp is an online software testing academy (Playwright, API testing, CI, AI-assisted testing, ISTQB prep). A ready-to-run Playwright + TypeScript starter with CI is on GitHub; more on our site.

Sources: microsoft/playwright-mcp · microsoft/playwright-cli · Playwright Test Agents · Playwright locators