Can AI actually speed up software testing? Here's one case that confirms it.
Some time ago, a project team at intive working on an automotive embedded project found themselves under unexpected pressure. A tooling shift at the client side had disrupted the planning, and there wasn't enough time to write all the required unit tests manually. The team was already working at full capacity and hardware constraints meant there was no straightforward way to scale up.
I was asked to step in and help – and instead of adding more people to do the same manual work, I came in with a different idea: automate the test generation using AI. The approach was new to this context, but the logic was sound.
Starting from scratch – almost
The testing tool in this project – Razorcat Tessy – uses a proprietary format for test descriptions. That was the first hurdle: without a reference, AI-generated output had no way to match it.
The fix turned out to be straightforward. We gave GitHub Copilot a manually written example test that covered the range of typical scenarios. With that as a reference, Copilot could produce syntactically correct test descriptions almost immediately. I think that's something worth remembering: if you hand AI a good template, the quality of the output changes significantly.
From there, it became a process of iterative prompt engineering. The initial instruction was simple: create a unit test for this function, using the example file as a reference. Each round of refinement added a new constraint: coverage requirements, naming conventions, mutation tests, edge cases with complex data structures. The prompt also enforced proper test descriptions – not just syntactically valid output, but descriptions that made sense to a human reviewer.
The hardest problems were the most important ones
The functions with the most complexity to test were those working with large data structures – arrays spanning hundreds or thousands of bytes. A naive test description for these would fill thousands of lines and exhaust the model's context window before it could generate anything useful.
The real challenge wasn't just size – it was that understanding which specific fields in those arrays actually needed to be filled required following the logic of the implemented code, and that was never straightforward.
The solution was to engineer the prompt to instruct Copilot to initialize only the specific fields accessed during the test, rather than the whole structure. That brought the test descriptions back to a manageable size and made it possible to cover even the most complex functions automatically. And those were exactly the functions that would have taken the longest to write by hand.
Turning a workflow into a reusable tool
Once the prompt had been refined enough, we stored it directly in VS Code as a stored prompt. After that, the workflow was simple: type /create Ut FileName.c FunctionName, and the test description was generated. Testers imported the output into the tool, reviewed it, and committed it – moving on to the next function.
That review step mattered a lot – humans still checked every result. The AI handled the generation – the engineer validated it. That balance was the whole point.
Beyond test generation, AI also helped solve another time-consuming problem: linking tests to requirements. The project used ReqIF-imported requirements in the testing tool, and initially, connecting them to the right tests was a manual job. Using the testing tool's API, we built an AI-assisted tool that automated that linkage – saving a significant amount of additional time and effort.
I must admit adoption wasn't immediate. Some team members were skeptical – and honestly, their skepticism wasn't unreasonable. This wasn't standard practice, but the goal wasn't to produce ideal tests by conventional quality measures. It was to meet a deadline that couldn't be moved. Eventually, the whole team came around and used the approach.
We met the deadline. Without AI-assisted generation, it wouldn’t have been possible. By our estimates, the AI-assisted workflow was roughly 50% faster than writing the same tests by hand.
What I'd take from this
The lesson for me wasn't just that AI can write tests. It's that AI works best when you give it the right context – a real example, a well-engineered prompt, and someone with enough technical knowledge to catch where it goes wrong.
The prompt I built isn't static either. Colleagues adapted it to their own needs as the project progressed. The next step would be to consolidate those variations back into a shared, maintained version that the whole team benefits from.
If I were to summarize this experience in one sentence: all it takes is good enough context – for the AI, and for the person running it.
.png)
.png)
.png)
.png)
.png)
.png)