Invented by Rihani; Lamine

Software keeps getting bigger and more complex. Making sure all its parts work well can be tough. This article dives deep into a new patent application that uses artificial intelligence—specifically large language models—to make the job of testing new software features faster, easier, and more reliable. We’ll explain why this matters, how the invention stands out, and what makes it a big step forward in software quality assurance.

Background and Market Context

In recent years, software has become a part of almost everything we use—phones, computers, cars, TVs, and even home appliances. As software grows, it gets harder to check every part and make sure nothing is broken when something new is added. This is where software testing comes in. Testing is the process that checks if a program works as it should, and if it keeps working when new features are added.

Traditionally, teams of people called QA engineers would spend days or even weeks creating test plans. These plans try to cover every possible way someone might use the program. They write out steps to check if buttons work, if data is saved right, if screens look good, and if speed or security isn’t broken. The more features a program has, the more tests are needed.

But software is changing faster than ever before. Companies are adding new features every month, sometimes every week. Customers expect new things quickly. This means QA teams have to write and run new tests all the time. But doing all this by hand is slow, expensive, and can let problems slip through. As a result, some bugs make it into the finished product and cause headaches for users and companies.

To solve these problems, the industry has started looking at automation. Automated testing means using programs that write and run tests without human help. This helps teams keep up with the fast pace and catch more problems early. Recently, artificial intelligence—especially large language models (LLMs) like GPT—has shown it can help in this area. LLMs are good at reading and understanding natural language, like technical docs or user stories. They can even write code and create test scripts.

The patent application we are examining aims to use LLMs to automatically create, update, and run test strategies for new features in software. This can change the way teams test software and make the process much faster and more reliable.

Scientific Rationale and Prior Art

For years, making sure a program works as expected has relied on people to design test strategies. A test strategy is a detailed plan for how to check that a new feature—or even a whole program—works well. Creating these plans by hand takes time and often misses important edge cases.

Before AI, companies tried using static templates and scripts to help with testing. Automation tools like Selenium, JUnit, or custom scripts could run specific tests, but humans still had to write the plans and scripts. Some tools could record user actions and replay them, but these were hard to keep up-to-date when the software changed. They also couldn’t learn from past mistakes or adapt to new problems.

The big shift came with machine learning and, more recently, large language models. LLMs, such as GPT, have been trained on huge amounts of text, including software documentation, code, and technical reports. They are great at reading through technical docs, understanding what a feature should do, and even suggesting ways to test it.

Some earlier research and products used basic AI to help with test case generation. For example, some tools could suggest boundary values (like the biggest or smallest possible number) for input fields, or try random inputs to see if a program would crash. Others could analyze code to look for risky areas. But these tools were limited. They couldn’t understand complex requirements, combine information from many places, or learn from past testing efforts.

The state of the art before this patent was mainly about automating the running of tests—not the planning or writing of tests themselves. Some tools could help generate test cases from code or simple documentation, but they could not produce full test strategies or adapt to new kinds of software or features.

What was missing was a way to take all the information about a new feature—its technical docs, past problems, templates for what a good test strategy looks like, and even the lessons learned from old test strategies—and combine them to make a solid plan for testing, all without human help. This is the gap the patent aims to fill.

Invention Description and Key Innovations

This patent application describes a computer-implemented method and system for generating and executing test strategies for new software features using large language models. Let’s break down what this means in simple terms.

Suppose a company adds a new button to its app. Normally, someone would read the documentation, think about what could go wrong, write out all the things to test, and then write scripts or click through buttons to test the feature. This invention lets a computer do most of that work.

Here’s how it works:

When a new feature is ready, a request is sent to the system. This request includes a description of the feature—maybe from the technical docs, user stories, or other sources. The system also has access to templates that show what a good test strategy looks like, plus all the old test strategies and any records of past problems and fixes.

The large language model takes all this information and creates a detailed plan for how to test the new feature. This plan is not just a list of test cases; it can include the testing approach, what tools to use, what to pay special attention to, and the best methods for checking if the feature works. The LLM can even fill in different sections of the test strategy one at a time, making sure each part is complete and fits together with the others.

Once the plan is ready, the system can automatically write test scripts using the LLM. These scripts can be run right away or stored for future use. The system then runs the tests on the new feature. It records the results, including any problems it finds. If something goes wrong, the system can suggest changes to the code to fix the problem, based on what the test strategy expects.

One of the key innovations here is that the LLM is trained not just on general text, but on all the previous documentation, test strategies, and technical issues specific to that software product or company. This means the system gets smarter over time. It learns from past mistakes and successes, making each new test plan better than the last. If a similar bug was found in the past, the system can make sure to include a test for it this time.

Another important part is flexibility. The system can work with different types of software, different testing frameworks, and different formats for both the test strategies and scripts. It can create tests for many areas, including functional testing (does the feature work?), performance (is it fast?), security (is it safe?), and more.

Here are some more details that make this invention stand out:

– The system can handle requests that include extra information, like a list of past problems and their fixes. This helps it cover tricky edge cases.
– It can generate test strategies section by section, so if one part depends on another, the system makes sure they fit together.
– It can write test scripts for different testing frameworks, making it easy to plug into existing company tools.
– After running tests, if something fails, the system not only reports the problem but can suggest code changes to fix it, making the whole development cycle faster.
– The system can be trained and improved over time, getting better at understanding the company’s products and testing needs.

This patent also covers using a second LLM to turn the test strategy into actual test scripts, and even using LLMs to generate tests for reproducing and fixing bugs. This end-to-end automation—from reading requirements, to planning, to writing, to running, to fixing—is what makes it especially powerful.

Conclusion

In short, this patent application presents a new way to use AI for software testing. It moves beyond simple test automation by letting large language models do the hard thinking and planning that used to require skilled QA engineers. By pulling together technical docs, templates, past test plans, and records of old problems, the system can create, run, and even improve test strategies for new software features with very little human help.

This approach means companies can move faster, catch more problems before release, and make their products more reliable. As software gets more complex and changes more often, tools like this will be essential. By automating both the planning and running of tests—and learning from every result—this invention sets a new standard for software quality assurance in the age of artificial intelligence.

Click here https://ppubs.uspto.gov/pubwebapp/ and search 20250217257.