How SDETs Can Use AI Agents, MCP & LLMs in Daily Work: A Practical Guide

 The software testing industry is undergoing a massive transformation. Just a few years ago, automation engineers focused on writing Selenium scripts, creating frameworks, and maintaining test suites. Today, a new wave of technologies—LLMs (Large Language Models), AI Agents, and MCP (Model Context Protocol)—is changing how quality engineering works.

Many engineers hear these terms daily but struggle to understand how they fit into real-world testing activities.

This article breaks down these concepts using simple examples and shows how SDETs can leverage them to become more productive, strategic, and future-ready.

The Evolution of Software Testing

Traditionally, SDETs spend significant time on activities such as:

• Understanding requirements
• Writing test cases
• Creating automation scripts
• Executing regression tests
• Investigating failures
• Logging defects
• Preparing reports

While automation reduced manual testing effort, engineers still spend hours performing repetitive tasks.

This is where AI comes into the picture.

Imagine if an intelligent assistant could:

• Read requirements
• Generate test scenarios
• Write Playwright scripts
• Execute tests
• Analyze failures
• Create Jira defects
• Send execution summaries

That's exactly what happens when AI Agents, LLMs, and MCP work together.

Understanding LLMs: The Brain

A Large Language Model (LLM) is the intelligence layer.

Examples include:

• ChatGPT
• Claude
• Gemini
• Llama

Think of an LLM as a highly knowledgeable engineer.

You can ask:

Generate test cases for a login feature.

The LLM can produce:

• Positive scenarios
• Negative scenarios
• Boundary validations
• Security checks

However, there is a limitation.

The LLM can think and generate answers, but it cannot directly interact with your systems.

It cannot:

• Open Jira
• Read Confluence pages
• Execute Playwright scripts
• Create defects

For that, we need AI Agents.

Understanding AI Agents: The Worker

An AI Agent is an LLM combined with:

• Memory
• Planning
• Tool access
• Decision-making capabilities

Instead of simply answering questions, it performs actions.

Think of it as:

LLM + Tools + Reasoning + Actions = AI Agent

For example:

You ask:

Create automation tests for the login page.

An AI Agent can:

1. Read requirements.
2. Generate test cases.
3. Create Playwright code.
4. Execute the tests.
5. Analyze failures.
6. Create bug reports.

The difference is simple:

LLM	AI Agent
Thinks	Thinks + Acts
Answers Questions	Completes Tasks
Generates Content	Executes Workflows

Understanding MCP: The Universal Connector

Now imagine your agent needs access to:

• Jira
• GitHub
• Confluence
• Databases
• APIs
• Test Environments

Traditionally, every integration requires custom development.

This creates complexity.

MCP solves this problem.

What is MCP?

MCP (Model Context Protocol) is an open standard that enables AI systems to communicate with external tools and data sources.

Think of MCP as:

USB-C for AI

Just as one cable can connect multiple devices, MCP allows AI Agents to connect to multiple systems through a common interface.

Instead of building hundreds of custom integrations, agents can use MCP-compatible connectors.

How the Three Technologies Work Together

A simple flow looks like this:

 SDET
  ↓
 LLM
  ↓
 AI Agent
  ↓
 MCP
  ↓
 Jira / GitHub / APIs / Databases

The LLM provides intelligence.

The Agent decides what to do.

MCP provides access to tools.

Together they create intelligent automation systems. 

Real-Time Use Cases for SDETs

1. Automatic Test Case Generation

One of the most time-consuming tasks is creating test cases from requirements.

Traditional Approach

• Read user story
• Understand functionality
• Create scenarios manually

AI-Powered Approach

Agent reads:

• Jira Story
• Acceptance Criteria
• Confluence Documentation

Then automatically generates:

• Functional Tests
• Negative Tests
• Edge Cases
• Security Scenarios

Result:

• Faster analysis
• Better coverage
• Reduced manual effort

2. Automation Script Generation

Modern LLMs can generate Playwright scripts with impressive accuracy.

Example prompt:

Create Playwright tests for login functionality using valid and invalid credentials.

The agent can generate:

• Page Objects
• Test Data
• Assertions
• Reporting Logic

