Mind Behind Machines

Tag: MCP

  • Manual QA Scripting? Agentic Testing with Playwright MCP

    You could ask an LLM to write an automation script, but it could not launch a browser, click a button, or verify a UI element on its own.

    This created a clear separation between reasoning and execution. Human engineers or traditional automation frameworks still had to take over once the code was generated.

    This gap is now addressed by the Playwright MCP server, which acts as an execution layer for AI-driven testing. Microsoft provides an open source Playwright MCP implementation that exposes Playwright browser automation capabilities through the Model Context Protocol. This allows AI agents to invoke browser actions through a standardized interface rather than running scripts directly.

    This shift is not just about generating code faster. It introduces the idea of Agentic Testing, where an AI system can reason about a test, execute it, observe the result, and iterate.

    Chatbot to Automation Agent

    In a traditional setup, LLMs such as ChatGPT or Claude operate as conversational systems. They respond with plain text based on their training data. Even when they generate automation scripts, those scripts still need to be executed manually or integrated into a separate test runner.

    When an LLM is connected to an MCP server, this limitation changes.

    Through the Model Context Protocol, the LLM can call external tools that perform real-world actions. With the Playwright MCP server in place, the AI gains the ability to interact with a browser environment instead of just describing what should happen.

    In practical terms, this allows the AI to:

    • Launch and control browsers to navigate URLs
    • Interact with elements by clicking, typing, and hovering
    • Capture snapshots and console logs to help troubleshoot front-end issues
    • Read execution results and retry when a generated test fails by refining the instructions and running the test again

    At this point, the AI transitions from a chatbot to an automation agent.

    The Architecture: How Agentic Testing Works

    Agentic testing with Playwright MCP follows a clear Host Client Server architecture. Each component has a defined responsibility, and together they form a continuous loop between intent, execution, and validation.

    Article content

    The flow begins with User Intent. A user provides a natural language instruction such as “Verify the checkout flow for t-shirts.”

    This request is handled by the MCP Host, which is the environment where the AI interaction takes place. This could be an editor or client, such as VS Code with Copilot enabled.

    The LLM Brain analyzes the prompt and determines which Playwright actions are required to satisfy the request. At this stage, the model focuses on reasoning and planning, not execution.

    The instructions are then passed to the MCP Client, which acts as the agent. The client mediates between the LLM and the execution layer and manages communication using the JSON RPC 2.0 protocol.

    The Playwright MCP Server receives these requests and performs the actual browser interactions. It executes the actions and captures execution results.

    Finally, Results and Feedback, such as success or failure signals and logs, are sent back to the LLM. This allows the model to refine its instructions and retry if needed.

    The Rise of Vibe Coding in QA

    This approach aligns with a broader trend often referred to as Vibe Coding. Instead of focusing on syntax and boilerplate, engineers express desired outcomes using natural language.

    In a QA context, this means describing expected behavior rather than manually writing detailed scripts. By providing a Test Context, which defines where files should be saved and how iterations should occur, QA engineers can guide the AI to generate and execute tests repeatedly until the expected outcome is reached.

    This enables the automation of more complex scenarios, including API testing and Page Object Model-based workflows, without writing large amounts of repetitive setup code.

    Why Every SDET Needs to Care

    This shift has practical implications for software testing teams.

    Speed Tests can be generated and verified faster than traditional manual scripting workflows.

    Accuracy. Instead of relying only on static locators that may become outdated, AI-driven execution uses structured page information and runtime feedback to interact with the UI.

    Unified Stack Using the same MCP-based approach, tests can interact with multiple systems within a single workflow, allowing broader validation during UI testing.

    As a result, the role of the QA engineer evolves. The focus moves away from writing scripts line by line and toward defining intent, context, and validation logic. The manual script writer gradually becomes an Agentic Architect.

    Thought

    Manual QA scripting is not disappearing overnight, but its role is clearly changing. With Playwright MCP, AI systems move beyond generating code and begin executing, validating, and refining tests themselves.

    The key question is no longer whether AI can help write tests, but whether teams are ready to let AI participate directly in running and improving them.

    Are you still debugging locators manually, or have you started vibing with Playwright MCP?

  • The “USB-C Moment” for AI: Understanding the Model Context Protocol (MCP)

    Why the Model Context Protocol (MCP) Changes Everything

    For the last few years, Large Language Models (LLMs) have impressed us with how well they can reason, explain concepts, and work with historical information. They can help you think, plan, and decide.

    But there was always a catch.

    Ask an LLM to actually do something:- send an email, update a CRM record, pull live data from a system, and the answer was usually the same: “I can’t do that.”

    The intelligence was there, but the ability to act in the real world was missing.

    To work around this, developers started wiring LLMs to tools and APIs manually. Every integration was custom-built. Every new system meant new glue code. Over time, this approach became messy, brittle, and hard to scale.

    That’s the gap the Model Context Protocol (MCP) is designed to close.

    The Problem with Tool Integrations Today

    Before MCP, connecting AI to external systems was very much a “one-off” exercise. If you wanted your AI to talk to a database, you wrote custom logic. If you wanted it to send emails, you wrote more code. If the API changed, you would have updated everything again.

    This worked, but it didn’t age well.

    The result was a growing collection of tightly coupled integrations that were hard to maintain and even harder to reuse. AI systems became smarter, but their ability to interact with the outside world stayed fragile.

    What MCP introduces is a clean break from that pattern.

    Enter MCP: A Universal Connector for AI

    MCP is an open standard introduced by Anthropic that defines a simple, consistent way for AI applications to connect to external tools and data sources.

    The easiest way to understand MCP is through a familiar analogy: USB-C.

    Before USB-C, connecting devices meant juggling different cables and adapters. USB-C changed that by becoming a universal port, plug in once, and everything just works.

    MCP does the same thing for AI.

    Instead of building custom adapters for every tool, MCP provides a universal interface. Once a tool supports MCP, any compatible AI can interact with it without additional custom wiring. The integration becomes reusable, predictable, and scalable.

    How MCP Works (At a High Level)

    At its core, MCP follows a simple three-part structure.

    There’s the host, which is where the AI lives. This could be a chat application, an IDE, or a desktop app. From the user’s point of view, this is where questions are asked, and answers appear.

    Inside the host sits the client, which understands the MCP protocol. The client is responsible for talking to MCP servers and handling requests in a standardized way.

    Finally, there’s the server. The server exposes real capabilities, access to databases, APIs, internal services, or external platforms like email or monitoring tools.

    When a user makes a request, it flows from the host to the client, through the MCP protocol, and into the server. The server acts or fetches the data, and the result flows back along the same path.

    Article content

    What MCP Actually Exposes to the AI

    One important detail is that MCP doesn’t give the AI unrestricted access. Instead, everything is exposed in a structured, intentional way.

    An MCP server can offer tools, which represent actions the AI is allowed to take, such as sending an email or querying a database. It can also expose resources, which are read-only pieces of information like logs, schemas, or configuration files. In addition, servers can provide prompt templates that guide how interactions should happen, reducing guesswork and improving consistency.

    This structure keeps interactions safe, predictable, and easy for the AI to reason about.

    Why MCP Is a Big Deal

    The real breakthrough with MCP is dynamic discovery.

    In traditional integrations, developers have to hardcode what a service can do. If something changes, the code must be updated manually.

    With MCP, the AI can simply ask the server: “What capabilities do you have?”

    The server responds with a machine-readable description of its tools and resources. This allows the AI to adapt automatically as systems evolve, without new code, redeployment, or rewiring.

    This is a fundamental shift. Integrations stop being static and start becoming self-describing.

    From Chatbots to Real AI Agents

    MCP doesn’t replace APIs. Instead, it wraps them in a way that’s friendly to AI systems.

    By standardizing how AI connects to tools and data, MCP makes it possible to move beyond simple chat interfaces and toward AI agents, systems that can navigate workflows, coordinate multiple tools, and handle real operational tasks.

    That could mean booking travel, troubleshooting production issues, or assisting with incident response, end-to-end, not just as a suggestion engine.

    Whether you’re a developer building MCP servers in Python or a non-technical user using no-code platforms like n8n, MCP lays the groundwork for more capable, scalable, and reliable AI systems.

    The Takeaway

    Just as USB-C simplified the hardware world, MCP is simplifying the AI integration world.

    Less custom code. More reuse. Smarter systems that can actually act.

    This feels less like a small technical improvement and more like a turning point, the moment AI starts becoming truly connected to the systems it’s meant to help run.