Take a faster, smarter path to AI-driven C/C++ test automation. Discover how >>
WEBINAR
AI is moving fast—and so is the pressure on teams to keep up. As 2026 begins, many QA and development leaders are asking the same question: How do we make AI actually helpful, not overwhelming?
Watch Forrester analyst Devin Dickerson, experts from Parasoft, and Bhanu Miryala, QA automation lead at Northbridge Financial, have a candid conversation about what’s really happening in software testing and where AI can genuinely make life easier for teams.
Devon Dickerson from Forrester points out a fascinating trend: while about 47% of enterprise developers report using generative AI in their workflow, the actual usage among individual developers is likely much higher. This creates a bit of a split. Individual developers and early-stage startups are widely adopting AI tools, making them a near-default part of their process. However, for larger enterprises, the picture is different. Many are still in the pilot phase, grappling with governance, data privacy, and how to measure the return on investment (ROI) of these AI initiatives.
This means that while individual developers are transforming their workflows with AI, enterprises are still figuring out how to build their entire software development lifecycle around it. It’s not just about adopting the tech; it’s about creating policies and strategies to support it.
There’s been a significant shift in how people are using AI tools. Early on, the buzz was all about “prompt engineering” – figuring out the perfect way to ask the AI for what you want. While that’s still important, the real innovation is happening in “context engineering.” This is all about managing the information AI has access to, ensuring it stays focused on the project’s intent and adheres to architectural standards. Think of it as keeping the AI assistant on the right track.
Advancements like using markdown files in the IDE or concepts like MCP (which helps expose context and tools to coding assistants) are all part of this move towards better context management. This dynamic discovery of context is becoming a key problem to solve, even if the specific solutions might change over time.
While AI is great at speeding up code generation, this acceleration can actually highlight and worsen existing gaps in the software development lifecycle (SDLC). Banu from Northbridge shared his experience. His company, dealing with complex commercial insurance systems that mix legacy and modern tech, has been on an automation journey since 2021. They’ve moved from basic automation to C# Selenium, integrated with CI/CD pipelines, and even explored hybrid API and UI automation. Yet, they found that purely repetitive UI automation wasn’t yielding significant value, and bug counts were still higher from manual testing.
This is where AI comes in. Banu’s team is now exploring how AI can help generate test cases, test data, and even automation scripts. The goal is to move beyond repetitive tasks and enable more creative, autonomous testing. This is crucial because if testing doesn’t keep pace with AI-driven code generation, the overall acceleration benefits are lost.
Nathan from Parasoft demonstrated how AI can be practically applied. He showed how to generate an API test scenario using an OpenAPI definition and a user’s description of what they want to test. By providing a prompt to add two items to a cart, submit an order, and verify it, the AI assistant suggested the necessary API calls, parameterized the test data (item IDs and quantities), and even handled authentication and dynamic data extraction (like order numbers).
This process created a fully functional, parameterized test scenario that was then executed, successfully placing orders in the demo application. This showcases how AI can significantly reduce the manual effort involved in creating complex test scenarios, especially for APIs.
So, how do we adapt our testing strategies when developers are coding faster with AI? Banu emphasized that traditional automation hasn’t closed the gap between development and testing. We need more powerful, creative, and domain-aware testing solutions. The challenge lies in the skill set of current resources; finding people with both domain knowledge and automation expertise is difficult. Organizations need to invest in training and tools that can understand complex architectures and adapt dynamically.
Devon added that great testers understand both the technology and how the software is supposed to be used, making their test cases realistic. He also noted that off-the-shelf AI coding assistants might not be enough for creating dynamic and thorough tests. Purpose-built tooling might be necessary to keep test practices aligned with code generation velocity.
With “vibe coding” becoming more prevalent, the question arises: do we need “vibe testing”? While rapid coding can be beneficial, it also introduces risks. If developers are pushing code they don’t fully understand, testing needs to be robust. Quality practices, including static code analysis and security testing, are more important than ever. AI might handle repetitive tasks, but human validation remains critical for ensuring the application does what it’s supposed to do.
Banu highlighted that AI can sometimes get confused by context, especially with legacy systems or when user stories reference previous implementations. This means AI-generated tests still require significant training, review, and iteration. The shift needs to happen at an enterprise level, with a holistic plan for incorporating AI across all functions, not just development or QA.
Testing applications that are themselves infused with AI presents a whole new set of challenges. These applications can be non-deterministic, have biases, and respond in ways that are correct but not strictly interpretable by traditional testing methods.
Nathan suggested using AI itself to validate non-deterministic outputs. An “AI asserter” can help determine if an output is acceptable, even if it varies slightly. For instance, it can understand that a “processed” status might be equivalent to a “placed” order in certain contexts. Another approach is service virtualization, where the AI components (like LLMs) can be stubbed out to create deterministic tests. This allows for validation of how the rest of the system interacts with the AI, even if the AI’s output is unpredictable.
Ultimately, testing AI-infused applications requires a mix of strategies: AI for code analysis and test generation, robust API test automation, static code analysis, and understanding when to make non-deterministic systems more deterministic through techniques like schema enforcement. It’s about combining these quality practices to ensure reliable outcomes.