The SDET simply reviews and refines.

This accelerates automation development significantly.

3. Smart Test Execution

Agents can determine:

• Which tests should run
• Which tests can be skipped
• Which modules are impacted

Instead of running a 5-hour regression suite, the agent executes only relevant tests.

Benefits:

• Faster feedback
• Reduced execution costs
• Quicker releases

4. Defect Management

Failure analysis often consumes more time than test execution.

AI Agents can:

• Capture screenshots
• Collect logs
• Analyze stack traces
• Compare previous executions
• Create Jira defects

Example defect summary:

Login API returning HTTP 500 when password contains special characters.

The bug report is generated automatically with evidence attached.

5. Test Impact Analysis

One of the most exciting use cases.

Suppose a developer modifies:

User Authentication Service

The AI Agent can:

• Analyze code changes
• Identify impacted APIs
• Identify impacted UI flows
• Suggest test suites to run

This saves enormous execution time.

A Day in the Life of an AI-Powered SDET

Imagine this scenario.

A new story is added to Jira.

Step 1

Agent reads the story using MCP.

Step 2

Agent retrieves related documentation from Confluence.

Step 3

Agent generates:

• Test cases
• API tests
• Playwright scripts

Step 4

Agent executes tests in the test environment.

Step 5

Failures are analyzed automatically.

Step 6

Defects are created in Jira.

Step 7

Summary is posted to Slack or Teams.

Step 8

SDET reviews results and approves.

What previously required hours can now be completed in minutes.

Building Your Own AI Test Architect

For SDETs looking to future-proof their careers, an AI Test Architect project is an excellent portfolio showcase.

Suggested features:

Requirement Analysis

Upload requirement documents and generate test scenarios.

Test Case Generator

Generate comprehensive manual test cases.

Playwright Script Generator

Create UI automation scripts.

API Test Generator

Generate REST API test suites.

Flaky Test Detection

Identify unstable automation tests.

Performance Scenario Generator

Generate load testing scenarios automatically.

Test Impact Analysis

Predict impacted tests after code changes.

MCP Integration

Connect to:

• Jira
• GitHub
• Confluence
• Databases 

Final Thoughts

The easiest way to remember these concepts is:

🧠 LLM = Thinks

🤖 AI Agent = Acts

🔌 MCP = Connects

🚀 SDET = Achieves More

The future of quality engineering isn't just automation—it's intelligent automation powered by AI Agents working seamlessly across the software development lifecycle.

As SDETs, now is the perfect time to start experimenting, building, and learning. The next generation of testing tools will be agent-driven, and the engineers who master them early will have a significant advantage.

Software Engineering Cafe ☕
Simplifying Software Engineering, Testing, AI, and Automation—One Cup at a Time.

 

AI Agents + MCP + LLMs Explained Like a Classroom Notebook Sketch 📖✏️

Artificial Intelligence is evolving rapidly, and terms like LLMs, AI Agents, and MCP are becoming common in discussions around automation and intelligent systems. While these concepts may sound complex, they can be understood using a simple classroom notebook analogy.

Imagine a student trying to complete a project.

Step 1: The LLM – The Smart Student 🧠

A Large Language Model (LLM) is like a knowledgeable student who has read thousands of books.

You can ask questions such as:

• "Explain APIs"
• "Write a Python script"
• "Generate test cases"

The student can answer based on what they have learned.

However, there is a limitation:

• The student only knows information learned during training.
• They cannot directly access your company database.
• They cannot open applications or perform actions on their own.

Example:
Ask an LLM:

"Generate Playwright test cases for a login page."

The LLM can create the test cases, but it cannot actually execute them.

---

Step 2: AI Agent – The Student with Hands and Feet 🤖

An AI Agent is an LLM equipped with the ability to take actions.

Instead of just answering questions, it can:

• Search documents
• Call APIs
• Execute scripts
• Interact with applications
• Make decisions based on results

Think of it as:

LLM + Tools + Memory + Reasoning = AI Agent

Example for SDETs:

An AI Test Agent can:

1. Read requirements.
2. Generate test cases.
3. Create Playwright scripts.
4. Execute tests.
5. Analyze failures.
6. Create defect reports automatically.

