72% of QA Teams Use AI to Generate Tests. Most Are Just Building Bigger Suites, Not Better Coverage

Part 1. What an AI-Augmented Test Coverage Workflow Does

Most teams that adopt AI test generation point it at the whole codebase and let it produce as many tests as it can. A workflow built correctly points it somewhere narrower, and does three things blanket generation cannot:

It identifies which code is high-risk, using code churn, historical defect data, and what a pull request changed, rather than treating every file as equally worth testing.

It generates test cases specifically for the coverage gaps in that high-risk code, not a blanket pass across the repository that produces a bigger suite without closing the gaps that matter.

It gates the merge on a coverage threshold for the changed code specifically, not a repository-wide average that a handful of well-tested legacy files can quietly prop up while the actual pull request ships undertested.

The team-capacity calculation:

Manually deciding which parts of a codebase need more test coverage, then writing those tests by hand, is not a task that scales with the volume of code AI tools now help produce. An automated risk assessment running on every pull request costs no incremental engineering time for code that's already well-covered, the team's attention concentrates on the specific gaps the assessment finds, which is a better use of engineering time than writing tests for code that didn't need them.

Part 2. Why Risk-Based Generation Beats Generating More Tests

AI test generation has been widely adopted, 72% of QA professionals report using AI to generate tests or optimize scripts, according to a 2026 industry survey. Adoption isn't the problem. Teams using AI to generate more tests without improving their underlying strategy are producing larger automation suites without improving what those suites cover, a distinction that matters more than the adoption number suggests.

Why the volume of code has outpaced the volume of good tests:

53% of code is now AI-generated or AI-assisted, and 61% of teams report moderate to dramatic increases in testing demand as a direct result, according to Ranorex's 2026 Software Quality Pulse Report. New code arriving faster than a team can review it doesn't automatically arrive better tested, and a test-generation approach that isn't targeted at the riskiest parts of that new code is solving the wrong half of the problem.

What happens when test volume grows without a quality gate behind it:

A Bitrise analysis of more than 10 million CI builds found the share of teams experiencing flaky tests, tests that fail intermittently with no underlying code change, rose from 10% in 2022 to 26% in 2025, a 160% increase in three years, as CI pipeline complexity grew 23% over the same period. Google's internal research puts flaky tests at 4.56% of all CI failures, consuming more than 2% of developer coding time on investigation that turns out to be noise, not a real regression. A larger test suite without a targeting strategy doesn't fix this, it usually makes it worse, more tests means more surface area for flakiness to accumulate.

The gap between trying AI testing and actually relying on it:

Nearly 9 in 10 organizations report doing something with generative AI in quality engineering, but only around 1 in 7 have operationalized it as an enforced part of their pipeline. Only 17% of teams say AI-driven testing tools have had a significant impact so far, most report only incremental gains. That gap between broad experimentation and real operational reliance is exactly where a risk-based approach with an actual enforced gate, rather than an optional tool a team tries occasionally, makes the difference.

Part 3. How to Build the Risk-Based Coverage Workflow

This pipeline scores the risk of what a pull request changed, generates tests targeted at the specific gaps in that changed code, and gates the merge on covering it, rather than generating tests broadly and hoping coverage improves somewhere.

The pipeline:

Pull request opened or updated, triggering the workflow automatically
→ AI drafts a risk assessment of the changed files, weighing historical
   defect data, code churn frequency, and the size and nature of the change
→ Deterministic rule: does any changed file clear the high-risk threshold
→ If no: standard test requirements apply, the pipeline proceeds normally
→ If yes: AI drafts test cases targeting the specific coverage gaps in
   the high-risk files, not a blanket pass across the whole pull request
→ Deterministic rule: does coverage on the high-risk changed code meet
   the required threshold once the drafted tests are included
→ If no: the merge is blocked, with the specific uncovered lines or
   functions named in the pull request comment
→ If yes: the merge proceeds, and the drafted tests are submitted for
   a developer's review before being merged into the suite
→ Every risk assessment, generated test, and gate decision is logged

Why the gate checks changed code specifically, not the whole repository:

A repository-wide coverage average can look healthy while the exact code a pull request just introduced ships with no meaningful test behind it, well-tested legacy files carry the average even as new, riskier code slips through untested. Scoping the gate to what changed closes that blind spot directly, a pull request can't hide behind the rest of the codebase's test history.

Why generated tests get reviewed, not merged automatically:

An AI-drafted test can pass and still test the wrong thing, confirming that broken behavior is consistent rather than catching that it's broken. A developer reviewing the generated test against what the code is supposed to do is what keeps a growing suite meaningful rather than just larger, which is precisely the failure mode this workflow is built to avoid in the first place.

Part 4. The Automation Approach

A test coverage automation built on this pattern runs on GitHub Actions, triggered by every pull request, without generating tests for code that was never at meaningful risk in the first place.

What this automation would include:

• A complete GitHub Actions workflow, covering risk scoring, targeted test generation, and a coverage gate scoped to changed code on every pull request.
• Configurable risk and coverage thresholds, so what counts as high-risk and what coverage level is required match a team's actual standards rather than a fixed default.
• AI-drafted test cases targeted at specific gaps, submitted for developer review before merging into the suite, never merged unreviewed.
• A full audit log of every risk assessment, generated test, and gate decision, so it's clear which pull requests needed extra coverage and which cleared the bar on their own.

As with every WorkplaceAI automation, the AI drafts the risk assessment and the tests; it never merges a test suite unreviewed, that stays a developer's call, made against a suite that's growing where it needs to, not just growing.