kane-qe, explained simply

A robot tester you can talk to, and a dashboard that tells you what really happened

You describe a test in normal words. An AI clicks through the website like a person would. kane-qe shows you every click as it happens, and when something breaks, it works out whether the website is broken or the test was asked to do something wrong.

The cast

Five things working together

you

The tester

You write what to check, like “add an iPod to the cart and make sure the total is right”.

Claude Code

Your assistant

The AI coding app you already chat with. It can start tests for you and explain the results.

kane-qe

The dashboard

This project. A panel inside Claude Code with tabs for running, reading and organising tests.

kane-cli

The messenger

A command-line tool from LambdaTest that carries your test to KaneAI and brings results back.

KaneAI

The robot tester

An AI that opens a real Chrome browser, reads the page, decides what to click, and checks what you asked.

flowchart LR
  Y["You
“check the cart total”"] --> C["Claude Code"]
  C --> Q["kane-qe
dashboard"]
  Q --> K["kane-cli"]
  K --> A["KaneAI
robot tester"]
  A --> W[("The website
in real Chrome")]
  A -. "every step, live" .-> Q
  A -. "evidence pack
screenshots, network, console" .-> Q
  Q -. "who is to blame?" .-> Y

One test, start to finish

What happens when you press Run

1. You ask. Type /kane and a sentence, or press Run in the panel, or just ask Claude.

2. A quick sanity check. If your sentence never says what to verify (“…and assert…”), kane-qe pauses and offers to add a check, so you don't pay for a test that proves nothing.

3. The robot works. KaneAI opens the site and does the steps. You watch each one appear in the panel, above the prompt, and in the status line.

4. A verdict. Passed or failed, plus anything it was asked to remember, like a price or an error message.

5. The evidence. Every run saves an evidence pack: a screenshot per step, every network request and every browser console message. kane-qe reads it for you.

sequenceDiagram
  autonumber
  actor You
  participant P as kane-qe panel
  participant K as KaneAI
  participant S as Website
  You->>P: "Search iPod, add to cart, assert total"
  P->>P: has a check? yes
  P->>K: run it
  loop each step
    K->>S: look, decide, click or type
    K-->>P: step done
  end
  K-->>P: verdict + evidence pack
  P-->>You: passed / failed + who owns it

The clever part

When a test fails, whose fault is it?

A failed test does not always mean the website is broken. Maybe the test asked for something impossible, maybe it ran out of time, maybe the robot got confused. kane-qe looks at the evidence and sorts it out, so you only file bugs that are real.

flowchart TD
  F["Test failed"] --> R{"Did it even start?
(credits, setup)"}
  R -- no --> N["Didn't run
top up or fix setup"]
  R -- yes --> E{"Did the website show
NEW errors right where
it failed?"}
  E -- "yes" --> B["Likely a real bug
(or needs a look)"]
  E -- "no" --> W{"What does KaneAI
say went wrong?"}
  W -- "wrong data or
missing button" --> T["The test is wrong"]
  W -- "ran out of steps
or time" --> S["The settings stopped it"]
  W -- "it got confused" --> M["The robot (AI) slipped"]

Noise is ignored. Big sites log errors all the time, from ads and trackers. kane-qe ignores errors from other companies' scripts and errors the page was already showing before the failure. Only new errors from the website itself count.

It tells you what to do next. A real bug gets a Draft bug report button. A wrong test gets Fix the test with Claude. A setting problem says which setting to raise.

THE ROBOT SLIPPED

Amazon, from India

Asked to add headphones to the cart on amazon.com, the robot kept the delivery country as India, where the item couldn't ship, and got stuck. Amazon logged 58 console errors, all from ads or already there before. Not a product bug.

THE TEST IS WRONG

Searching “zzqxwv”

The test expected at least one product for a nonsense word. The site correctly said “no products”. KaneAI called it test data, so kane-qe said: fix the test.

THE TEST IS WRONG

Switch to euros

The test looked for a currency menu this demo shop doesn't show. KaneAI: locator problem. The website was fine.

SETTINGS STOPPED IT

Empty review form

The step limit was set to 8, and the run used them all just before reading the warning. Raise the limit, rerun.

DIDN'T RUN

Out of credits

The account hit zero mid-run. That's never counted as a failed test; the panel says to top up.

CLEAN PASS

Cart quantity × 2

iPod Nano $122.00 × 2 = $244.00 on the cart page. Passed, and the website logged no errors of its own.

Real numbers

Exploring a shop, one scenario at a time

Each test costs credits, KaneAI's currency. These are 10 real scenarios run against LambdaTest's demo shop while building this project. Longer journeys cost more; a confused robot costs more still.

passedfailed: the test was wrong or limited

Guest checkout cost the most (52 credits) partly because the robot clicked “add to cart” and “Guest Checkout” twice each. kane-qe flags that as wasted effort.

Where the time goes

Thinking vs. clicking

A run's time splits three ways: the AI thinking (reading the page and deciding), the browser working (clicking, loading, taking screenshots), and waiting (pages loading, setup, saving evidence).

In the guest-checkout run below, more than half the time was the AI thinking. That's normal for a long journey, and it's why a clear, specific objective is cheaper and faster than a vague one.

165.5 s

AI thinkingbrowserwaiting & overhead

From a document to proof

Turning a requirement into tests that prove it

Teams write requirements: “a shopper can search; when nothing matches, show a message”. The Assurance tab feeds that document to KaneAI, which lists the use cases in it, asks you about anything unclear (you answer with a button), and writes one test per scenario.

Then you run those tests. Two numbers tell you where you stand: designed (does every promise have a test?) and proven (did those tests actually pass?).

flowchart LR
  D["Requirement
doc or ticket"] --> U["Use cases"]
  U -- "questions?" --> A["You answer
with a button"]
  A --> U
  U --> T["Tests written
for you"]
  T --> R["Run them"]
  R --> P["Coverage:
designed + proven"]

Search the catalog: designed100%

Search the catalog: proven by runs100% · 5 of 5

View a product from results: designed0%

Real result: one PRD, 2 use cases found, 3 tests designed for the first, all 3 passing.

The dashboard

Six tabs, one job each

Run

Start and watch

Type a test, press Run, see each step live. Several runs at once show as a list.

Insights

What really happened

Whose fault, wasted effort, a step-by-step timeline with screenshots.

Tests

Your saved tests

Rerun them here, on LambdaTest's cloud machines, or on phones and tablets.

Assurance

Requirements → proof

The document-to-tests loop above, with coverage numbers.

History

Everything so far

Trends, credits spent, page speed, and Sites: what you've explored on each website.

Setup

Is everything ready?

Words you'll see

A tiny glossary

Objective: The test, in plain words: what to do and what to check.
Assertion: The “check” part: “assert the total is $244”. Without one, a test can't fail, so it proves nothing.
Evidence pack: One file per run with every screenshot, network request and console message. Proof of what happened.
Credits: What KaneAI charges per run. A short test is about 10–20; a long journey 40–60.
Flaky: A test that sometimes passes and sometimes fails with no change. kane-qe can rerun one 3 times to check.
Grid: LambdaTest's cloud computers (HyperExecute) that run your tests in parallel, including on virtual phones.
Coverage: How much of a requirement has tests (designed) and how much passed (proven).
Console / network errors: Problems the website reports in the browser's developer tools. New ones at the failing step are the strongest hint of a real bug.

Try it

Three steps to your first test

Install the tester: npm install -g @testmuai/kane-cli, then sign in from Claude with ! kane-cli login --oauth.
Add kane-qe to Claude Code: /plugin marketplace add 4DvAnCeBoY/kane-qe, then /plugin install kane-qe@kane-qe.
Run something: /kane https://ecommerce-playground.lambdatest.io search iPod and assert at least 4 results.

Want every button and shortcut? The Field Guide has the full reference and a 5-minute video.