This moves from "answering" to "doing."

---

Step 3: MCP – The Universal Adapter 🔌

Now imagine the student needs access to multiple systems:

• Jira
• GitHub
• Confluence
• Databases
• Test environments

Without a standard interface, the student would need a different process for each system.

This is where MCP comes in.

What is MCP?

MCP (Model Context Protocol) is a standard way for AI models to connect with external tools and data sources.

Think of MCP as:

"USB-C for AI"

Just as one USB-C cable can connect many devices, MCP allows AI Agents to connect to many tools using a common protocol.

---

Real-Life Example for an SDET

Suppose a new user story arrives in Jira.

Traditional Process

1. Read Jira story.
2. Understand requirements.
3. Write test cases.
4. Create automation scripts.
5. Execute tests.
6. Report bugs.

AI Agent + MCP Process

1. Agent reads Jira story through MCP.
2. Fetches related Confluence documents.
3. Generates test cases.
4. Creates Playwright automation.
5. Executes tests.
6. Analyzes failures.
7. Creates Jira defects automatically.
8. Sends summary to Teams/Slack.

The engineer reviews and approves.

Result:

• Faster delivery
• Reduced manual effort
• Improved productivity

Example: AI Test Architect

This is a practical project every SDET can build to showcase AI skills.

Features

✅ Upload requirements

✅ Generate test cases

✅ Generate Playwright scripts

✅ Generate API tests

✅ Detect flaky tests

✅ Generate performance scenarios

✅ Test impact analysis

✅ MCP integration with Jira, GitHub, Confluence

Suggested Tech Stack

• Python
• FastAPI
• LangChain
• OpenAI APIs
• Playwright
• PostgreSQL
• Docker
• MCP Servers

---

Why SDETs Should Learn This

The future of testing is shifting from:

❌ Manual execution

❌ Tool-specific expertise

To:

✅ Problem solving

✅ AI-assisted automation

✅ Agentic workflows

✅ Intelligent quality engineering

The most valuable engineers in the coming years will not be those who know the most tools, but those who know how to combine LLMs, AI Agents, and MCP to solve real business problems.

---

Final Thoughts

Think of it this way:

• LLM = Brain
• AI Agent = Brain + Actions
• MCP = Bridge to the Outside World

Together they create intelligent systems capable of understanding, reasoning, and acting across multiple applications with minimal human intervention.

As SDETs and Quality Engineers, now is the perfect time to start experimenting with AI Agents and MCP-powered testing solutions.

Where Can We Apply AI in Software Testing?

Artificial Intelligence is no longer a futuristic concept in software testing – it’s here and actively transforming how QA teams work. From reducing test maintenance to predicting failures before they happen, AI-powered testing tools are becoming essential in modern DevOps pipelines.

Here’s a breakdown of where AI can be applied in testing, along with real-world tools that support each area.

1. Test Case Generation

AI analyses requirements, user journeys, and code changes to generate meaningful test cases automatically.

Tools

Testim – uses AI to create automated tests from user flows.

Functionize – converts plain English requirements into test cases.

Benefit: Saves manual effort and increases coverage.

2. Test Case Optimization & Prioritization

AI helps identify the most relevant test cases based on impact analysis.

Tools

Launchable – uses ML to prioritize test runs.

Sealights – focuses on smart test selection.

Benefit: Faster execution without compromising coverage.

3. Defect Prediction

AI predicts high-risk areas in the application by analyzing code commits, bug history, and patterns.

Tools

DeepCode (Snyk Code)– detects potential defects through AI-driven code analysis.

CodeScene– predicts hotspots based on developer activity.

Benefit: Proactive defect detection before failures occur.

4. Automated Visual Testing

AI detects pixel-level differences and layout issues across browsers/devices.

Tools

Applitools Eyes– AI-powered visual validation.

Percy (by BrowserStack) – automated visual regression testing.

Benefit: Guarantees UI consistency.

5. Self-Healing Test Scripts

AI adapts scripts when UI changes break element locators.

Tools

Testim – heals broken selectors automatically.

Mabl– self-healing test execution.

Benefit: Reduces flaky tests and script maintenance.

