Test the apps Cascade builds in Windsurf before you ship
Cascade edits many files at once, so an accepted diff does not prove the running Windsurf app works. Kane CLI drives it in a real browser, verifies each step in plain English, and catches what the edit broke.
or read the documentation
Why test apps built with Windsurf
Windsurf's Cascade agent reasons across the whole codebase, edits many files at once, runs builds, and can deploy to Netlify. Teams ship real full-stack apps this way, so the running app needs eyes the diff cannot give.
Cascade auto-applies edits in a non-interactive diff, so accepting a change does not prove it. It touches files you never named and drifts as context compresses, so a flow that passed an hour ago can break silently.
Kane CLI checks the running app, not the diff. Describe a journey in plain English and it drives your deployed app in a real Chrome browser and names the step that breaks. Agent-native, so Cascade runs it via --agent in one loop.
What Kane CLI tests in your Windsurf app
From the feature Cascade just shipped to the flows a wide multi-file edit may have broken, verified in a real browser.
The feature Cascade just shipped
Walk the exact flow Cascade built this run, from the new route to the action that proves it works. Confirm the running app matches the diff you accepted, not just that the file compiled.
Auth and protected routes after a rewrite
Cascade's classic failure is dropping an auth or CSRF check while rewriting a route. Sign up, log in, hit a protected page, and catch the guard that silently went missing.
API-backed CRUD and data
Windsurf wires up Prisma, API routes, and forms fast. Create, read, update, and delete real records through the UI and confirm the data persists, not just that the endpoint returns 200.
Multi-file edit blast radius
Cascade touches files you never mentioned, so a change to one component quietly changes others. Re-run your known-good journeys to catch the working feature that started behaving differently.
Responsive UI and console health
Generated shadcn and Tailwind layouts can overflow on mobile or throw hydration and console errors. Load the deployed app in a real browser, check it across viewports, and surface the errors users would hit.
Regression across a long session
By hour three, context drift means Cascade has forgotten earlier constraints. Lock in the flows that passed early and re-run them so a late-session edit cannot ship a regression unnoticed.
Trust the running app, not just the accepted diff
Start in your terminal
Validate on the cloud
Release with confidence
Built for the Cascade build-then-verify loop
Kane CLI and KaneAI share the same automation engine and dashboard.
Verify the run, not just the diff
Cascade auto-applies its edits and shows a non-interactive diff, so accepting it is not the same as proving it works. Kane CLI drives the running app and closes the gap between a green build and a verified user journey.
Cascade fixes what Cascade broke
Windsurf already runs builds and shell commands and self-corrects. Give it Kane CLI through the --agent flag and that loop extends to the live app: it runs the flow, reads the result, and repairs the route or component it just broke.
Evidence the multi-file edit is safe
Every run produces a persistent video, a step trace, and a replay link. When a Cascade edit touches files you never named, you get proof of which flows still pass and which regressed.
Test your Windsurf app in three steps
Install Kane CLI
Run npm install -g @testmuai/kane-cli and sign in with your TestMu AI account. It lives in Windsurf's integrated terminal, with nothing to wire into your project.
Hand it to Cascade, or run it yourself
Point Cascade at the Kane CLI guide so it runs flows with the --agent flag in its build loop, or run them yourself against your deployed app URL after Windsurf ships a feature.
Describe the flow and verify
Write the journey Cascade just built in plain English. Kane CLI drives a real browser, verifies each step, and returns a pass or fail with video evidence of where it 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
$0
/month
200 Credits
Resets in every
30 days
Starter
$19
/month
2000 Credits
Launch: 4,000 Credits (+100%)
Bonus for first 3 months
Pro
$99
/month
10,000 Credits
Launch: 15,000 Credits (+50%)
Bonus for first 3 months
Enterprise
Get access to solutions built on Enterprise-Grade Security, Privacy, and Compliances.
Need more credits?
Got a bigger use case in mind?
Let’s talk
Choose the right plan for you
Free
$0
/month
200 Credits
Resets in every
30 days
Starter
$19
/month
2000 Credits
Launch: 4,000 Credits (+100%)
Bonus for first 3 months
Pro
$99
/month
10,000 Credits
Launch: 15,000 Credits (+50%)
Bonus for first 3 months
Enterprise
Get access to solutions built on Enterprise-Grade Security, Privacy, and Compliances.
Need more credits?
Got a bigger use case in mind?
Let’s talk
Get the technical rundown
Documentation
Everything you need to install, configure, and run Kane CLI in under 2 minutes.
Frequently asked questions
Install Kane CLI, then describe the journey in plain English, for example "open the app, sign up, create a project, and confirm it appears on the dashboard." Kane CLI drives the running app Cascade built in a real Chrome browser, checks each step, and returns a clean pass or fail with video evidence. Run it yourself from the integrated terminal, or let the Windsurf agent run it with the --agent flag in its loop.
Windsurf is an agentic IDE, and its Cascade agent edits across many files in one run, often touching files you never mentioned. That reach is the point and the risk. A common Cascade failure is silent regression: it rewrites a route for a new use case and quietly drops an auth or CSRF check, or "fixes" one feature and breaks another. Context drift makes it worse, since by hour three Cascade works from a compressed view of your codebase that has forgotten earlier constraints. Reading the diff does not prove the running app works. Kane CLI verifies the real app in a browser so the regression surfaces before your users do.
The running full-stack app Cascade built and deployed: end-to-end journeys, sign-up and login, protected routes and sessions, forms and validation, API-backed CRUD, navigation across pages, and the absence of broken links or console errors. It checks each step, not just the final screen, and flags the exact point where a multi-file edit broke the flow.
Yes. Kane CLI is built for AI coding agents, and Windsurf is one. Point Cascade at the guide at testmuai.com/kane-cli/agents.md and it will install, run flows with the --agent flag, read the structured results, and fix the route or component it just broke before you see it. Cascade already runs builds and shell commands and self-corrects, so verification fits straight into that loop.
Yes. Authenticate with your TestMu AI credentials, pass --headless and --timeout, and gate your pipeline on the exit code: 0 on pass, 1 on fail, 2 on setup or auth errors, 3 on timeout. Run your key flows on every Netlify or Vercel deploy, so a context-drift regression never reaches production.
The CLI is free to install and use. Local runs are free; cloud runs on the TestMu AI grid are billed against your TestMu AI plan. Start on the free tier and verify your app end to end without a credit card.
Teach Cascade to test what it builds
Point Windsurf at the Kane CLI guide and Cascade will install, authenticate, and verify the running app in a real browser, then fix the route or component it just broke.
Point your agent to: testmuai.com/kane-cli/agents.md