Skip to content
, home
Book a call
MenuClose

a Techtorial Academy program

AI for test engineers, in your framework.

Hands-on AI test automation training for your existing QA team: writing test cases, generating and maintaining test automation, and fitting AI into the Playwright, Cypress, or Selenium suite you already run. Instructor-led, private, in your repo, measured before and after.

Book a callFind your starting point

Same task, two ways

task: write a checkout test

sample

AI, no training

  1. prompt
  2. broken draft
  3. retry, fix, retry
  4. not merged

AI, after TestHubble training

instructor-led, in your repo
  1. prompt
  2. review
  3. test passes
  4. merged
Same engineer, same AI tool. The difference is the training.Illustrative sample of one task, writing a checkout test. Without training, the engineer prompts the AI, gets a broken draft, retries, and loops back to the prompt without reaching a merge. After TestHubble training, the same engineer prompts, reviews the draft, gets a passing test, and merges it. Along the way, two sample gauges show skill with AI rising and time per task going down.

Does any of this sound familiar?

You rolled out AI tools. Your test suite didn’t change much.

  • The AI licenses are paid for. Testers use them for the odd regex and little else.

  • The automation backlog grows faster than the team can work through it.

  • Flaky tests and broken locators eat part of every sprint.

  • AI output gets pasted straight into PRs, and reviewers can’t tell what was checked.

  • Nobody has written down what’s allowed: which tools, which data, who reviews what.

  • These are skills and habits problems, not tool problems.

    That’s what we work on

We train on the AI tools you already have.

We start with the tools you already have. Your team learns on whatever your company has approved, inside the framework it already runs.

In your framework

  • Playwright
  • Cypress
  • Selenium + Java
  • GitHub Copilot
  • Claude / Claude Code
  • ChatGPT Enterprise / Codex
  • Gemini / Gemini Code Assist
  • Cursor
  • Amazon Q Developer
  • Windsurf
  • JetBrains AI
  • or whatever your company has approved

Tools we train on. Not partners or clients.

How a program works

We untangle it, and we measure it.

We don’t promise a percentage. We promise what we’ll measure, and we report it honestly, with your own data.

your-test-suite/measured
skillsAI adoptionflaky ratetime to fix

  1. Before we start

    Baseline

    A practical skills test in your framework, plus the metrics you already have in your repo, CI, and tracker.

  2. During the program

    Hands-on, in your repo

    Your engineers write, review, and maintain real tests with the AI tools your company has approved. Labs run on your code, not toy demos.

  3. At the end

    Results report

    Before and after on skills, AI adoption, and team outcomes like flaky test rate and time to fix broken tests.

  4. 30 days later (60 for 8-week options)

    Follow-up

    We check whether it’s sticking. Engineers see their own results first and can correct them. No rankings.

One test, start to finish

The skill we teach, one test at a time.

Draft.An AI writes the test in seconds.

Your engineer asks Copilot or Claude for a checkout test. It looks right. It even passes, some of the time.

Review.Your engineer catches three problems.

A hard wait, a brittle selector, a weak assertion. Spotting them, and fixing them in your conventions, is the skill we teach.

checkout.spec.tsAI draftIn reviewReviewed

PromptWrite a Playwright test: a user can check out from the cart.

// AI first draft

1test('user can check out', async ({ page }) => {2  await page.goto('/cart');2  await page.click('#btn-checkout-2');1  await page.waitForTimeout(3000);3  expect(await page.locator('.msg')6    .textContent()).toContain('Thank');7});

// After review

1test('user can check out', async ({ page }) => {2  await page.goto('/cart');3  await page4    .getByRole('button', { name: 'Checkout' })5    .click();6  await expect(page.getByRole('heading', {7    name: 'Order confirmed',8  })).toBeVisible();9});

  1. Hard waitopenfixed

    waitForTimeout(3000) guesses. Slow CI fails, fast CI wastes time.

  2. Brittle selectoropenfixed

    #btn-checkout-2 breaks on the next redesign. Find it by role.

  3. Weak assertionopenfixed

    "Thank" passes on the wrong page. Assert the outcome, and let it retry.

An AI-drafted Playwright checkout test with three review comments (hard wait, brittle selector, weak assertion), followed by the reviewed version that uses role-based locators and a web-first assertion.

Run.The reviewed test goes through your CI.

Role-based locators and an assertion that waits for the real outcome. Green in your pipeline, merged in your repo.

Pull request: Add checkout testRunningReady to merge
  1. Install
  2. Lint
  3. E2E tests
  4. Review
  5. Merge
CI logsample run
$ npx playwright test checkout.spec.tsRunning 3 tests using 3 workers✓ [chromium] › user can check out✓ [firefox]  › user can check out✓ [webkit]   › user can check out3 passed
Sample CI run: install, lint, end-to-end tests, review and merge all pass; the Playwright run shows 3 passed in Chromium, Firefox and WebKit.

Measure.Then we show what changed.

A baseline before the program and a report after it, with your own data. We don’t promise a percentage.

How we measure results

Results report: before / aftersample
Practical skills test, in your framework
Baseline (sample)After (sample)
Engineers using AI on real tickets
Baseline (sample)After (sample)
Flaky test ratelower is better
Baseline (sample)After (sample)
Time to fix a broken testlower is better
Baseline (sample)After (sample)

Illustrative layout, not a client result. Your report uses your team’s own baseline.

Agentic setup

We set it up with you. Then we teach your team to run it.

An agentic system inside your own test framework: coding agents, conventions files, skills, MCP servers, sub-agents, and AI in CI. Your engineers learn to run it, extend it, and review what it produces, so they finish more tasks in less time.

  • Coding agents
  • Conventions files
  • Skills
  • MCP servers
  • Sub-agents
  • AI in CI

Agents draft. Your engineers review and merge. Part of the Accelerator, or on its own as an add-on.

Techtorial Academy, training test engineers since 2019

Teaching test engineers since 2019.

TestHubble is a Techtorial Academy program. Techtorial has trained more than 2,000 students from zero to software test engineer. TestHubble brings that teaching to teams who already know testing and now need to use AI well.

Techtorial Academy founded
2019
students trained from zero to test engineer
2,000+
More about us

Where do you want to start?

Pick what sounds most like your team. Any option can start as a pilot with 3–5 engineers.

We’d suggest

AI Readiness Assessment

2 weeks

A scored audit of your framework, a skills baseline for your team, and a roadmap.

  1. Understand
  2. Build skills
  3. Keep it sharp
Compare all options

Safe by default.

Your security team will ask. Here’s the short answer, and we’re happy to go through the long one on a call.

security-checklist.txt

  • NDA in place before we see your code
  • Least-privilege access only
  • No production data. No personal data.
  • Your company’s approved AI tools
  • Private cohort: only your engineers, 3–15 per group
  • Everything produced in your repo is yours

Remote or on-site, at a pace that fits delivery

Tell us about your team and your framework.

In a short call we’ll ask how your team tests today, which AI tools you have, and what you want to change. You’ll leave with a suggested starting point, whether or not it’s us.

Book a callOr request a proposal
suggestsgetByRole('button')reviewed