Run End-to-End Tests from Your Terminal with Kane CLI
Author and Run Tests Right from the Terminal in Natural Language, with an Evidence-Backed Pass or Fail from a Real Browser.
npm install -g @testmuai/kane-cli
Vibe Testing: What It Is, Principles, and How to Start
Vibe testing uses AI and plain-English prompts to check how software feels to users. Learn its principles, how it differs from scripted tests, and how to start.
Last Updated on:
A growing share of shipped code comes from AI assistants, and someone still has to check that it behaves the way a user expects. Vibe testing handles that check from the user's side: you describe the experience you expect in plain English, and an AI agent turns it into a test, runs it, and reports what it found.
The name borrows from vibe coding, the term OpenAI co-founder Andrej Karpathy coined in February 2025 for building software by prompting an AI instead of writing the code yourself.
TL;DR
Vibe testing is an AI-assisted QA approach in which testers describe expected user behavior in plain English and an AI agent generates, runs, and maintains the test. It checks whether a flow feels right to a user, such as clear error messages and obvious next steps, as well as whether it works.
- Intent-driven prompts: A vibe test starts from a sentence such as "submitting an empty form should tell the user which field is required", and the AI agent decides the clicks, inputs, and assertion needed to check it.
- Experience over function: Vibe testing targets UX failures that scripted assertions skip, such as silent form submissions, missing error states, and confusing labels, while unit and API tests keep covering the logic.
- Self-healing maintenance: Because a vibe test stores the intent rather than a fixed selector, the AI agent can find an element again after a UI change instead of failing on a renamed ID.
- Human review: Vibe testing still needs a person to write clear prompts and check what the agent asserted, because the model only knows the context the prompt gives it.
How Do You Start Vibe Testing?
Pick one high-traffic flow such as signup or checkout, describe its expected behavior in a prompt, and run it next to your existing automated test. TestMu AI's KaneAI and Kane CLI run vibe tests from natural-language prompts in a real browser and return a pass or fail with the check they made.
What Is Vibe Testing?
Vibe testing is an AI-driven QA approach that evaluates software from the user's point of view, using natural language prompts to generate and run tests. A scripted test asks whether a feature works; a vibe test also asks whether the experience matches what a user expects.
For a quick visual walkthrough of this concept, watch the video below from TestMu AI.
Subscribe to the TestMu AI YouTube channel for more tutorials on testing and automation.
- Describe the behavior - write the expected experience as a prompt, for example "the checkout page should show the order total before the payment step".
- Let the agent build the test - the AI agent reads the page, picks the elements, and decides which check proves the prompt true or false.
- Review the result - read the pass or fail together with the check the agent actually ran, then tighten the prompt where it guessed.
Note: Write your first vibe test in plain English with KaneAI and run it on TestMu AI's cloud. Try TestMu AI free
Why Teams Are Rethinking QA With Vibe Testing?
Teams adopt vibe testing because AI-assisted development ships UI changes faster than hand-written scripts can follow, and because many real defects are experience problems that pass every functional assertion.
- Less script upkeep - the test stores intent, so a renamed button or a moved field does not break it the way a hardcoded selector would.
- More people can write tests - product managers and designers can describe a flow in a sentence, and an engineer reviews the check the agent produced.
- Coverage for experience bugs - a form that submits silently, an error message that blames the user, or a dead-end page all pass "does it work" checks but fail a vibe test.
- A second look at generated code - when an AI assistant writes the feature, a vibe test written from the user story checks the result against intent rather than against the code's own assumptions.
- The unhappy paths AI code skips - an assistant writes the happy path it was shown, not the empty state, the expired token, the duplicate submit, the slow network or the odd input. A login can render and still not set the session, and a checkout can say "Order confirmed" while the payment call failed, which is why a vibe-coded app that looks right in the demo can break in production.
For help phrasing those user stories as prompts, see this guide on using ChatGPT for test automation.
What Are the Core Principles of Vibe Testing?
The core principles of vibe testing are intent-driven testing in natural language, adaptive exploration of real user behavior, and continuous refinement through feedback from each run.
- Conversational, intent-driven testing - testers define scenarios as prompts, and the agent generates and runs steps that serve that intent, so the test reads like the user story it checks.
- Exploratory, adaptive testing - the agent works from what is on the page at run time, which lets it handle dynamic content and try edge cases a fixed script never reaches.
- Continuous refinement - each run shows which prompts the agent read as intended and which it guessed at, and the tester tightens those prompts before the next run.

