Software testing using artificial intelligence – agents supporting quality assurance

Development teams are producing software faster than ever before. Effective software testing ensures that the code released actually works.

At Hurja, we have seen first-hand how artificial intelligence is transforming software testing and development processes. When tests can be generated, run and maintained more efficiently with the help of AI, quality assurance becomes considerably more cost-effective and sensible to implement as part of day-to-day development work.

As development accelerates, testing must keep pace. AI-based test automation makes quality assurance continuous, faster and more easily scalable.

According to Capgemini’s World Quality Report 2025 press release, nearly 90 percent of organizations are utilizing or piloting generative AI in their quality assurance workflows. Gartner defines AI-assisted software testing tools as solutions that support continuous and more autonomous testing as part of the software development life cycle. They can be used, for example, to create and maintain test scenarios, test cases and test automation, as well as to optimize, prioritize and analyze tests.

In this article, we explain what software testing using artificial intelligence means in practice, what sort of technical solutions it requires, and how artificial intelligence makes testing more cost-effective, continuous and easier to scale.

What does software testing using artificial intelligence mean?

Software testing using artificial intelligence means that AI agents assist with routine testing tasks. A human defines the objectives and boundary conditions and oversees the process as a whole. Decisions requiring judgement that is essential in terms of use cases, architecture or quality remain the responsibility of humans.

In practice, agents can handle tasks such as:

• by analyzing the system and codebase for test case generation
• running tests following code changes
• analysing results and identifying errors
• in straightforward cases, suggestions for corrections, corrections themselves and the rerunning of tests

A good end result requires groundwork. Developers should define a framework for the agent, on the basis of which tests are written. In practice, this means providing guidelines on what to bear in mind when creating tests, which solutions to favor, what to avoid, and which parts of the system require particular attention.

A well-trained coding agent is able to draw on the context of the project and determine what type of test is appropriate for the situation. Where necessary, they can suggest, for example, unit tests, end-to-end tests or both for software testing.

In Claude, this sort of guidance can be implemented, for example, as a Skill. At its simplest, it involves a text file that the AI reads and internalizes before writing the tests. Behind the scenes, work is being done to ensure that the AI generates the right kind of tests for the right purpose and in the right context.

Read more: 6 winning use cases for AI – how to find where it really pays off

Less manual work, better test coverage

In a small team, a single developer can achieve more with the help of artificial intelligence without the workload increasing proportionally. Less time is spent on designing, writing and maintaining tests, allowing the developer to focus more on the actual software development.

In traditional test automation, test scripts are often written by hand. When the system changes, the tests also need to be maintained, and this maintenance can take up a significant proportion of the team’s time.

AI-based testing reduces the maintenance workload. Tests can be created automatically, and self-healing features help to keep the tests up to date as the system changes.

Development is accelerating, and testing is keeping pace

Artificial intelligence speeds up coding so much that the bottleneck in development easily shifts elsewhere. Development work that used to take a whole sprint can now be completed as early as the first week of the sprint. In some projects, a two-week sprint has even been condensed into a single day. This is particularly feasible when the tasks are repetitive and the system’s knowledge base is in order.

As more code is produced at a faster rate, the testing feedback loop must be shortened. Manual testing alone can easily cause the feedback to lag too far behind the moment a change is made. In AI-based software testing, tests can be run automatically after every change. The development team receives feedback within minutes, rather than having to wait weeks for the next round of testing.

People are needed to define what is being tested, what level of quality is sufficient, and which parts of the system are the most critical. Artificial intelligence can handle repetitive tasks: running tests, analysing results, identifying errors and suggesting fixes. This shifts the developer’s focus from carrying out individual tests to managing the overall process.

As well as tools, streamlining testing requires clear procedures. When agents are informed of what is considered critical within the system and what kinds of solutions are favored in the project, testing better supports the pace of development.

Read more: User stories as a tool in app design using artificial intelligence

How agent-based software testing works from a technical perspective

Agent-based software testing begins with specification. The developer describes a new feature to the agent and provides instructions on the basis of which the tests are written. The instructions may specify, for example, what needs to be verified, which use cases are important, and what constraints need to be taken into account during testing.

