Changelog

Feature flags are great for shipping safely, but the code behind them goes untested until launch day. Meticulous now finds the flags relevant to a PR and replays the affected flows with each one forced both ON and OFF, so you see how your app behaves either way before you flip the switch. This works even on flows that were recorded before the flag existed. Ask us to get your project set up today!

A new name, and a big upgrade! When a PR changes code that your existing sessions don’t cover, Meticulous' agent swarm automatically creates new test sessions tailored to the change. It analyses your diff and existing recordings, plans relevant test cases, drives your app, and shows how the new functionality behaves across a range of edge cases. This is great for testing new features and can be configured to use live backend for end-to-end testing capability. Agent Swarm Testing is currently in beta with a select group of projects.

Visual regressions aren’t the only issues worth catching. Meticulous now brings every new console error introduced in a test run into one organised summary, grouping matching errors and showing the flows and routes they affect. Each error also includes a 'Copy as prompt' action, making it easy to share the relevant error and route context with your coding agent for further investigation.

• ♿ Accessibility checks are now fully out of beta — violations are traced right to the React component that rendered them, plus new WCAG AA/AAA rule presets and redesigned check reports
• 🐛 Meticulous crawl covers more ground — it now accepts multiple start URLs in a single run, and adds a new depth mode that prioritises interacting with page elements.
• ✅ Agents can approve diffs — turn on a new project setting and your agents can approve or ignore expected diffs themselves (e.g. via the /meticulous-review skill), clearing the Meticulous check fully autonomously without a human review
• 🌱 Agents can grow your coverage — sessions an agent records to cover new code (e.g. via the /meticulous-increase-coverage skill) can now be added straight to your selected set instead of waiting for the next session selection, with coverage updating immediately

Your agent can now take part in the review process. It inspects the diffs in a test run, works out which ones are real regressions, and leaves comments explaining what went wrong.

It also works the other way round: it can read the diffs you've rejected and the comments you've already left, then use that feedback to fix the issues for you.

Try it out today with the Meticulous CLI, Skills or the MCP server — see the agent swarm docs to get started.

Meticulous does a lot of dark magic under the hood — error detection, network patching, powering up the flux capacitor. Sometimes, though, the easiest way to understand how your app reached a particular state is to watch the before and after replays side by side. Now you can.

• 🛜 More automated built-in checks (Beta) — We can now catch more non-visual regressions automatically, from increases in network traffic to extra React component renders. See the built-in checks docs, and let us know if you'd like early access.
• 💨 Faster onboarding — Adding more internal projects to Meticulous? New automated tooling makes it much smoother. See the docs.
• 🔗 Open a diff in your app — Right-click a diff to jump straight to that URL in your local development branch or your preview environment, so you can fix it even quicker.

"Did Meticulous actually test my change?" is the first thing you ask when you open a test run. Now it's easier than ever to answer that.

You can see every line your PR touched, the user flows that ran (with hover previews), and exactly which routes produced diffs. It's available to everyone — no beta, just transparency.

Meticulous is only as good as the sessions you record. Our original approach to boosting coverage — session extension, mutated network requests, and feature flags — reaches new uncovered states in your existing sessions.

Now we're taking that further. When your PR touches code that no existing session covers, our agentic harness generates entirely new sessions: it reads your code diff and existing recordings, plans new test cases, drives your app, and shows you how your feature behaves across a variety of edge cases.

This makes new functionality much faster to review, and it feeds coverage into future test runs too. We're looking for design partners — reply if you want early access.

Let your agents interface with Meticulous directly, helping them ship fewer regressions with less oversight. Our MCP server lets them see test run diffs, replay details, coverage data, and more. See the docs to get started.

• ♿ Accessibility testing (Beta) — We run axe-core across every replay in a test run and flag any new accessibility violations on the PR that introduced them.
• 💬 Comments are GA — The screenshot-doodle-and-share era is over. Comment directly on the exact spot on a diff and tell your team exactly what needs to change.
• 💅 Redesigned documentation — Rewritten, searchable, and restructured so both you and your agents can find answers more easily. Our changelog lives there too now.
• 🖼️ Replay fidelity improvements — On complex apps, playback videos were sometimes rendered without styles, making CSS diffs painful to debug. Not anymore.