To compare platforms that put these principles into practice, see this roundup of vibe testing tools.
How Vibe Testing Differs from Traditional Testing?
Vibe testing focuses on user intent and experience, using AI to adapt as products change, while traditional testing relies on hand-written scripts that check expected functionality.
| Aspect | Traditional Testing | Vibe Testing |
|---|---|---|
| Approach | Hand-written test scripts or record-and-playback tools that follow step-by-step instructions. | AI interprets natural language prompts to create and run tests dynamically. |
| Focus | Checks if features work under expected conditions. | Evaluates the feel of the product, uncovering UX issues and emotional friction. |
| Script Maintenance | Test scripts break easily when UI changes; they require manual updates and brittle selectors. | Self-healing AI selectors adapt automatically to UI changes, reducing maintenance. |
| Test Description | Code-based: assert(button.text === "Book a Demo") | Conversational: "The button should clearly guide the user to request a product demo." |
| Function vs. Experience | Focuses solely on function: does it work? | Also checks the experience: is the flow clear, and does the user know what to do next? |
| Adaptability | Must be updated for every small UI or workflow change. | AI evolves tests alongside the product using ML-based understanding. |
| Underlying Technology | Manual effort, hardcoded selectors, often brittle under change. | An LLM-based agent that reads the page at run time and maps intent to elements. |
Example: A Vibe Test on a Real Form
This run used Kane CLI 0.8.10 against the Input Form Demo on TestMu AI's Selenium Playground. The prompt describes an experience, with no selectors or steps:
kane-cli run "Go to https://www.testmuai.com/selenium-playground/input-form-demo/ and click Submit without filling any field. Verify the form tells the user which field is required instead of submitting silently." --agent --headlessThe last line of the agent-mode output, trimmed to the fields that matter:
{
"type": "run_end",
"status": "passed",
"summary": "Submitted the input form without entering any information, as requested.\nThe form prevented submission and highlighted the required Name field with a message asking the user to fill it out.",
"final_state": { "required_field_feedback": "true" },
"context": { "memory": { "required_field_feedback": {
"condition": "The form tells the user which field is required instead of submitting silently.",
"code_js": "el(25).validationMessage === 'Please fill out this field.' && document.activeElement === el(25)",
"locators": ["internal:role=textbox[name=\"Name\"i]"]
} } },
"duration": 43.9,
"result_code": 100
}The agent turned "tells the user which field is required" into two checks: the browser's native validation message ("Please fill out this field.") and focus moving to the Name field. The run passed in 43.9 seconds. Reading that generated check is the review step, because it shows whether the agent tested what you meant.
How Is AI Used in Vibe Testing?
AI powers vibe testing through natural-language test creation, generated test cases and data, self-healing locators, and root-cause analysis when a test fails.
Spending on these capabilities is growing. Fortune Business Insights values the global AI-enabled testing market at USD 1.01 billion in 2025 and projects USD 4.64 billion by 2034, a CAGR of 18.30%.
- Natural-language test generation - a prompt replaces the hand-written script, the approach known as NLP testing.
- Generated test cases and data - AI can generate test cases from user stories and past bugs, plus input values and edge cases a tester might not list.
- Self-healing locators - self-healing test automation re-finds an element after a UI change instead of failing on a stale selector.
- Root-cause analysis - when a run fails, the agent points to the step and the likely cause rather than leaving a raw stack trace.
Teams with an existing Selenium suite can follow the same workflow through vibe testing with Selenium, which uses Cursor and an MCP Selenium server to turn plain English user journeys into runnable Selenium scripts.
What Is the Role of AI Agents in Vibe Testing?
AI QA agents do the writing, running, and upkeep of vibe tests: they read a natural language prompt, decide the steps, and adjust when the application changes.
TestMu AI's KaneAI is a GenAI-native testing agent built for this workflow. Teams plan, author, and run tests from natural-language prompts across web, mobile, and API layers:
- Inputs teams already have - KaneAI turns PRDs, Jira tickets, screen recordings, and GitHub PRs into executable tests, not only typed prompts.
- Framework export - generated tests export to Selenium, Playwright, Cypress, or Appium, so the team can own the code if it wants to.
- Self-healing - steps re-anchor when the UI changes, and the test run view shows which step auto-healed.
- Smart versioning and reusable modules - every test keeps a version history for comparison and rollback, and shared steps live in modules so one fix applies everywhere.
- Integrations - KaneAI connects to Jira, Azure DevOps, and GitHub, and runs on HyperExecute and the Real Device Cloud.
To try it, follow the guide on creating web tests with KaneAI.
Limitations and Key Considerations of Vibe Testing
- Prompts carry all the context - the model knows only what the prompt says, so state the intent, the expected result, and the edge cases explicitly. Techniques from prompt engineering help here.
- Generated checks need review - confirm that the steps and assertions the agent produced match the objective, as in the example above, before trusting a pass.
- Not a replacement for other layers - vibe testing covers end-to-end flows and UX, while unit, performance, security, and low-level integration tests stay in the pipeline.
- Run cost and time - an agent run takes longer than a compiled script (the example took about 44 seconds for one form check), so keep fast scripted tests for high-frequency regression.
Final Thoughts
Start with one flow your users hit every day, write its expected behavior as a prompt, and run it next to the scripted test you already have. Compare what each one catches before adding more.
The KaneAI getting started guide walks through the first test, and the vibe coding QA process covers the gates that turn these checks into a merge requirement.
Testing web or mobile apps without writing code? KaneAI by TestMu AI turns plain-English instructions into tests.
Author
Shantanu Wali is Vice President of Product Management at TestMu AI, where he owns several product lines across the testing platform, including the Real Device Cloud and the Digital Experience Testing Cloud. He has also contributed significantly to the development and scaling of KaneAI, TestMu AI's flagship GenAI-native testing agent that uses natural language to make software testing faster and more reliable in this AI era. He brings 7+ years of experience across software development and product management, starting as a backend developer at Infosys building solutions for Fortune 500 clients. Shantanu holds an MBA from IIM Calcutta and a B.Tech in Mechanical Engineering.
Reviewer
Harish Rajora is a software developer at TestMu AI with over 6 years of hands-on experience in Python and cross-platform application development across Windows, macOS, and Linux. He has authored 800+ technical articles and worked on large-scale projects, including GenAI applications and core engineering features used by millions. Harish has led DevOps initiatives building CI/CD pipelines with Jenkins, AWS, GitLab, and GitHub, and holds an M.Tech in Software Engineering from IIIT Allahabad.
Vibe Testing FAQs
Did you find this page helpful?
More Related Blogs
TestMu AI forEnterprise
Get access to solutions built on Enterprise
grade security, privacy, & compliance
- Advanced access controls
- Advanced data retention rules
- Advanced Local Testing
- Premium Support options
- Early access to beta features
- Private Slack Channel
- Unlimited Manual Accessibility DevTools Tests




















