The AI Revolution in Testing: KaneAI

AI-driven test automation is transforming software testing organizations, making processes more efficient and reliable. Traditional testing methods often struggle with maintenance, scalability, and adaptability, leading to inefficiencies and delays in deployment. As AI evolves, tools like KaneAI are redefining how testing teams operate, bringing intelligence and automation to quality assurance workflows.

At Spartan Summit 2025, Harshit Paul, Director of Product Marketing at LambdaTest, hosted an insightful session on “The AI Revolution in Testing,” featuring Vimukthi Saranga, Associate Tech Lead at Wiley. Vimukthi Saranga is a seasoned QA expert with over a decade of experience. With his background in teaching, he has the unique ability to break down complex technical topics into simple, digestible insights, helping teams and individuals embrace test automation with confidence.

The session highlights how KaneAI enhances test planning, execution, and debugging while integrating seamlessly with modern testing infrastructures.

If you couldn’t catch all the sessions live, don’t worry! You can access the recordings conveniently by visiting the LambdaTest YouTube Channel.

Vimukthi starts with a kickoff guide, helping viewers gain insight into the session and learning points.

Challenges in Testing

Vimukthi highlights the challenges that QA engineers encounter daily, such as the tedious nature of test planning and documentation and more. He also highlights that manual testing, once the norm, has gradually been replaced by automation due to its greater efficiency. However, even automation introduces its own set of challenges, from writing test scripts to managing test cases. The repetitive nature of these tasks can be time-consuming and prone to errors.

Further, he highlights the importance of identifying the problems in the testing process before selecting a tool or technology. This approach ensures that the right solution is chosen, one that directly addresses the existing challenges and optimizes workflows.

He explains that the transition from manual testing to automation was driven by the need for faster execution and more reliable results in Agile development environments. Yet, even with automation, engineers still face hurdles like duplicate work, debugging failures, and managing multiple tools for different aspects of the testing process.

He further elaborates on each of the challenges automation testers face in detail for better understanding.

• Writing Test Cases (TCs) and Test Management: Vimukthi emphasizes the importance of writing clear and well-structured test cases. These test cases lay the foundation for any automated testing process.

He highlights best practices for creating detailed test cases that are:

• Every test case should be written to cover a specific functionality but also be adaptable for future needs.
• Each test case must have a well-defined structure that includes steps, expected results, and relevant data inputs.

He also discusses the importance of effective test management, which ensures that test cases are organized, prioritized, and executed efficiently.

• Creating Automation Scripts: Vimukthi emphasizes the importance of creating automation scripts after defining test cases. He explains that these scripts significantly improve test execution speed and accuracy by automating repetitive tasks.

Automation helps ensure consistent test execution across multiple platforms, enhancing the overall efficiency of the testing process. The key idea is to leverage automation tools to increase efficiency while reducing human errors. Vimukthi shows how Kane AI assists in generating these scripts with minimal effort through natural language instructions.

• Test Run Execution on Web and Mobile: Vimukthi stresses the significance of executing test runs on both web and mobile platforms. Since modern applications often have both web and mobile interfaces, it’s essential to ensure that the automation scripts work across different platforms.

This includes testing the application on different browsers and ensuring that the UI behaves as expected. He outlines how mobile testing requires consideration of factors like screen size, touch interactions, and different mobile browsers.

He explains how the test execution is seamless across both platforms, ensuring consistency regardless of where the tests are being run.

• Debugging Failures: He emphasizes the importance of effective debugging, noting that it’s crucial to approach failed test cases systematically. By analyzing the failure reports and identifying the root cause, testers can make informed decisions on whether the issue lies within the code or the test itself.

Debugging helps stabilize test cases, ensuring that tests are reliable and resilient over time.

First, determine whether the issue lies in the automation script or the application itself. Vimukthi highlights the importance of logs and screenshots in debugging failed tests. By analyzing the logs, you can pinpoint which step failed, and screenshots provide visual evidence of the failure.

