Vibe coding testing

Vibe coding testing for the apps your agent ships verified in a real browser

When an AI agent or app builder ships code fast, its only proof is code-level. Point Kane CLI at the live app and verify the real flow in a browser with plain-English objectives. Free to install.

npm install -g @testmuai/kane-cli

or read the documentation

Why vibe-coded apps need a verification pass

Vibe coding means describing what you want and letting an AI agent or app builder ship it. That speed is the point, but the agent reasons over text: source code, types, unit tests. It never opens a browser to see the rendered result.

So when the agent declares passed, it is reporting on the code surface only. The runtime UI is invisible to it. The button wired to the wrong API, the redirect that 404s, the form that skips validation, the blank deployed build all slip through.

Kane CLI is the second pair of eyes. Describe the journey in plain English and it drives your live URL in a real Chrome browser, checks each step, and returns a verified pass or fail. Your agent can run it too, closing its own loop.

Kane CLI verifying a vibe-coded app flow in a real browser

What Kane CLI does for vibe coding testing

Real-browser verification of the flow your agent built, no framework knowledge required.

Sees what the agent cannot

Your agent judges its own work from code that compiles and types that check. Kane CLI opens the vibe-coded app in a real Chrome browser and judges it from the rendered screen, so a flow that only looks done gets caught before it ships.

Test in the language you prompt in

You built the app by describing it, so test it the same way. Plain-English objectives, no selectors, no XPath, no Playwright. If you could prompt the feature into existence, you can describe the journey that proves it works.

Verified pass or fail with evidence

No more trusting a green check that only reflects code signals. Every run returns a binary pass or fail plus a video, a step trace, and a ShareLink pinpointing the exact step where the generated flow fell apart.

Works with whatever built the app

Lovable, Bolt, v0, Replit, Cursor, Claude Code, it does not matter. Kane CLI points at your live URL, so it verifies the running result no matter which builder or agent vibe-coded it.

Checks every step, not just the last screen

Vibe-coded flows tend to break in the middle: a redirect that 404s, a form that skips validation, a modal that never closes, a console error nobody saw. Kane CLI verifies each step instead of just the final state.

Re-verify after every reprompt

Every follow-up prompt quietly rewrites components and can undo a journey that worked an hour ago. Lock in your known-good flows and replay them after each change so reprompting never silently regresses the app.

Build up confidence in what your agent shipped

Start in your terminal

Validate on the cloud

Release with confidence

Built for the prompt-then-verify loop

Kane CLI and KaneAI share the same automation engine and dashboard.

Close the verification gap

Your agent ships a feature in minutes, but verification has not kept pace. Kane CLI runs the freshly vibe-coded flow in a real browser the moment it lands, so the app gets proven as fast as it gets generated.

Test what the agent cannot see

An agent declares passed from code signals it can read, never from the rendered page. Point Kane CLI at your live URL and it watches the actual app behave, catching the broken flow the source code happily compiled.

Proof that outlives the prompt

Each run leaves a persistent video, a step trace, and a replay link. Drop it into a PR or a bug report so the verified result for that vibe-coded change is something the whole team can open and trust.

Test your vibe-coded app in three steps

Install Kane CLI

Run npm install -g @testmuai/kane-cli and sign in with your TestMu AI account. There is nothing to bolt into the app your agent vibe-coded for you.

Point it at your live URL

Hand it the preview link or deployed domain of the app you just prompted into being. Run flows yourself, or have Claude Code, Cursor, or Codex run them right after it edits the code.

Describe the flow in plain English

Spell out the journey the way you described the feature to your agent: sign up, create a record, confirm it shows. Kane CLI watches the rendered app run and tells you what actually broke.

Get Started With Kane CLI

🎉 Launch offer: Bonus credits for the first 3 months on paid plans

Choose the right plan for you

Local test authoring via CLI

Auto-heal & vision

View test cases on UI

Test Manager

Free

/month

200 Credits

Resets in every

30 days

Free tier

Starter

$19

/month

2000 Credits

Launch: 4,000 Credits (+100%)

Bonus for first 3 months

Free tier

Get the technical rundown

Blog

A look at Kane CLI. What we built, what it does, and where it is headed.

Read the blog

Documentation

Everything you need to install, configure, and run Kane CLI in under 2 minutes.

View documentation

GitHub

Browse the source, file issues, and follow the roadmap on GitHub.

Open GitHub

Frequently asked questions

Vibe coding testing is the verification pass for apps built by describing what you want to an AI agent or app builder rather than writing every line yourself. The agent ships a feature fast, but its only proof is code-level: it compiles, types check, the diff looks right. None of that confirms the rendered app works for a real user. Vibe coding testing closes that gap by running the live app in a real browser and confirming the actual flow. Kane CLI does exactly this: describe the journey in plain English and it drives a real Chrome browser to return a verified pass or fail.

Because code velocity now outpaces verification velocity by an order of magnitude. An agent can ship a feature in minutes, but it reasons over text: source code, types, unit tests. It cannot open a viewport and see that the button is wired to the wrong API, the redirect 404s, the form skips validation, or the deployed build renders blank. When an AI agent declares "passed," it is reporting on the code surface only. The runtime UI is invisible to it. Vibe-coded apps need a real-browser pass before they reach anyone, and that is what Kane CLI provides.

No. Kane CLI takes objectives in plain English, with no selectors, XPath, or framework boilerplate. Write the journey the way you would describe it to a teammate, for example "open the app, sign up as a new user, create a record, and confirm it appears on the dashboard." The agent resolves the path and verifies each step. This is the whole point of vibe coding testing: if you can describe the flow, you can test it, no matter which builder or agent generated the app.

Yes, and that is how the verification gap closes for good. Install the Kane CLI skill into Claude Code, Cursor, Codex, or Gemini CLI, and right after the agent generates a change it runs Kane CLI with the --agent flag, reads the structured NDJSON result, and decides whether to keep going, fix the bug, or hand it back to you. Point it at the guide at testmuai.com/kane-cli/agents.md. The agent writes the code, Kane CLI confirms the rendered app actually works.

Yes. Authenticate with your TestMu AI credentials, pass --headless and --timeout, and gate the pipeline on the exit code: 0 on pass, 1 on fail, 2 on setup or auth errors, and 3 on timeout. Replay your signup, core data, and checkout flows on every deploy so a broken redirect or a missing env var introduced by the latest reprompt is caught in CI instead of by your users.

Installing and running the CLI costs nothing. Local runs are free; cloud runs on the TestMu AI grid bill against your TestMu AI plan. Start on the free tier and verify your vibe-coded app from signup to checkout without a credit card.

Teach your agent to verify what it ships

Point your coding agent at the Kane CLI guide and it will install, authenticate, and verify the signup, data, and checkout flows in a real browser on its own, closing the prompt-then-verify loop without you.

Point your agent to: testmuai.com/kane-cli/agents.md