6. Intelligent Test Data Generation

AI creates realistic, diverse, and compliant datasets.

Tools

Tonic.ai – synthetic test data generation.

GenRocket – generates controlled test data at scale.

Benefit: Better test reliability and compliance.

7. Performance Testing & Monitoring

AI identifies performance anomalies and predicts failures under load.

Tools

Dynatrace– AI-driven performance monitoring.

AppDynamics – anomaly detection for applications.

Benefit: Faster root cause detection and performance tuning.

8. Regression Testing

AI determines which regression tests are necessary after code changes.

Tools

Testim and Mabl– smart regression test automation.

Launchable– regression suite optimization.

Benefit: Faster CI/CD pipelines.

9. Security Testing

AI detects vulnerabilities and predicts attack vectors.

Tools

Snyk– AI-powered security scans.

Darktrace – anomaly detection for security threats.

Benefit: Strengthens application security early.

10. User Behavior Analytics for Testing

AI uses production data to simulate real-world usage patterns.

Tools

Mabl – integrates customer journeys into test coverage.

ProdPerfect – generates tests based on real user behavior.

Benefit: Testing aligns with actual user needs.

✅ Final Thoughts:

AI isn’t here to replace testers – it’s here to enhance testing efficiency and accuracy. By adopting AI-powered testing tools, teams can:

Automate repetitive tasks.

Predict and prevent defects earlier.

Release faster with higher confidence.

The future of software testing is AI-augmented, and the sooner teams start experimenting with these tools, the more competitive they’ll be.

Program to count digits in an integer!!!

Given a number N, the task is to return the count of digits in this number.

There are two approaches to get the count of digits in the number N.

Let us see both the approaches:

Approach 1:

We can convert the number into a String and get the length of the string to get the number of digits in the number.

Time Complexity = O(1)

Space Complexity = O(1)

package com.practice.basicprograms;

public class CountOfDigitsinNumber {

    public static void main(String[] args) {
        int number=18192;
        String N=Integer.toString(number);
        int length=N.length();
        System.out.println(length);
    }
}

Approach 2:

1. Initialize a count variable and increment it by using loop
2. Run a while loop until N becomes equal or less than 0
3. Divide N by 10, so that last digit will get eliminated with each iteration
4. Return the count variable to get the number of digits

package com.practice.basicprograms;

public class CountOfDigitsinNumberUsingLoop {

    public static void main(String[] args) {
        int n=18192;
        CountOfDigitsinNumberUsingLoop counts=new CountOfDigitsinNumberUsingLoop();
        System.out.println(counts.countofdigits(n));
    }
    public int countofdigits(long number){
        int count = 0;
        while(number!=0){
            number=number/10;
            count++;
        }
        return count;
    }
}

Time Complexity: O(count of digits)

Space Complexity: O(1)

Happy Coding!!!!

Different Types of Tests that can be automated🤷‍♂️

Automation can be applied to various types of tests across software development Life cycle, ensuring efficiency, accuracy, and speed in the testing process.

Here are different types of tests that can be automated:

Functional Tests

Functional tests validate the software’s functionality by testing it against the specified requirements. These tests check if the application behaves as expected from the end user’s perspective. Automated functional tests can simulate user interactions and validate various use cases.

Example:

Testing the login functionality of an application with valid credentials.

Unit Tests

Unit test usually tests the individual Object or individual methods of an object in a class. Unit Testing is highly necessary to prevent the flow of defect or preventing the defect at the earliest in the SDLC.

Example:

Testing the loops or conditions in a class

Integration Tests

Integration tests verify the interactions between different components or modules of a system. Several modules are together tested. The purpose of Integration tests is to make sure that all modules integrate and work together as expected. Automated integration tests help ensure that these interactions work as expected and that integrated components function properly together.

Example:

Testing the flow of placing the order for an item in Amazon or Flipkart along with payment.

System Tests

System Testing is a complete fully integrated product Testing. It is an end-to-end testing where the testing environment is similar to the production environment. Here, we navigate through all the features of the software and test if the end business / end feature works. We just test the end feature and don’t check for data flow or do functional testing and all.

Example:

