Visual testing without writing tests
A new category of tools generates its own coverage instead of asking you to author it — Meticulous replays recorded sessions, TestDriver drives a sandbox, VisualMax discovers routes. How each gets coverage, and what each gives up.
Every tool in the established roundups — Percy, Chromatic, Applitools, Argos, Playwright — shares one assumption: a human decides what gets tested. You write a snapshot call, an SDK call, or a Storybook story. A page nobody wrote one for is invisible.
A separate category has grown up around removing that assumption. These tools generate their own coverage. They are not all doing the same thing, and the differences decide whether one fits your product.
Three ways to get coverage without authoring it
| Approach | Coverage comes from | Needs | Tool |
|---|---|---|---|
| Session replay | What users actually did | A recorder script in your app, plus traffic | Meticulous |
| Agent exploration | An AI driving your app in a sandbox | A running build | TestDriver |
| Route discovery | The routes that exist in your app | A repository connection | VisualMax |
Those are genuinely different bets about where truth lives — in user behaviour, in an agent's exploration, or in the application's own structure. None is obviously right.
Best for: Products with real traffic on staging or production, where covering actual user journeys matters more than covering every route.
- License
- Commercial
- Pricing
- Not published — meticulous.ai/pricing returned HTTP 404 on 13 September 2026; the site routes to a demo request
The most established tool in this category and the one to beat. The mechanism is genuinely clever: record clickstream and network data from real sessions, then on each pull request select the relevant ones and simulate them against your changed frontend, screenshotting at key points. Coverage is a by-product of usage rather than of discipline. The trade is that a page nobody visits is a page nobody tests, and the recorder script is a dependency inside your own application.
- Coverage reflects what users actually do, including multi-step journeys no one would think to script
- Backend responses are mocked by replaying recorded ones, so tests are side-effect free with no test-data setup
- Test suite evolves automatically — new flows added, stale ones removed, with no developer intervention
- Serious production credibility: YC Summer 2021, 100+ organisations, a public testimonial from an engineering leader at Dropbox
- Requires a recorder script installed in your application — a real security and privacy conversation, especially if you record production
- Needs traffic before coverage exists, so a pre-launch product or a rarely-visited admin page gets little
- Replaying mocked backend responses means you are not testing against live data behaviour
- No published pricing, so budgeting requires a sales conversation
Best for: Teams who want an agent to explore the app and leave behind readable regression tests.
- License
- Commercial
- Pricing
- $20/seat/month including 2 testing hours, then $0.14 per minute · $600/month tier
The most agentic of the three: an AI opens your app in a sandbox, finds bugs, and generates regression tests as committed files. The output being real test files is a genuine advantage — you keep them if you leave, which is not true of any hosted-baseline product here. The flip side is that an agent exploring is inherently less repeatable than a recorded session replayed or a route list captured.
- Runs every pull request in a real desktop sandbox, not a headless browser
- Blackbox by design — no access to source, DOM or internal APIs, so it tests what a user experiences
- Writes regression tests as readable files and opens them as pull requests you can review and keep
- Per-seat plus compute pricing is predictable in a way per-screenshot billing is not
- Compute-minute billing means an expensive run is an expensive month — model it against your PR volume
- Agent-driven exploration is less deterministic than replay or discovery by nature
- Broader than visual testing, so some spend goes to functional checks you may already have
- Newer, with a smaller track record than Meticulous
Best for: Teams who want every route covered from day one, including before the product has traffic.
- License
- Commercial
- Pricing
- First week free, then paid
This is our product, so weigh it accordingly — and the honest comparison with Meticulous is a real trade rather than a win. If your risk lives in complex multi-step user journeys and you have the traffic to record them, session replay covers something route discovery does not. If your risk is that pages exist which nobody has ever tested, discovery covers something replay cannot.
- Coverage from route discovery, so new pages are covered without traffic, a snippet, or a test
- No script in your application — connection is to the repository, not to your runtime
- Waits for real data and page readiness before capturing, rather than replaying mocked responses
- Maps changed source files to affected routes and recaptures only those
- Routes, not journeys — a multi-step flow that only breaks on step four is not what this is built for
- Meticulous has substantially more production track record
- Hosted only, with a smaller integration surface than the incumbents
- Not a component-library tool; Storybook coverage is better served elsewhere
What all three share
Two limitations worth being clear about before you conclude this category solves everything.
- Generated coverage is still coverage you did not specify. You lose the ability to say "test exactly this state" without falling back to something more manual. For a compliance-critical screen that needs a guaranteed check, an explicit test is still the right tool.
- Review is still human. None of these decide whether a change is intended. They reduce authoring work, not judgement work — and reviewer fatigue remains the second-biggest reason visual programmes get abandoned, after flake.
They also do not replace a component library's story coverage. If you have a Storybook design system, Chromatic or Loki still does something none of these do.
Choosing
- You have meaningful traffic on staging or production already
- Your risk lives in multi-step journeys, not single pages
- You can get a recorder script approved for your application
- Buying without published pricing is acceptable to your procurement
- You need coverage before you have traffic
- You cannot put a third-party script in your application
- Your risk is pages nobody has ever tested
- You want capture against real data, not replayed mocks
And TestDriver if what you actually want is an AI reviewer that both finds the bug and leaves behind a test file you own — a different shape of product from either of the above.
If you are evaluating this category against the established tools, the head-to-heads are in our full roundup, and the specific question of what AI is doing in each is in AI visual testing tools.
Frequently asked questions
Can you do visual testing without writing tests?
Yes. A category of tools generates its own coverage: Meticulous records real user sessions and replays relevant ones on each pull request, TestDriver drives your app with an AI agent in a sandbox, and VisualMax discovers routes from the running application. Each gets coverage from a different source, with different trade-offs.
How does Meticulous work?
You install a JavaScript snippet that records user sessions — clickstream and network data — on development, staging, preview or production environments. When you open a pull request, Meticulous selects relevant recorded sessions, simulates them against your changed frontend with backend responses replayed from the recording, screenshots at key points, and posts the visual differences as a comment.
How much does Meticulous cost?
It is not published. meticulous.ai/pricing returned HTTP 404 when checked on 13 September 2026, and the site routes to a demo request instead. TestDriver publishes $20 per seat per month including two testing hours, then $0.14 per minute.
Do these tools replace Storybook visual testing?
No. Session replay, agent exploration and route discovery all operate on the running application, so they cover pages rather than components in isolation. If you maintain a design system in Storybook, a component-level tool such as Chromatic or Loki still covers something these do not.
Sources
- Meticulouschecked 2026-09-13
- Meticulous on Y Combinatorchecked 2026-09-13
- TestDriver pricingchecked 2026-09-13
- Vizzly pricingchecked 2026-09-13
- Happo pricingchecked 2026-09-13