Changelog

"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.

When looking at the before and after screenshots has you scratching your head, click on a diff to open up the new focused full-screen modal. You can see everything that happened leading up to that diff, and rapid access to all our more advanced debugging tools such as HTML DOM snapshots, replays, etc.

We've spent a lot of April making test runs quicker. A few of the bigger pieces:

• Parallel base & head execution – head replays no longer wait for the base run to finish. You'll notice this even more on stacked PRs
• Session slicing – a single long session used to slow down how quickly we could share test run results. They're now sliced into shorter, replayable chunks, which gets more of your real user flows into every test run without dragging runtime up
• Faster startup – replay workers have been rearchitected so less time is spent waiting for your test run to start executing
• Faster uploads – S3 transfer acceleration is on for recorder, asset, and container uploads
• More resilient runs – one bad chunk no longer fails the whole test run; we will automatically retry

Visual diffs are great, but "did this PR make the app slower?" is a question we keep hearing. Replays now capture real performance signals - memory usage, CPU pressure, TTI and more. Pair that with hardware-pinned benchmarking (so you're comparing apples to apples across instance generations) and you can start spotting perf regressions on the same PR-by-PR cadence as visual ones.

This is early and we're looking for design partners to shape it. If perf regressions are a thing your team cares about, let us know and we'll get you set up.

The HTML diff viewer now surfaces React component names (resolved through your source maps), so you can tell what component you're looking at without playing detective.

• 🔀 Session extension (Beta) – adds coverage to your project by intelligently mutating session data from network traffic, feature flags, etc. to hit uncovered paths. Let us know if you'd like us to enable this feature for your project.
• ✅ Describe Tested rolls out to everyone – The PR coverage callout that tells you whether Meticulous actually exercised the code your PR touched is now on for all projects, thank you to everyone who used the beta feature!
• 🪪 Reader role + project-scoped SSO claims – New read-only role and meticulous_role / meticulous_projects SSO token claims so you can give people access to specific projects without handing over the whole org.
• 📋 Copy as prompt – One-click copy of a diff (with screenshot URLs and React component-source metadata) as an LLM-ready prompt - paste into your Claude Code to give it context on what you want to fix.
• 🧰 Broader recorder coverage – Better fidelity for Rive animations, navigator.locks, SubtleCrypto.digest, PressureObserver, ReportingObserver, tRPC batched/streaming requests and batched GraphQL.
• 🗺️ Unminified Stack Traces – Error reports in your application now display exactly where in the application they occurred, not just that they occurred!
• 🤖 Agentic Skills – we're continuing to iterate on our agentic skills library. Let your agent execute Meticulous against its local changes and iterate on the results, e.g. "Upgrade React major version and then use Meticulous to iterate until you remove all unexpected visual differences".

We've built a new dashboard that gives you a bird's-eye view of how Meticulous is performing across your project: track code coverage trends, test run execution time, user engagement and potential bugs that Meticulous has flagged. You can access it from your Meticulous project page.

We've rebuilt the timeline sidebar to make the events leading up to a diff much more intuitive, so you're not scrolling through 47 duplicate rows wondering what went wrong in this test run or your life. This is just the beginning of our planned design work to better surface relevant context around each visual difference, so let us know what is and isn't working for you.

When a test failure has you scratching your head, and even the newly redesigned inspect panel cannot save you, there is now a "Debug with AI" button right in the Meticulous UI. It sets up an AI-assisted debugging workspace, so you can investigate what went wrong without having to piece together CLI commands. Think of it as pair-debugging with someone who already has all the context loaded. If you'd rather give agents direct access to your Meticulous test runs through the CLI, we recommend adding these new skills. We're going deep on agentic workflows - if you have thoughts on what would be most useful, we're all ears.

• 🔗 Combined PR Comments – If you have multiple Meticulous projects in one repo, results now appear in a single PR comment instead of cluttering your PR thread.
• 🧪 Smarter Network Patching – Several improvements to how we match and repair API responses, meaning fewer false diffs caused by stale mocks.
• ⚙️ Self-Serve Network Settings – Request and response size limits (and other settings that used to require contacting us) are now available in your project settings.
• 🧵 Test Runs Threaded by PR – The project test runs page now groups runs by pull request, so older runs collapse under the latest instead of filling your screen.
• 💨 Session Acceleration – We're actively working on making Meticulous test runs faster.