How to Generate Tests With AI

Why Generate Tests With AI?

Generating tests with AI saves scripting time, raises test coverage, catches bugs earlier and keeps a growing test suite manageable as the application scales.

Incorporating artificial intelligence to generate tests for automation testing can bring a lot of benefits:

• Tackle Complex Scenarios: Complex scenarios, such as analyzing the load threshold or performance metrics, including network latency in various network calls, can easily be done through AI. Testers can also create complex tests without worrying about their maintenance easily.
• Increased Test Coverage: AI is capable of scanning the test script and determining the areas that have not been covered through tests. Then, it can generate tests for those sections specifically and, in the process, increase the test coverage automatically.
• Early Bug Detection: To generate tests with AI is not the only thing a tester can do. AI can also be implemented as an assistant which can assist the entire coding process and predict bugs in the code as a tester is writing them. It facilitates bug detection at the earliest possible phase of testing.
• Ease of Management: As the software scales, it becomes a lot harder to manage every testing process, let alone test case management. Scalability brings its challenges, a lot of which can be eliminated with AI in the process.
• Accuracy: Automated testing is the execution of test scripts written in a programming language (scripted automation) or as instructions (codeless automation). When done manually, all of this requires time and complex logic, which can be flawed more often than we think.

AI helps generate test cases that can target each task as instructed by the tester. Yes, the tests can be complex here as well, but since AI maintains it, it is acceptable.

Generating test cases for automated testing is time-consuming and challenging, which is exactly the problem test case generation with AI solves. Testers must identify locators, initiate drivers, and write complex logic, all while uncertain about test coverage. Achieving 100% coverage manually is not feasible.

How to Generate Unit Tests With AI?

Give an AI assistant the full source file and name your test framework, then run the unit tests it returns and fix any failures before you commit them.

IDE assistants read the open file and the code around it, while a chat session sees only the code you share with it.

• JetBrains AI Assistant: Place the caret in a class or method, open the context menu, and select AI Actions, then Generate Unit Tests. The JetBrains AI Assistant documentation says the test opens in an AI Diff tab, and Accept all saves it in the project's test module, which AI Assistant creates if the project has none.
• GitHub Copilot Chat: Open the source file in the current editor tab and type the /tests slash command. The GitHub Copilot testing guide recommends opening existing test files in adjacent tabs so Copilot matches your testing framework.
• ChatGPT or Claude chat: Start a new chat session, paste the entire source file, and name the stack, such as Vitest with React Testing Library, in a short prompt. A fresh session keeps context from other files out of the answer.

PyCharm's AI Assistant generates tests for the project's default test runner. The Copilot testing guide covers Visual Studio, Visual Studio Code and JetBrains IDEs.

Can AI Agents Generate and Repair Browser Tests Through MCP?

Yes. Through the Model Context Protocol, an AI agent drives a real browser with Playwright, writes a test plan, generates the test code and repairs tests that fail.

The Model Context Protocol (MCP) is an open-source standard for connecting AI applications to external systems. The Playwright MCP server uses it to let an LLM act on web pages through structured accessibility snapshots instead of screenshots.

Playwright 1.56 introduced three Playwright Test Agents that split AI test generation into planning, writing and repair.

• Planner agent: The planner explores the app from a seed test and saves a Markdown test plan, such as specs/basic-operations.md, with steps and expected results.
• Generator agent: The generator turns the Markdown plan into Playwright test files under tests/ and verifies selectors and assertions live as it performs each scenario.
• Healer agent: The healer replays a failing test, inspects the current UI, patches a locator, wait or data value, and reruns the test until it passes or guardrails stop the loop.
• Agent setup: The npx playwright init-agents command adds the agent definitions for VS Code, Claude Code, Codex or OpenCode. Playwright 1.62 also bundles the MCP server, which runs with npx playwright mcp.

The Playwright MCP README notes that coding agents increasingly prefer the Playwright CLI, because CLI calls avoid loading large tool schemas and accessibility trees into the model context. MCP remains relevant for self-healing tests and long exploratory runs, where a continuous browser context outweighs the token cost.

Agents that learn expected results by exploring the running app can write assertions from its current behavior, so a bug can become the expected result.

