How KushoAI UI CLI Fixes What Traditional UI Tests Keep Breaking

#ui #testing #playwright #tutorial

In the previous blog, we explored why UI tests tend to break so often, not because the tools are bad, but because the UI layer itself is the most unstable part of any application. Small visual changes, asynchronous behavior, and environmental inconsistencies can cause tests to fail even when the user experience remains intact.

This leads teams to spend more time fixing automation than shipping features. Instead of fighting these problems sprint after sprint, it’s worth asking a different question: What if UI testing worked differently from the ground up?

Why Most UI Testing Tools Still Feel Heavy

Most UI testing tools still rely heavily on scripts tightly coupled to the UI structure. Writing and maintaining these scripts requires deep knowledge of selectors, timing behavior, and internal implementation details, things that change frequently as products evolve.

Over time, this results in long maintenance cycles, fragile tests that break on minor UI updates, and CI failures that are difficult to debug.

Introducing KushoAI UI CLI

To streamline these tedious tasks, KushoAI has introduced its UI/CLI testing tool, which can test your UIs in minutes.

KushoAI CLI takes your recorded user flows and generates exhaustive test variations. Record your user flow once, and KushoAI creates multiple test cases with different inputs, edge cases, and scenarios to provide thorough test coverage.

The tool transforms manual testing into intelligent, automated test scenarios with minimal effort.

Getting Started with UI Testing Using KushoAI UI CLI

To use the KushoAI UI CLI, visit the KushoAI website and create an account; no credit card is required.

Prerequisites: Node version 18 or above, a Terminal Editor, and Git.

#1 Clone the Kusho CLI Repository.

Head over to the KushoAI CLI repo and clone it to use the UI CLI in your terminal.

git clone https://github.com/kusho-co/kusho-cli.git
cd kusho-cli

After the repository is cloned, in your terminal, install Playwright.

npm install

npx playwright install  # this will install the browser binaries

# Link the package globally to use the 'kusho' command
npm link

#2 Set up Credentials

Use the command kusho credentials to set up your Kusho credentials in the terminal. You will need to provide the email address you used to log in to KushoAI and the CLI Auth token, which you can get from the website's UI Testing page.

This is how the setup of the credentials will look:

#3 Record UI Interactions

Start recording your UI interaction using:

kusho record

After recording, Kusho AI generates comprehensive test scenarios that open in your terminal editor.

What you can do:

Review Generated Tests: See all test variations created from your recording.
Edit Existing Tests: Modify selectors, assertions, or test logic as needed.
Add New Tests: Create additional test scenarios for edge cases.
Remove Unwanted Tests: Delete any test scenarios you don't need.

Editor Quick Commands:

Vim: Press i to edit, Esc then :wq to save and exit

Nano: Edit normally, Ctrl+X , then Y then Enter to save

Vi: Press i to edit, Esc then :wq to save and exit

Save the file to proceed to test generation.

Kusho integrates your recordings with customized tests to generate a detailed, executable test script. This process merges your original recordings with tailored test scenarios, generates multiple test variations and edge cases, converts everything into optimized Playwright code, and ultimately creates a comprehensive test script ready for execution.

#4 Run Tests

To execute your generated test suites, use the command below:

kusho run /Run latest test kusho run latest /Run specific test kusho run your-test-name /Run with additional option kusho run your-test-name --headed --record

After the test run, a comprehensive test report will open in your browser.

Who is KushoAI UI CLI best for

KushoAI UI CLI is especially useful for teams that are already frustrated with flaky UI tests and constant maintenance overhead. If your UI tests break more often than they catch real issues, this approach can significantly reduce noise and rebuild trust in automation.

It’s also a strong fit for fast-moving frontend teams where UI changes are frequent and for startups or scaleups that don’t have large QA teams dedicated to maintaining complex test suites.

Final Thoughts

Most of the frustration around UI testing comes from over-engineering and over-reliance on scripts that are too close to the implementation.

Stability comes from better abstraction, clearer intent, and using UI tests for what they’re actually good at. With KushoAI UI CLI, teams can spend less time fixing broken tests and more time focusing on what matters most: shipping reliable features with confidence.