• Stabilizing TCs: Vimukthi states that environmental stability is a key factor, especially for tests executed on different browsers or devices. He mentions strategies for managing dynamic content and elements that might change frequently (e.g., buttons, pop-ups). He also emphasizes creating reusable modules for common test actions (like login steps), which makes test cases more stable and maintainable.

He stated that to achieve more stable test cases by reducing false failures and ensuring that automation scripts consistently execute successfully.

• Reporting Issues: Vimukthi highlights the importance of proper issue reporting. Once the tests are executed, any failures or unexpected behaviors should be reported clearly. He explains that the issue report must include detailed information such as steps to reproduce, logs, screenshots, and any other relevant data. Effective communication with developers is key to ensuring that issues are resolved quickly.

As Vimukthi explains, these bottlenecks create inefficiencies that can significantly slow down the testing cycle. With the increase in release frequency, particularly in Agile environments, testers are under constant pressure to deliver high-quality results quickly. This is where solutions like KaneAI by LambdaTest come into play.

Vimukthi shares how AI can revolutionize the testing process, offering smarter and more efficient ways to handle testing tasks, along with a demonstration of the practical solutions offered by KaneAI.

Introduction to AI in Testing

Vimukthi emphasizes the transformative role of artificial intelligence in software testing, describing it as a game-changer that addresses many of the traditional methods’ inefficiencies. He explains that incorporating AI-native testing tools like KaneAI enhances automation by enabling testers to interact using natural language, eliminating the need for extensive coding expertise.

According to him, this approach significantly improves testing efficiency, accelerates bug detection, and ensures seamless integration with CI/CD pipelines.

He also addresses that by using AI-driven test creation, execution, and debugging, QA teams can focus more on strategic testing efforts rather than routine scripting. KaneAI, for instance, not only simplifies test case authoring but also adapts to application changes in real-time, reducing maintenance overhead and ensuring reliable test execution.

As Vimukthi shares his valuable insights on AI enhancement in the software testing process, he demonstrates how KaneAI can revolutionize your testing workflows by offering a blend of UI automation with seamless integration of API calls and JavaScript, all through simple natural language commands.

KaneAI: A Game Changer for QA Teams

KaneAI, developed by LambdaTest, is a GenAI-native testing agent designed to address these challenges by enabling teams to plan, create, and evolve tests using natural language. Built for high-speed quality engineering teams, it integrates seamlessly with the LambdaTest ecosystem, supporting test planning, execution, orchestration, and analysis.

He further also highlights the key features of KaneAI

• Natural Language Test Creation: Testers can create test cases using simple English commands, eliminating the need for programming expertise.
• AI-Driven Test Execution: KaneAI understands user inputs and executes actions in real-time.
• Automated Debugging: The tool identifies issues in test scripts, suggests fixes, and automatically adjusts locators when application changes occur.
• Seamless API Integration: Users can integrate API calls directly into their test cases.
• JavaScript Execution: Custom JavaScript commands can be executed within test cases, enabling complex interactions and validations.
• Data-Driven Testing: CSV files can be uploaded for parameterization, allowing tests to run with multiple datasets efficiently.
• Cross-Browser and Mobile Testing: Tests can be executed across different operating systems and browsers with easy configuration.
• Bug Management Integration: Results, logs, and failure reports can be directly linked to bug-tracking tools such as Jira.

He clearly breaks down the challenges testers face and how KaneAI can help them overcome them. He also highlights how it assists testers in performing repetitive tasks efficiently.

Demonstration: AI in Action

Vimukthi proceeds by providing a live demonstration showcasing KaneAI’s capabilities in revolutionizing test automation. He guides the audience through how testers can seamlessly interact with KaneAI using natural language prompts, eliminating the need for extensive coding expertise.

During the demonstration, he illustrates how testers could instruct KaneAI to perform essential test automation tasks such as:

• Navigating through different web pages
• Interacting with UI elements, including filling out forms and clicking buttons
• Validating expected results against actual application behavior

KaneAI’s natural language processing allowed testers to communicate their test steps conversationally. Instead of writing complex automation scripts, users could simply provide instructions like “Visit the login page” or “Enter username and password,” making it highly accessible for both technical and non-technical users.

Using JavaScript for Advanced Test Interactions