Claude, migrate all 1000 class components to hooks. Use Meticulous to test this PR locally: if you see visual diffs, fix and re-run till you eliminate all unexpected diffs. Don't change any components Meticulous doesn't have 100% coverage for.

Claude, review the Meticulous test for the current commit, fix any issues.

Meticulous has thousands of sessions recorded, each mapped to the lines of code in your codebase, and covering real user journeys, network mocks and data edge cases.

Meticulous skills let your agent leverage this: either by pulling the results of a Meticulous test run, or by proactively finding the relevant sessions impacted by the local changes and running them against them. Get started here.

We're actively expanding these skills. If you've got a workflow you wish you could hand to an agent but can't, let us know!

Meticulous simulates most code paths and edge cases in your application on every change. Custom checks let you piggyback on this to detect regressions in anything you can measure.

We have checks that flag if a PR significantly increases:

• React-component re-renders
• Number of network requests made
• Bytes of JS code loaded across many flows
• JS statement execution count (deterministic proxy of CPU time)

You can also write your own checks – covering anything from performance to accessibility. Meticulous's deterministic browser can help reduce noise in many performance measures. Let us know if you'd like early access.

Reviewing as a team usually means screenshotting a diff, pasting it into Slack, and writing "wait, is this expected?" We're fixing that. You're now able to drop a comment on a diff and have the conversation right inside Meticulous, where all the context already lives. This is rolling out in beta shortly, give us a shout if you want early access.

Meticulous has always been brilliant at detecting frontend changes. Now we're going down the stack.

We've started recording and replaying what your server does, eg. Postgres queries and outbound HTTP calls, and surfacing backend spans right in the network tab alongside frontend requests. If you run a server-side-rendered app and you've ever wanted Meticulous to see the whole picture, this is for you.

• 🔌 WebSocket traffic in the network panel – The session network panel now logs WebSocket messages, not just HTTP requests, so realtime apps are far easier to debug.
• ⚙️ Web Worker replay – Apps that offload work to Web Workers now replay faithfully instead of going quiet.
• 🪟 Same-origin iframes in screenshots – We now inline same-origin iframe DOM into the screenshot, so embedded content actually shows up in your diffs.
• 🆕 Onboarding Explanation – improved experience for new joiners with more educational content on how to use Meticulous in the UI.

When you use Debug with AI, you get a full diagnosis of the difference. We rebuilt it so you can run it directly from the test run page. It now lives as a tab in the modal after you click into a diff. The agent reads in context from your PR and the Meticulous replay so it knows what code changed as well as all the events leading up to the diff.

We've added new tabs to the session recording page, making it easier to debug the recorder on new projects. The context tab shows you the user identity, session context, and what feature flags were active during that session. The network tab gives you a full log of every HTTP request, WebSocket message, and streaming fetch from that recording.

We have made it simpler to explicitly record a session for Meticulous rather than relying on background recordings. You can now see the length of the current recorded session and pin and label it directly from your frontend. Read more on how to get started.

• 📺 Live test run statuses auto-update – The test runs overview page now updates in real time; no more manually refreshing to see if your run finished.
• ⏩ Timeline jumps to the right screenshot – Opening the Timeline tab now scrolls straight to the screenshot you're looking at instead of dropping you at the top. The selected event is also saved in the URL, so when you share a link, whoever opens it lands right on the event you were inspecting.
• 🕵️ User event timeline upgrade – Side-by-side details panel, screenshot previews, and a real DOM path-diff on each event so you can see exactly what changed in the tree, not just that something changed.
• 🦾 Agent CLI – We love how you have been weaving Meticulous into your agentic setups. You can now log in directly via OAuth in the CLI rather than having to rely on an API token. Check out our docs to get started with agents in Meticulous.