Testing the end to end flow from login to placing and order and rechecking the order in My Orders page and logout in Amazon or Flipkart

Automating these tests can significantly improve the development workflow, allowing for faster feedback, early bug detection, and overall higher software quality. It’s important to strike a balance between automated and manual testing to ensure comprehensive test coverage.

Happy Testing!!!

Are you new to JavaScript? Have you ever wondered what the difference is between var, const, and let? 

 Understanding the scope, hoisting, and reassignment of variables in JavaScript is crucial for developing robust and maintainable code. 

 In brief, variables declared with var are function-scoped and are hoisted to the top of their containing function or global scope. Reassignment is possible within their scope. 

var a=4

Variables declared with let are block-scoped and are hoisted to the top of their containing block. 

Attempting to access a let variable before its declaration will result in a Reference Error. Reassignment is possible within their block scope. 

let b=5

 Variables declared with const are also block-scoped, but they must be assigned a value when declared, and they cannot be reassigned to a different value after their initial assignment. However, the value itself can be mutable if it's an object or an array. 

const flag=true

 In modern JavaScript, it's recommended to use const by default and only use let when you need to reassign the variable. Avoid using var unless you have a specific reason to use it, as it has some quirks and can lead to unexpected behavior due to its function-scoped nature and hoisting. 

 Remember, using the right variable declaration is essential for writing maintainable and bug-free code.

Happy Tester’s Day 2023!!!

 Firstly, Happy Testers’ Day!

”Quality is not an act, it is a habit” — Aristotle

 

Imagine a world where software works flawlessly, where products and services meet your expectations and give you a satisfying experience. This is the world we can create with Software testing.

Every IT community requires testers because there would be no one dedicated to identifying issues within the software of a computer, machine, program, or other devices that could cause it to malfunction. However, Quality Assurance is more than just testing; it is also the process of incorporating quality into software development.

Traditionally, Tester’s Day has been observed every year on September 9. On September 9, 1945 when the scientists who were testing the computer Mark II Aiken Relay Calculator, they found a real small moth between the contacts of the electro-mechanical relay and one of them pronounced the word ‘bug’.

The scientists had to make a report on the work done where the term ‘debugging’ appeared for the first time. Now debugging is the process of finding and eliminating bugs which lead to incorrect performance of the system and failures. At that time, the tests were focused on the hardware because it was not as developed as today and its reliability was essential for the proper functioning of the software.

”Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it” — Brian W. Kernighan

The term debugging was associated with the application of a patch for a particular bug as a phase within the stage of software development, and that is why the tests that were performed were only of a corrective nature by taking certain measures in order to make the program work and it was in 1949 when Alan Turing wrote his first article about carrying out checks on a program and then in 1950, in the article “Turing Test”, he explains the situation of how a software must adapt to the requirements of a project and the behavior of a machine or a reference system must be indistinguishable.

However, according to the Yale Book of Quotations, the American inventor Thomas Alva Edison used the term ‘bug’ in a letter to Theodore Puskas in 1878 to describe a flaw in a system.

According to other sources the term bug was commonly used to describe faults in the system during Edison’s time and according to some reports this wasn’t even the first ever computer bug — “It was reported as the first bug in jest, as it was an insect. The term bug had been used as a label for problems in computers and other electrical systems for a long time before this. Grace Hopper did not find the bug. Bill Burke found the bug. Grace Hopper was the team lead and often told the story of its discovery.”

Though people have different assumptions or thoughts for this day, it is important to visualize how the software testing stage has evolved and emerged from its absence to its continuous presence throughout the Software Development Life Cycle. Now we have so many roles and responsibilities within the Testing and it has evolved to a great extent and its all because of a bug found.

Every day is a Tester’s Day, however, it’s acceptable to have an exceptional day that makes testers around the globe share and team up and feel proud to be one. I’d like to congratulate all the people who test software, who strive to make the applications with great quality, passion and wish them all the best!
Happy Tester’s Day to all!

World Tester’s Day is recognized on the 9th of September every year to mark the discovery of the first-ever bug in 1947 since then.

Happy Testing!!!Don’t let any bug escape your sight!

Please share this post with others to inspire them to join us in the world of testing!!!