The agent then analyzes the software and, based on the context, determines what kind of tests are appropriate for the situation. If a single function or a small feature is involved, the agent can write unit tests. If the interaction between classes, functions or parts of the system is being tested, integration tests are required. Entire user flows can be tested using end-to-end tests, which simulate user behavior in a browser.

In practice, the work proceeds in cycles:

• A new property is defined for the coding agent
• The agent writes tests based on the specifications
• tests are being carried out
• The agent analyzes the errors and makes suggestions for corrections
• The code is corrected and the tests are run again

The same basic principle has long been applied to software development: test, fix, retest. Artificial intelligence makes this cycle considerably easier to implement, as some of the work can be automated. This makes it easier to justify more comprehensive testing even in projects where there has previously been insufficient time or budget for it.

When the agent has sufficient context, the tests are better suited to the actual requirement. The agent utilizes the specifications, the codebase and the system architecture, ensuring that the tests serve their intended purpose.

Test cases are derived from natural language

The test specification can begin with a simple description: “The user adds 500 kilograms of concrete to their order.”

The developer provides the agent with a description and explains what needs to be verified in the scenario: that the quantity is updated correctly on the order, that any calculations work as agreed, that the data is passed to the interface, and that the user receives clear feedback. The agent reviews the codebase, user interface and APIs before writing the test. Based on this, they propose a test level appropriate to the situation.

If the item to be checked is a single calculation rule, a unit test is often sufficient. Where the interaction between the user interface and the API is involved, an integration test provides greater assurance. The entire user flow can be tested as an end-to-end test.

Playwright, for example, can be used for end-to-end testing. The test opens the browser, follows the user flow, enters the quantity, submits the order and checks the result. Playwright can capture screenshots and videos of the run, allowing the developer to see what happened step by step. The final result can be verified both programmatically and visually.

Agents write and mark tests

In an agent-based model, one agent can focus on writing tests while another focuses on evaluating them. The reviewer agent checks, for example, whether the test corresponds to the given task, complies with project practices and covers all relevant scenarios.

The developer receives a more complete proposal for review and makes the final decisions. Agents speed up the process of writing, running and fixing tests, but a human is responsible for the overall picture.

RAG makes the project details available to the agent

The quality of software testing improves when the agent has access to project data. RAG, or Retrieval-Augmented Generation, essentially means that the AI retrieves information from an agreed knowledge base to support its responses. In testing, the knowledge base may include, for example, interface descriptions, testing guidelines, architectural decisions, user interface logic and previous observations from production.

In the concrete order example, the agent could retrieve from the knowledge base, for instance, unit conversions, minimum quantity thresholds, rules affecting delivery, and the data format expected by the interface. When this information is available before the test is written, the agent’s suggestions are better suited to that particular system. The same principle also applies to RAG AI bots, where the organization’s own knowledge is harnessed by artificial intelligence. Knowledge is not confined to the memories of individual people, but can also be utilized systematically to guide the AI.

Case: RAG-based AI chatbot for a website

A radical approach to software testing

With Hurja AI, artificial intelligence can be integrated into the entire development cycle, from design through to implementation and testing. This approach is suitable for new projects and legacy systems where test automation is either absent or can no longer keep pace with the speed of development.

As part of our software development services, AI-powered software testing can be incorporated at any stage of the project.

You can get started regardless of your current situation:

• If there is no test automation at all, we’ll build it from scratch.
• If the current testing process cannot keep up with the pace of development, we’ll work together to see how we can get the process back on track.
• If the system involves multi-layered integrations and errors are hidden in hard-to-find places, we design diagnostic tools that make the problems visible.

Read more: Prototyping and AI – from idea to interactive prototype in an instant

Do you want software testing to give you a competitive edge?

Artificial intelligence has brought an incredible pace of change to software development. Teams that also run tests automatically after every code change release their software more quickly and with greater confidence than teams where testing is still a manual step at the end of a sprint.

The benefits are evident in practice on many levels. Test coverage improves when agents are able to identify even those borderline cases that one would not specifically think to request for testing. Errors can be detected within minutes, rather than only being spotted weeks later. Architecture management is also made easier when project data, testing practices and previous findings are available to the agents.

Do you run tests automatically every time a change or release is made? Or is your manual testing backlog piling up sprint after sprint? Get in touch, and let’s work out together how to make testing support the pace of development.