The healer also returns a skipped test when it believes a feature is broken. A tester should review every generated assertion and every skipped test before the suite is merged.

How to Review and Refine AI-Generated Tests?

Treat AI-generated tests as first drafts: run them, check every assertion against the requirement, send failures back to the AI and add the cases it missed.

• Run every test: Add the generated file to the project and run it with the usual test command, such as yarn test, before you trust any result.
• Feed errors back: Paste a failing test's error message into the same AI session and ask for a fix, so the AI works from the code and prompt it already has.
• Check common defects: A Vitest walkthrough by Keyhole Software lists three: selectors that guess a data-testid the page does not have, missing act() wrappers around React state updates, and float assertions that need toBeCloseTo.
• Compare with requirements: Read each expected value against the requirement or acceptance criteria, not against what the application does today.
• Fill coverage gaps: Add tests for the scenarios the AI skipped, because GitHub's Copilot documentation warns that generated tests may not cover all scenarios.
• Keep the reviewed file: The same prompt can return a different test file on a later run, so commit the reviewed version instead of regenerating it.

How to Check Results and Coverage of AI-Generated Tests?

Run the generated tests with your usual test command, read the pass and fail report, then run a coverage report to see which statements and branches no test reaches.

• Results report: Some AI API testing tools run the tests they generate from an OpenAPI file right away, then show a report summary and a full HTML report with scores, errors and logs.
• Statement and branch coverage: In the Keyhole Software Vitest walkthrough, the yarn test:coverage command reported 100 percent statement coverage but 50 percent branch coverage for one React component, so read both columns.
• Pull request reports: Pull-request-based test generators post a report that lists what was tested, what was missed and how coverage changed.
• Reruns after API changes: Save the test generation configuration and rerun it after an API update, so each run uses the same settings and the results stay comparable.

How Does TestMu AI Test Management Generate Test Cases?

Testers enter a prompt, user story or requirement document, and AI returns a structured test case with steps, expected results, preconditions and priority to review and save.

Once the tests are generated, they need to be executed and, most importantly, managed regularly. In these situations, teams look for tools that go beyond prompt-based "input-output" features, and this is where TestMu AI's AI-native test management platform comes into the picture.

TestMu AI provides an AI-native unified test management that provides test case creation, management, triggering, and reporting all in one place. With TestMu AI, you can create test cases manually or using AI.

For demonstration, let’s look at how to create test cases with AI:

Note: Ensure you have access, If not, please contact sales.

• From the top-right, click on the New Project button.

• Enter your Project name, Description and Tag(s) in the respective fields.

• Click on the Create button, and it takes you to the below screen.

• Click on the project name that you just created, and you will be routed to the Test Cases dashboard.
• Navigate to the prompt box and press the Tab key to generate test cases with AI. You can then press the Shift+Enter keys to generate multiple test cases. Once done, press the Enter key.


You can then organize your test cases efficiently by creating folders and subfolders. Additionally, you can copy and move test cases, export test cases and do much more.

To get started, refer to this documentation on Introduction to Test Manager.

Note: Create and manage test cases with AI-native Test Management. Try TestMu AI Today!

Which AI Test Generation Method Should You Choose?

Choose by the job: AI chatbots such as ChatGPT and Claude draft one-off scripts, IDE assistants write unit tests, and testing agents also run, debug and report on tests.

Authoring tests in software testing is one of the most time-consuming jobs. The tester has to not only make sure the tests are maintainable and readable but also think about the coverage which sometimes can make things a bit complex. This challenge can be avoided by adopting AI in software testing to take care of the tasks that were performed manually.

It can be introduced at multiple levels, performing multiple types of jobs. Some might just be available to generate tests with AI, while some AI testing tools or test assistants like TestMu AI KaneAI can debug, fix errors, and generate test reports on their own.

Whatever method a tester opts for, AI is bound to get fabulous benefits and overcome the challenges of automation testing performed manually. It is a step ahead in getting an autonomous test infrastructure, something that we all aim for in the future.

Sources and References Used

• The Future of Software Testing: AI-Powered Test Case Generation and Validation - ResearchGate