While natural language automation is powerful, there are instances where deeper control over browser interactions is required. Vimukthi demonstrates how KaneAI allows testers to execute JavaScript commands directly within their test cases, enabling advanced test interactions.

This feature is particularly beneficial for scenarios that require direct DOM manipulation beyond standard UI automation.

For example, he showcases:

• Scrolling to the bottom of the page: Using window.scrollTo(0, document.body.scrollHeight);, testers can programmatically navigate through lengthy pages, ensuring all elements load correctly.
• Interacting with shadow DOM elements: Since many modern applications use shadow DOM to encapsulate elements, traditional selectors often fail. JavaScript execution enables testers to interact with these elements effectively.
• Dynamically modifying CSS properties: Testers can simulate different UI states by altering CSS styles on the fly, helping verify responsiveness and design consistency.
• Executing JavaScript code snippets to interact with elements that are difficult to locate: Some UI components may be hidden or dynamically rendered, and JavaScript allows direct manipulation and verification of such elements.

These capabilities ensure that testers have full control over their automation scripts, allowing them to fill gaps where traditional automation tools may fail.

API Integration for Data-Driven Testing

Vimukthi further demonstrates how API calls can be seamlessly incorporated into test cases, allowing testers to interact with external data sources and validate responses dynamically.

KaneAI simplifies API-driven testing by allowing testers to incorporate API calls directly within their automation workflows.

The response was then utilized within a form submission test, allowing KaneAI to extract specific values (e.g., user first name) and dynamically input them into the UI test scenario. This approach improves test coverage by reducing reliance on hardcoded test data.

Vimukthi demonstrates how testers can:

• Fetch user data from an API and use it within UI test scenarios: Instead of relying on static test data, testers can dynamically retrieve real-time data from APIs and populate test fields accordingly.
• Validate API responses dynamically within test execution: KaneAI enables testers to check whether API responses match expected outcomes, ensuring the correctness of backend services.
• Store API responses as variables and reuse them in subsequent test steps: This feature allows data to flow smoothly across different test cases, improving efficiency and reducing redundancy.

For example, he executes an API call using KaneAI’s built-in integration:

The API returns a JSON response containing user details such as first name, last name, and email. KaneAI stores this response as a variable, enabling seamless use in a UI test case.

For instance, after retrieving user data via API, Vimukthi demonstrates how testers could:

1. Open a form on the web application.
2. Autofill the form fields using the retrieved API response (e.g., inserting the first name dynamically instead of hardcoding it).
3. Submit the form and verify the correct data entry.

By integrating API calls directly within test automation, KaneAI facilitates data-driven testing, making it easier to validate multiple datasets efficiently.

Additionally, Vimukthi showcases how testers could parameterize API tests, enabling different datasets to be tested within the same automation flow. He says that this is particularly beneficial for regression and data-driven testing, ensuring that test coverage extends to various input scenarios.

CSV Handling and Variable Management

He continues to explain KaneAI’s other good feature: CSV-based data handling, which allows testers to feed structured datasets into automation scripts.

Vimukthi explains how:

• CSV files can be imported to provide multiple input values for test cases.
• Variables extracted from CSVs can be dynamically assigned within test execution.
• KaneAI’s automation engine iterates through the dataset, running tests for each row in the CSV file.

This feature enables efficient data-driven testing by leveraging external test data sources. It eliminates the need for manually inputting values and improves overall test efficiency.

Exporting to Selenium Python Code

One key feature Vimukthi highlighted was KaneAI’s ability to convert automated test cases into Selenium Python scripts by default. However, you can also choose any other framework.

He demonstrates how users can:

• Generate Selenium-based Python code from their natural language test cases.
• Download and modify the generated scripts for further customization.
• Execute these scripts in local or CI/CD environments.

Project Management and Test Execution

Vimukthi also guides the audience through the complete process of setting up and managing test projects within KaneAI.

He explains how testers can:

