The four levels of autonomous software testing
1. Assisted authoring. You say what to test, it writes the code. Real time saved. You still decide everything.
2. Generated coverage. It proposes what to test from a specification or the running app. You review the plan. Where most products genuinely are.
3. Self-maintaining. Coverage adapts as the product changes without someone repairing it. Requires distinguishing intended change from regression.
The fourth is closed loop: it detects a failure, hands evidence to a coding agent, and verifies the fix. That exists today in a narrow form, for behavioral defects with a clear reproduction, and does not extend to anything requiring a product decision.
What each level asks of you
Level one: know what to test. All the judgement stays with you.
Level two: review a plan. Faster than writing, and it is not zero, and skipping it is how you get coverage nobody understands.
Level three: decide what counts as intended change. The tool cannot know that a flow was deliberately redesigned.
Level four: define correct precisely enough that a fix can be verified without you.
Notice that the human work does not disappear as you climb. It moves up the stack, from typing toward deciding, which is both more valuable and harder to delegate.
The ceiling nobody markets
No level removes the need to decide what correct means. A tool can derive that an endpoint exists and that a field is a string. It cannot derive that two discounts should not stack, because that is a business rule that lives in a decision someone made.
Any product implying otherwise is describing level two and calling it level four.
Questions that place a product on the ladder
Vendors describe themselves at the highest rung they can defend, so it is worth having questions that locate them precisely.
Who decides what gets tested. If the answer is that you do, it is level one regardless of how the test is authored.
What happens when the interface changes but the behavior does not. If a human repairs the test, it is level two. If it survives, three. If it survives and still fails when behavior actually changed, three done properly, which is rarer.
And what happens after a failure. If the output goes to a dashboard for a person, that is where it stops. Level four means the output is consumable by whatever fixes the problem, and the fix gets verified without a human relaying anything. Asking these three in order takes five minutes and produces a much more honest placement than any feature list.
Getting started
Terminal
npm install -g @testsprite/testsprite-cli
testsprite setup
If you would rather not install anything, the dashboard does the same thing. Everything else the command line can do is in the CLI repository.
If the pipeline belongs to another team, the GitHub App is the path of least resistance: it is a webhook, it changes nothing in your repository, and it fires when your build reports the new version live. If you want the check visible in the repo instead, a GitHub Actions step does that.
Where TestSprite sits on the ladder
Level two throughout, level three for behavioral change, and level four in the narrow form: a failure returns as something a coding agent can act on, and the fix gets verified by the same check rather than by the reasoning that produced it.
Concretely, coverage is generated from your product and refined in plain language, steps are intentions so cosmetic change does not break them, and the verification skill installs into the coding agent you already use so the loop happens where the work is.
What stays with you is the ceiling described above: deciding what correct means for an ambiguous rule. Everything below it moves, and the benefit is that coverage stops being limited by how much anyone can author.
What level is realistic today?
Two, with three for behavioral changes and four in a narrow form for defects with a clear reproduction.
Does autonomy mean fewer people?
It means different work. The mechanical half shrinks and the judgement half becomes the job.
How do we know it is not just generating noise?
Read the plan, cut what does not matter, and measure escaped defects rather than test counts.
What breaks at level three?
Intended changes. A redesigned flow looks identical to a regression unless someone says otherwise.
Is a closed loop safe?
For behavioral defects with a clear reproduction and a check you confirmed can fail, yes. Beyond that it is optimistic.
A ladder, not a switch.
Autonomous software testing runs from assisted authoring to a closed loop, and most products sit at generated coverage. Human work moves up the ladder rather than disappearing, and no level removes the need to decide what correct means.