Test the apps you build with Amazon Q before real users sign in
Amazon Q Developer ships features fast, but it reports success on code, not the rendered UI. Point Kane CLI at your running app and verify signup, forms, and the deployed build in a real browser. Free to install.
or read the documentation
Why test apps built with Amazon Q
Amazon Q Developer is AWS's AI coding assistant. It generates and edits code in your IDE and CLI, shipping agentic multi-file features from a single prompt, and that speed is the point.
But Amazon Q declares success on code-level signals: the build compiled, the test passed, the file changed. None of that confirms the rendered app works for a real user once a button, redirect, or form is actually clicked.
Kane CLI is the second pair of eyes. Describe the journey in plain English and it drives your live app in a real Chrome browser, signs up fresh, and returns a verified pass or fail. Amazon Q can run it via --agent.
What Kane CLI tests in your Amazon Q app
Signup, forms, and the deployed build, verified for a real user in a browser.
First-run signup, not your warm session
Kane CLI registers a brand new account against the app Amazon Q built, follows the post-login redirect, and checks the session survives a reload. Auth that compiles clean still routes the very first stranger to a dead screen.
CRUD that Amazon Q stitched together
It fills the forms Amazon Q generated, trips the validation, and reads the record back from the dashboard. The insert that compiles but quietly never lands in your AWS data store gets caught here.
The deployed build behind the demo
Localhost passing means little once Amazon Q ships to your domain. Kane CLI runs the live build to surface a blank render from a missing env value, a refresh that 404s on a deep link, and asset chunks gone stale after a redeploy.
Button-to-endpoint wiring
It clicks the control and confirms the right API answers and the result paints on screen. Amazon Q reasons over code, so a handler aimed at the wrong route reads correct in the diff while breaking in the browser.
Regression across multi-file edits
Amazon Q rewrites components and threads features through several files in one pass, and the next pass can undo a flow that worked. Pin your known-good journeys and replay them after each agentic edit.
A failing step Amazon Q can read
Each run hands back a video, a step-by-step trace, and a replay link pinned to the exact break. Feed that to Amazon Q and it patches the real defect instead of re-reading code that looks fine.
Build up confidence before real users sign in
Start in your terminal
Validate on the cloud
Release with confidence
Built for the build-then-verify loop
Kane CLI and KaneAI share the same automation engine and dashboard.
Close the loop Amazon Q leaves open
Amazon Q Developer ends its turn when the code compiles and the file is written. Kane CLI picks up where that stops, running the generated signup, CRUD, and deployed build as a user would before the feature counts as done.
Judge the render, not the reasoning
Amazon Q is confident about the code it produced, but confidence is not a working screen. Aim Kane CLI at the live app and it exercises the deployed build in a real browser, so the verdict comes from what loaded, not from the plan that wrote it.
A verdict Amazon Q can act on next
Each run leaves a saved video, a step trace, and a replay link, ready to paste into a PR or a bug report, or pipe straight back to Amazon Q so its next turn fixes the real break.
Test your Amazon Q 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 onto the code Amazon Q generated.
Aim it at the app Amazon Q built
Target your local server or your deployed domain. Launch flows from the terminal yourself, or have Amazon Q Developer fire them from your IDE or CLI the moment it finishes an edit.
Describe the journey, get a verdict
State it in plain English: sign up, submit the form, confirm the record on the dashboard. Kane CLI walks the real browser and hands back a pass or fail with video and a replay link to act on.
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 as a new user, submit the form, and confirm the record shows on the dashboard." Kane CLI drives your running app in a real Chrome browser, walks each step the way a user would, and returns a pass or fail with video evidence. Run it from the terminal against your local server or deployed domain, or let Amazon Q run it after it edits the code in your IDE or CLI.
Amazon Q Developer generates and edits code fast, including agentic multi-file features across the IDE and CLI, but it reports success on code-level signals: the build compiled, the unit test passed, the file changed. None of that confirms the rendered app works. The button can be wired to the wrong handler, the redirect can 404, the form can fail validation, and the deployed build can render blank from a missing config. Kane CLI runs the real app in a browser, as a real user, and tells you whether the flow actually works before you ship.
The signup and login journey for a fresh user, create-read-update-delete on your forms and data, the deployed build rendering instead of a blank screen, and regression after Amazon Q edits the code. It also catches SPA 404s on refresh, console errors, and broken API calls. It verifies each step, not just the final screen, and flags the exact point where the app breaks so you and Amazon Q know what to fix.
Yes. Because Amazon Q Developer lives in your IDE and CLI, it can install Kane CLI and trigger a run right after it finishes editing, using the --agent flag that streams structured NDJSON it parses on its own. Point it at the guide at testmuai.com/kane-cli/agents.md and the same agent that wrote the feature checks the rendered result and repairs the broken handler or form before it ever reaches you. One prompt, code plus proof.
Yes. Sign in with your TestMu AI credentials, add --headless and --timeout, and let the exit code decide the build: 0 passes, 1 is a failed flow, 2 is a setup or auth problem, and 3 is a timeout. Replay the signup and core CRUD journeys on every push so an Amazon Q edit that quietly breaks a working screen is caught in the pipeline, not in production.
Installing and running Kane CLI costs nothing. Runs on your own machine are free; runs on the TestMu AI cloud grid draw against your TestMu AI plan. Start on the free tier and put an Amazon Q built app through its full signup-to-dashboard journey without a credit card.
Teach Amazon Q to test what it builds
Amazon Q Developer runs in your IDE and CLI. Point it at the Kane CLI guide and it will install, authenticate, and verify the signup, form, and deployed-build flows in a real browser with the --agent flag on its own.
Point your agent to: testmuai.com/kane-cli/agents.md