• Select and configure test projects: Users can create new test projects within KaneAI, define their scope, and set configurations for execution environments.
• Save test scripts and organize them efficiently: KaneAI provides a structured approach to managing test scripts, allowing testers to store, categorize, and retrieve them easily.
• Execute automated tests across multiple environments, including web and mobile: KaneAI’s execution engine supports running tests on different platforms, ensuring comprehensive cross-platform testing.
• Load CSV files and perform compatibility testing: By selecting and loading CSV data, testers can perform compatibility checks across various datasets, ensuring their applications function correctly under different inputs.
• Review test execution reports and debug failures effectively: KaneAI generates detailed execution reports, highlighting passed, failed, and skipped test cases. Vimukthi demonstrated how testers can analyze logs, pinpoint issues, and stabilize test execution.
• Convert automated test cases to Selenium Python code and configure execution settings: After generating code, users can configure execution settings such as browser types, test environments, and data sources.
• Finish test execution and save results: Once a test run is completed, testers can save results, generate reports, and refine test cases based on execution insights.

By following these steps, you can streamline test management, as KaneAI enables teams to maintain a structured and efficient testing workflow, ensuring seamless collaboration and execution.

Enhancing Test Stability and Debugging Failures

As part of the demonstration, Vimukthi addresses the common challenges testers face in automation, particularly test failures and debugging.

He outlines a structured approach to handling failed test cases effectively:

• Identifying Failure Causes: Understanding whether failures are due to application changes, flaky locators, or external dependencies.
• Debugging with KaneAI: KaneAI provides visual debugging tools, including step-by-step execution logs and screenshots. This helps testers pinpoint the exact step where the test failed.
• Reducing False Failures: Stabilizing test cases is crucial to maintaining automation reliability. Vimukthi highlighted best practices, such as implementing intelligent waits and using dynamic locators to handle UI changes smoothly.

By leveraging KaneAI, testers can minimize debugging effort and reduce false negatives, ensuring that automation scripts consistently execute successfully.

The key takeaway from Vimukthi’s demonstration is that using AI-Native tools like KaneAI can significantly help enhance test automation by:

• Simplifying script creation through natural language instructions
• Allowing advanced interactions with JavaScript execution
• Integrating API calls seamlessly within test scenarios
• Enhancing debugging capabilities to stabilize test execution

His demonstration highlights the power of AI-driven automation and showcases practical ways testers can enhance their workflows and increase test coverage with minimal effort.

Final Thoughts!

KaneAI is not just another automation tool—it represents a paradigm shift in the way software testing is conducted. By eliminating the complexities of manual scripting and reducing the time spent on repetitive tasks, QA teams can focus on strategic testing efforts that improve software quality.

For those looking to explore KaneAI further, LambdaTest offers a free trial of KaneAI, where users can experience the benefits firsthand. As AI continues to evolve, tools like KaneAI are setting new standards for intelligent, efficient, and scalable test automation.

Note

Experience your journey with KaneAI Book a Demo! Now

 
As the insightful session concludes, Vimukthi engages with the audience in a Q&A segment, addressing their queries and providing deeper insights into leveraging AI for efficient software testing.

Question and Answer Session

1. Suppose in the latest development, a bug gets introduced – the webpage contains a duplicate non-mandatory field. And my test case or test run was prepared when the bug wasn’t introduced. How will KaneAI handle this? Will it make it a pass?

KaneAI will detect locator changes and notify users, automatically identifying alternative locators to maintain test stability.

2. How to re-run the bunch or selected test cases that are already saved?

All saved test cases can be accessed within the LambdaTest test manager and easily re-run by selecting them within a new test run configuration.

3. Can we use KaneAI for Salesforce testing?

While not explicitly tested, KaneAI’s ability to work with dynamic UI elements suggests strong potential for Salesforce automation. The LambdaTest support team can provide further insights.

4. How can we map test cases to Jira features for traceability?

KaneAI allows testers to add Jira issue IDs as tags, enabling seamless mapping and tracking of test cases to corresponding Jira features.

5. Can KaneAI handle non-functional testing, such as accessibility checks?

Currently, LambdaTest offers separate accessibility testing features, which can be integrated with test runs to include non-functional testing.

LambdaTest

LambdaTest is a continuous quality testing cloud platform that helps developers and testers ship code faster.

See author's profile