# Why AI Didn't Actually Make You Ship Faster — Gabriel Spencer-Harper, Meticulous

Gabriel Spencer-Harper, Meticulous

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/HLTa7Vcs4X0-why-ai-didnt-actually-make-you-ship) · [Video](https://www.youtube.com/watch?v=HLTa7Vcs4X0)

## Why AI Didn't Actually Make You Ship Faster

Gabriel Spencer-Harper explains how Meticulous moves frontend verification from handwritten assertions to recorded workflows and visual comparisons—and why network mocking, browser determinism and coverage-guided selection have to work together.

![Selected presentation frame from Why AI Didn't Actually Make You Ship Faster — Gabriel Spencer-Harper, Meticulous at 61 seconds](https://ai.engineer/api/talk-essay-media/dd3143c28d87d8a27d2692334f95bcd661236084789c6088acc28ba0c9d40502)

Slide reads “Engineering the future of AI” beside the speaker on the Expo Stage.

### Writing code faster leaves the merge decision behind

[0:12](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=12s)

An agent finishes a pull request. Would you feel comfortable merging and shipping it? That is the practical question behind Gabriel Spencer-Harper’s talk. The co-founder and CEO of Meticulous starts with a mismatch: AI can produce code faster than people can establish that the change is safe. Someone still has to verify it, so faster code generation can move the bottleneck rather than remove it.

A frontend change can behave differently under different feature flags, roles, permissions, settings and configurations. Reviewing the patch does not automatically reveal its effect across those combinations. The work before merge includes reaching the relevant application states, observing what changed and deciding whether those changes are acceptable.

Assertion-based tests encode expected behavior in advance. A human or agent chooses what should happen and writes checks for it. Spencer-Harper’s objection is the size of the remaining space: even diligent test authors cannot anticipate every possible regression. A passing assertion answers the question someone thought to ask; the merge decision often depends on effects they did not anticipate.

![Selected presentation frame from Why AI Didn't Actually Make You Ship Faster — Gabriel Spencer-Harper, Meticulous at 153 seconds](https://ai.engineer/api/talk-essay-media/8e8dd9d21da7edfb2bd657e7e41eae60515c8314ecb55a473be411c7bd4fb7cc)

The slide “ASSERTION-BASED TESTS ARE NOT ENOUGH” shows a Claude Code-authored pull-request summary and a green “Merge & Ship” button.

The costs show up in several places:

- **Regressions:** shipping faster can expose users to bugs with business consequences.
- **Verification work:** manual validation, review, flaky-test debugging and suite maintenance consume engineering time. Spencer-Harper describes this as double-digit percentages of an organization’s time.
- **Changes deferred:** dependency upgrades and sweeping refactors become easier to attempt when engineers can inspect their consequences with confidence.

Meticulous is presented as a way to obtain exhaustive or near-exhaustive frontend verification without developers maintaining the tests. That ambition needs a precise reading: the mechanisms described here compare recorded frontend behavior and select flows by executed lines of code. They do not establish that every possible state has been recorded or that every kind of correctness is visible in a screenshot.

### Replay the same workflow before and after the change

[4:04](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=244s)

The demo begins with one line of JavaScript injected into non-production environments: localhost, QA, development or staging. It instruments the browser and records workflows as people use the application. Clicking a login button, opening settings and visiting analytics becomes a sequence of events that the system can replay. The recorded collection can contain thousands or tens of thousands of flows.

When a pull request opens, the CI runner starts the application on localhost port 3000. Meticulous selects recorded workflows and dispatches their events one by one. Throughout each replay, it captures screenshots at what Spencer-Harper calls each atomic moment. Running the workflow before and after the code change produces two screenshot sequences; comparing corresponding states reveals the application’s visible differences before merge.

![Selected presentation frame from Why AI Didn't Actually Make You Ship Faster — Gabriel Spencer-Harper, Meticulous at 306 seconds](https://ai.engineer/api/talk-essay-media/d98bae7078acaa830334b917c9d266e14014a8d57280e50efd6a7648dcc4615f)

A GitHub pull request displays code changes with added and removed lines.

The concrete example contains two changes: a name has changed, and an error has been introduced into a dropdown. The comparison exposes the name change in both light and dark modes, along with a visible manifestation of the dropdown’s logical error. The causal path is straightforward: replay reaches the relevant state, the changed code renders it differently, and the before/after comparison puts that difference in front of the reviewer.

A pull-request comment leads to the differences, typically within a few minutes in the workflow described. Meticulous does not label each difference a bug. A reviewer decides whether the name change is intended and whether the dropdown’s changed behavior is acceptable. Business judgment moves from writing an assertion before the change to interpreting an observed difference afterward; Spencer-Harper also allows for an agent to perform that review.

Where does the reviewer enter the process? The diagram separates event replay and comparison from the decision about correctness. Both versions receive the recorded workflow, but the resulting diff still needs someone to interpret it. In the demo, that distinction lets an expected name change and an unexpected dropdown change appear through the same mechanism.

One workflow, two versions, one review decision
Replaying the same events produces comparable screenshot sequences. The diff identifies visible changes; review determines whether they are intended.
- Recorded workflow — Browser events captured in a non-production environment.
- Before the change — Replay events and capture a screenshot sequence.
- After the change — Replay events and capture the corresponding sequence.
- Visual differences — Name changes in light and dark modes; a visible dropdown error.
- Review — A person or agent decides which changes are expected.
- Recorded workflow → Before the change (Dispatch recorded events)
- Recorded workflow → After the change (Dispatch recorded events)
- Before the change → Visual differences (Baseline screenshots)
- After the change → Visual differences (Changed screenshots)
- Visual differences → Review (Interpret before and after)

### Control the network and the browser’s timing

[7:10](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=430s)

Comparing screenshots only helps if repeated runs of unchanged code produce comparable images. Meticulous addresses two sources of variation at different layers:

- **Recorded network traffic:** at record time, it captures network requests and responses. At replay time, it stubs them in, giving the workflow recorded responses rather than relying on changing live network results.
- **Browser scheduling:** it augments the browser from the scheduling-engine layer upward to control randomness that network mocking alone cannot remove.

![Selected presentation frame from Why AI Didn't Actually Make You Ship Faster — Gabriel Spencer-Harper, Meticulous at 459 seconds](https://ai.engineer/api/talk-essay-media/9d288000b3ea15bbd04a1b48cfd83fa4a2bce3bccefa5913bad5651e1c599720)

Slide titled “KEY TECHNOLOGIES” lists exhaustive coverage, deterministic testing and automatic mocking.

Network mocking has two jobs in the design. First, it makes replay repeatable: Spencer-Harper describes running a test a thousand times and obtaining the same result. Second, each test is isolated from the others. Workflows need not compete through shared network state, so the system can run them horizontally in parallel and return results within a few minutes. The same decision that supports repeatability also supports speed.

The browser itself can still introduce differences. An animation spinner may render at different positions depending on the machine’s speed. Different interleavings of `setTimeout` and `setInterval` can alter what happens before a screenshot. If those differences survive replay, unchanged code can look changed, producing flaky results and wasting review attention.

Meticulous therefore aims for a deterministic or near-deterministic browser, controlling this variation below the test script. Spencer-Harper claims radically fewer flakes than Cypress or Playwright; the recording supplies the scheduling rationale rather than a quantified comparison. The useful architectural point is that visual comparison depends on controlling when the browser does work, as well as what data it receives.

### Choose workflows by the code they exercise

[8:40](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=520s)

A large recording library creates another problem: which workflows should run on each pull request? Meticulous replays each recorded session once against the main or master branch and monitors the lines of code it executes. That produces an index from workflows to executed lines. It then selects a subset of workflows that maximizes code coverage across the application.

This gives selection a concrete target. Instead of treating every recording as equally valuable, the system uses its execution history to choose flows that collectively reach code throughout the application. Feature flags, roles, permissions and configurations matter because they can lead execution through different branches. The index connects observed journeys to the implementation they actually exercised.

Why use code coverage when executing a line does not prove it behaved correctly? Spencer-Harper gives a sharp counterexample: a Cypress or Playwright test could execute 100% of a codebase while making only one assertion. Most of that execution would go unchecked. His phrase is the distinction to remember: “code covered is not the same as code tested.”

Meticulous tries to narrow that gap by comparing screenshots throughout the flow. The stated example is a 412-step workflow in which a single-pixel difference would be flagged. Executed code is therefore accompanied by much denser observation of its visible consequences than a single end-of-test assertion. That is the basis for Spencer-Harper’s claim that coverage and testing become approximately equivalent in this system: the approximation depends on the behavior producing an observable visual difference.

### Dense observation makes determinism essential

[10:09](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=609s)

The technical ending ties the design together. Coverage-guided selection supplies breadth across the recorded workflows. Screenshots throughout those workflows supply dense observation. But that density brings an enormous volume of comparisons: Spencer-Harper describes screenshot counts on the order of tens or hundreds of millions. Without controlling flakiness, the additional observation could drown the reviewer in noise.

What makes more observation useful rather than overwhelming? The stack below shows the dependency. Controlled replay makes differences more meaningful; frequent screenshots let selected flows expose changes along the way; coverage-guided selection determines which recorded paths contribute breadth. Removing browser variability is consequently part of the verification mechanism, not merely a convenience for running tests.

The merge decision still ends with judgment. In the demonstrated pull request, the name change and dropdown error both arrive as visual differences. The system’s contribution is to reach those states repeatedly and make the consequences inspectable before shipping. That is how the proposed verification layer supports the ambition from the opening: making larger changes, including dependency upgrades and refactors, without expanding manual exploration at the same pace as code generation.

The dependencies behind broad visual verification
Frequent screenshots make coverage-guided replay informative, but only if repeatable execution keeps incidental differences from overwhelming the result.
- Controlled replay — Recorded network responses isolate tests; browser scheduling controls timing variation.
- Screenshots throughout each flow — Observe visible changes along the workflow without drowning in incidental variation.
- Coverage-guided workflow selection — Choose recorded flows using their executed-line index.
- Controlled replay → Screenshots throughout each flow (Reduce flaky visual differences)
- Screenshots throughout each flow → Coverage-guided workflow selection (Make executed paths visually checked)

## Key takeaways

- Faster code generation can leave verification as the limiting step: the team still needs to understand a change across roles, permissions, flags and configurations.
- Meticulous compares recorded workflows before and after a change. It exposes visible differences; a person or agent decides whether they are expected.
- Recorded network responses make replay repeatable and isolate tests for parallel execution. Browser-level timing control addresses variation that network mocking cannot remove.
- Coverage-guided selection depends on frequent screenshots to turn executed paths into visually checked paths. At large screenshot volumes, controlling flakiness is essential to keeping the differences useful.

## Slides

### Meticulous

Gabe introduces Meticulous and argues that code verification can become the bottleneck as agents write code faster.

[0:49](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=49s) [Meticulous wordmark on a peach-to-purple gradient.](https://assets.ai.engineer/sites/aiecode2025/sha256/c614229e2a708d741b70e139a18301ac355041410ca8a8a574e3feea6f08202c.webp)

Meticulous

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Audience · Deck for Gabe - June 2026 - Figma Slides
figma.com/deck/[illegible]/Deck-for-Gabe----June-2026?node-id=1-58
Wed Jul 1 10:46

### Exhaustive verification with zero developer effort

Meticulous presents frontend verification as a way to ship at the speed agents write code. Spencer-Harper says verification otherwise becomes a bottleneck; the slide lists customers including Dropbox and Notion.

[1:12](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=72s) [Meticulous claims exhaustive verification with zero developer effort, above a collection of customer logos.](https://assets.ai.engineer/sites/aiecode2025/sha256/52010863a5e289ed725c1e5cacc1da7949eb5086ec3e24fb24dfcf2302ae8ba1.webp)

EXHAUSTIVE VERIFICATION WITH
ZERO DEVELOPER EFFORT.

Ship code at the speed your agents write it. Powering frontend testing at the world’s best technology companies:

Engine
Dropbox
Notion
LaunchDarkly
Wealthsimple
ElevenLabs
motion
BuildOps
tana
CANARY TECHNOLOGIES
BILT
outtake
cortex

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Audience - Deck for Gabe - June 2026 - Figma Slides
figma.com/deck/[illegible]/Deck-for-Gabe----June-2026?node-id=1-58

### Assertion-based tests are not enough

A Claude Code pull request standardizes a modal across 254 screens. The speaker asks whether you would merge it before checking configurations, permissions, and edge cases for regressions.

[2:27](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=147s) [Slide stating that assertion-based tests are not enough, illustrated by an AI-authored pull request and a merge button.](https://assets.ai.engineer/sites/aiecode2025/sha256/545f90d912d31409c525f99e00ec43b5c96b32dba1ed5db07d23c5167eca0139.webp)

ASSERTION-BASED TESTS ARE NOT ENOUGH

Standardize to use shared modal component, across all 254 screens
#54102
+2,320 −8,412

Authored by Claude Code
Merge & Ship

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Audience - Deck for Gabe - June 2026 - Figma Slides
figma.com/deck/[illegible]/Deck-for-Gabe[illegible]June-2026?node-id=1-58
Wed Jul 1 10:48

### The Problem

Spencer-Harper argues that bugs and test maintenance cost teams time. He says exhaustive verification would let developers make sweeping changes with confidence.

[3:13](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=193s) [Problem slide with cards describing the cost of bugs and the time required to maintain end-to-end tests.](https://assets.ai.engineer/sites/aiecode2025/sha256/5f1a6a5101cdc2917f608c9eb785ba0eeb8091ccb9dadae30d91d6fe1e6a8d12.webp)

THE PROBLEM

01 Bugs
Bugs are expensive, both in customer impact and in dev time to root-cause.

02 Time
Exhaustive E2E coverage is infeasible for the FE using current solutions: it requires 1000s of tests, which are a nightmare to maintain and eat developer time

Interface text:
Chrome File Edit View History Bookmarks Profiles Tab Window Help
Audience - Deck for Gabe - June 2026 - Figma Slides
figma.com/deck/[illegible]/Deck-for-Gabe----June-2026?node-id=1-58

[3:37](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=217s) [Slide describing bugs, test maintenance time, and development pace as consequences of inadequate front-end testing.](https://assets.ai.engineer/sites/aiecode2025/sha256/e972c90c0fb0f7626a96bac5a6915577d17dd8cbdfb5632622a10ccb6dc43e9f.webp)

THE PROBLEM

01 Bugs
Bugs are expensive, both in customer impact and in dev time to root-cause.

02 Time
Exhaustive E2E coverage is infeasible for the FE using current solutions: it requires 1000s of tests, which are a nightmare to maintain and eat developer time

03 Pace
Most FE dev teams move at a fraction of the pace they could be: with truly exhaustive end-to-end test coverage you can ship & iterate at lightning speed.

Interface text:
Chrome File Edit View History Bookmarks Profiles Tab Window Help
Audience - Deck for Gabe - June 2026 - Figma Slides
figma.com/deck/[illegible]/Deck-for-Gabe----June-2026?node-id=1-58

### How It Works

Gabriel introduces a Meticulous demo: JavaScript injected into non-production environments records browser workflows for testing.

[4:04](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=244s) [Slide introducing a different approach to front-end testing.](https://assets.ai.engineer/sites/aiecode2025/sha256/2a3850a33434fa783e93b3c96afd981894f28972b4ccf27ac2501dd909d1ba4d.webp)

HOW IT WORKS

A RADICALLY DIFFERENT APPROACH TO FRONT-END TESTING

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Audience - Deck for Gabe - June 2026 - Figma Slides
figma.com/deck/[illegible]/Deck-for-Gabe----June-2026?node-id=1-58
Wed Jul 1 10:49

### Demo: Pull Request Changes

The pull request renames “Create new record” to “Create new company” and makes it a primary action. Spencer-Harper says a second change introduces an error in a dropdown.

[4:35](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=275s) [Pull request showing a button renamed and made a primary action, with another code change partly visible below.](https://assets.ai.engineer/sites/aiecode2025/sha256/21816a237169b47d627fa6e37cf229106c1208f58e88ae7756d6ca04b7d2adbe.webp)

Demo 1: UI Change + Error #22
Open
adrikoz wants to merge 2 commits into main from ui-change+error

DefaultRecordActionsConfig.tsx
@@ -104,9 +104,10 @@ export const DEFAULT_RECORD_ACTIONS_CONFIG: Record<
  type: ActionType.Standard,
  scope: ActionScope.Object,
  key: NoSelectionRecordActionKeys.CREATE_NEW_RECORD,
- label: msg`Create new record`,
- shortLabel: msg`New record`,
+ label: `Create new company`,
+ shortLabel: `New company`,
  position: 2,
+ isPrimaryCTA: true,
  isPinned: true,
  Icon: IconPlus,
  shouldBeRegistered: ({ objectPermissions, hasAnySoftDeleteFilterOnView }) =>

SettingsRolesDefaultRole.tsx
@@ -85,9 +85,10 @@ export const SettingsRoleDefaultRole = ({
  dropdownId="default-role-select"
  options={options}
  value={defaultRole?.id ?? ''}
- onChange={(value) =>
-   updateDefaultRole(value as string, currentWorkspace)
- }
+ onChange={(value) => {

Interface text:
github.com/alwaysmeticulous/twenty-demo/pull/22/changes
Authenticate your account
Able to merge
Code
Preview
Conversation 1
Commits 2
Checks 3
Files changed 2
+7 -5
All commits
0 / 2 viewed
Submit review
Filter files...
packages/twenty-front/src/modu...
action-menu/actions/record-ac...
settings/roles/components
Viewed

### Demo: Button Change and Error

The PR renames the create-record action to Create new company, promotes it to a primary CTA, and adds an unconditional error before the default-role update runs.

[5:43](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=343s) [Code diff showing a button-label change and an added error in a role-selection handler.](https://assets.ai.engineer/sites/aiecode2025/sha256/1397a3b5c8f5df5e75969c6c768c3dcdda4ebafae923a2034c1bdeb51c03f62b.webp)

DefaultRecordActionsConfig.tsx
@@ -104,9 +104,10 @@ export const DEFAULT_RECORD_ACTIONS_CONFIG: Record<
    type: ActionType.Standard,
    scope: ActionScope.Object,
    key: NoSelectionRecordActionKeys.CREATE_NEW_RECORD,
-   label: msg`Create new record`,
-   shortLabel: msg`New record`,
+   label: 'Create new company',
+   shortLabel: 'New company',
    position: 2,
+   isPrimaryCTA: true,
    isPinned: true,
    Icon: IconPlus,
    shouldBeRegistered: ({ objectPermissions, hasAnySoftDeleteFilterOnView }) =>

SettingsRolesDefaultRole.tsx
@@ -85,9 +85,10 @@ export const SettingsRoleDefaultRole = ({
    dropdownId="default-role-select"
    options={options}
    value={defaultRole?.id ?? ''}
-   onChange={(value) =>
-     updateDefaultRole(value as string, currentWorkspace)
-   }
+   onChange={(value) => {
+     throw new Error('Failed to update default role: permission denied');
+     updateDefaultRole(value as string, currentWorkspace);
+   }}
  />
</SettingsOptionCardContentSelect>
</Card>

Interface text:
github.com/alwaysmeticulous/twenty-demo/pull/22/changes
Conversation 1 · Commits 2 · Checks 3 · Files changed 2
+7 -5
All commits · 0 / 2 viewed · Submit review
Filter files…
packages/twenty-front/src/modu...
action-menu/actions/record-ac...
settings/roles/components
Viewed

### Demo: Pull Request Test Results

Meticulous posts a pull-request comment linking to its test results. The review groups console errors and visual differences; developers decide whether the changes are expected rather than receiving a bug verdict.

[5:56](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=356s) [Pull request conversation with an automated comment reporting visual differences and test coverage.](https://assets.ai.engineer/sites/aiecode2025/sha256/8fa907f1165fd6eb56c60b3f781ec0d9f36c39dc3649da4bdcaca8730217e887.webp)

Demo 1: UI Change + Error #22
Open
adrikoz wants to merge 2 commits into main from ui-change+error
Conversation 1 | Commits 2 | Checks 3 | Files changed 2
+7 -5

adrikoz commented on Mar 11 · edited
Summary
• Renamed the “Create new record” button to “Create new company” and promoted it to primary CTA
• Added error handling in the default role change dropdown to throw when permission is denied

Changes
• DefaultRecordActionsConfig.tsx: Changed label/shortLabel from generic “record” to “company”, added isPrimaryCTA: true
• SettingsRolesDefaultRole.tsx: Added throw new Error in the onChange handler for the default role select

Mention @copilot in a comment to make changes to this pull request.
Rename create record button to New company and make it primary CTA

alwaysmeticulous Bot commented on Mar 11 · edited
Meticulous spotted visual differences in 27 of 692 screens tested: view and approve differences detected.
Meticulous evaluated ~6 hours of user flows which tested 100% of the executable lines edited in your PR.
Last updated for commit 68c6124 Add default role change error. This comment will update as new commits are pushed.

Interface text:
github.com/alwaysmeticulous/twenty-demo/pull/22
Meticulous - meticulous/Twenty Demo - Test Run - ...
app.meticulous.ai
Memory usage: 152 MB
Reviewers
Copilot | Request
Still in progress? Convert to draft
Assignees
No one—assign yourself
Labels
None yet
Projects
None yet
Milestone
No milestone
Development
Successfully merging this pull request may close these issues.
None yet
Notifications | Customize
Subscribe
You’re not receiving notifications from this thread.
1 participant
adrikoz force-pushed the ui-change+error branch from [illegible] to [illegible] 4 months ago
Compare
Lock conversation

[6:04](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=364s) [Meticulous results overview showing tested screens, detected differences, and approval status.](https://assets.ai.engineer/sites/aiecode2025/sha256/30a90fb4af3bd6b42fe41615cb8c421d86469e3311579bb47f239e7ca3ed18d0.webp)

All code changes were tested | View coverage

Results overview
Screens tested 781
User flows tested 79
Differences detected 26

Approval status
Unreviewed 26
Approved 0
Rejected 0
Ignored 0

NEW CONSOLE ERRORS 2
Change 1 2

UNIQUE VISUAL DIFFERENCES 24
Change 2 12
Sample 3 | All 12
Change 3 11
Sample 3 | All 11
Change 4 1

Approve all visual differences

Note: It looks like you have some flakes. To resolve mark CSS selectors to ignore, book a call with us, or read the guide in the docs.

Interface text:
app.meticulous.ai/projects/meticulous/Twenty%20Demo/test-runs/[illegible]?source=github
meticulous / Twenty Demo / #22 Demo 1: UI Change + Error 68c6124
Docs
Differences | New | Passed
Filter
Group by: Similar

### Reviewing a visual difference

Meticulous displays a workflow screen alongside before-and-after controls. The reviewer uses the diff to decide whether a change is expected; the tool does not itself determine whether it is a bug.

[6:17](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=377s) [A visual-difference review displays a workflow screen beside before-and-after controls.](https://assets.ai.engineer/sites/aiecode2025/sha256/63174b8aab05d2855ff0fa3a1f5aa4a8e9477d31960e4f0a1437018ac911e910.webp)

NEW CONSOLE ERRORS  2
Change 1  2

UNIQUE VISUAL DIFFERENCES  24
Change 2  12
Sample 3  All 12
DIFFERENCE
BEFORE  AFTER
Change 3  11
Sample 3  All 11
Change 4  1
Approve all visual differences

Workflow screen:
YCombinator
Workflows
All Workflows
Name  Statuses  Last update  Created by  Versions  Runs
Untitled  1 day ago  Tim Apple  v1
Quick Lead  Draft  Deactivated  12 days ago  System  v1  v2
Add New
Calculate
See runs  + New record
Filter  Sort  Options

Search
Ask AI
Settings
Favorites
Mac Pro Video Production... 
Set up onboarding proces...
Anthony Green
Prepare meeting agenda...
Workspace
People
Companies
Opportunities
Tasks
Notes
Survey results
Workflows
Dashboards

/objects/workflows?viewId=[illegible]

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Wed Jul 1 10:51
Deck for Gabe - June 2026
Presenter - Deck for Gabe
Demo 1: UI Change + Error
Meticulous - meticulous/Twenty Demo
app.meticulous.ai/projects/meticulous/Twenty%20Demo/test-runs/[illegible]?source=github
meticulous / Twenty Demo / #22 Demo 1: UI Change + Error  68c6124
Docs
Differences  New  Passed
Filter
Group by: Similar
Work
New Chrome available

### Reviewing a detected error

The demo opens a Roles settings difference flagged with new errors. Meticulous shows what changed; the reviewer or an agent uses judgment to decide whether the change is expected.

[6:32](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=392s) [A roles settings screen appears in the review panel with a new-errors indicator.](https://assets.ai.engineer/sites/aiecode2025/sha256/d15d6e9158469fad25a9151f0243410af3f42ee902761e1d3983ae0a8db1b4d5.webp)

New errors

Roles
All roles
Assign roles to specify access permissions
Search a role...
Name | Assigned to
Admin | 1
Member | 3
+ Create Role

Options
Adjust the role-related settings
Default Role
Set a default role for this workspace
Member
Search
Admin
Member

/settings/roles

Interface text:
meticulous / Twenty Demo / #22 Demo 1: UI Change + Error
Docs
Differences | New | Passed
Filter
Group by: Similar
NEW CONSOLE ERRORS 2
Change 1 2
DIFFERENCE
BEFORE | AFTER
UNIQUE VISUAL DIFFERENCES 24
Change 2 12
Sample 3 | All 12
Change 3 11
Sample 3 | All 11
Change 4 1
Approve all visual differences

Exit Settings
Workspace / Roles
User
Profile
Experience
Accounts
Emails
Calendars
Workspace
General
Data model
Members
Roles
Domains
APIs & Webhooks
Applications
AI
Other
Admin Panel
Updates
Documentation
Logout
Advanced

Chrome
File Edit View History Bookmarks Profiles Tab Window Help
Deck for Gabe - June 2026
Presenter - Deck for Gabe
Demo 1: UI Change + Error
Meticulous
app.meticulous.ai/projects/meticulous/Twenty%20Demo/test-runs/[illegible]?source=github
Work
New Chrome available

### Key technologies

Meticulous replays recorded network responses, reduces flakes through a more deterministic browser, and selects recorded workflows to maximize code coverage.

[7:11](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=431s) [Slide naming exhaustive coverage, deterministic testing, and automatic mocking.](https://assets.ai.engineer/sites/aiecode2025/sha256/6f8151c8a9385da97ac8440ee05617170920fe5d31aca167419b95eaf666f671.webp)

KEY TECHNOLOGIES

Exhaustive coverage

Deterministic Testing
Eliminates flakes with ground-up browser architecture

Automatic Mocking
Mocks backend requests to prevent side effects

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Audience - Deck for Gabe - June 2026 - Figma Slides
figma.com/deck/[illegible]

### What customers say

Customers at Notion, LaunchDarkly, Engine and Dropbox describe Meticulous as a development guardrail and credit it with improving quality and reducing behavioural issues and flakes.

[10:40](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=640s) [Four attributed customer testimonials about Meticulous.](https://assets.ai.engineer/sites/aiecode2025/sha256/e395f9e80be7779bfbe9e7b11d3248ee56779942499acc5b9d43e0b3ac508819.webp)

WHAT CUSTOMERS SAY

Notion
Meticulous is unlike anything else, developers love it and it is now an essential guardrail of our software development process.
Erdem, Head of DevEx

LaunchDarkly
Meticulous helps us simultaneously move fast and raise the quality bar. If we didn't have Meticulous, it would be so much more difficult to get to that place.
Zach, Principal Engineer

Engine
Meticulous empowered us to ship tighter and reduce behavioural issues right away.
Colin, Principal Engineer

Dropbox
Engineers loved it instantly - no more debugging after merge, zero maintenance, and no flakes. Once we started using Meticulous, we couldn't imagine working without it.
Tony, Engineering Manager

Interface text:
Chrome  File  Edit  View  History  Bookmarks  Profiles  Tab  Window  Help
Audience · Deck for Gabe - June 2026 - Figma Slides
figma.com/deck/[illegible]/Deck-for-Gabe----June-2026?node-id=1-58

## Full transcript

[0:12](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=12s) Hello, everyone. Hi. Um, my name is Gabe. I'm one of the co-founders and CEO of Meticulous. Um, I'll just wait one more minute for people to come in, and then we can, and then we can get started. Um, so in today's demo or talk, I'll talk about verification of code. Um, I'll spend one minute introducing Meticulous, and then one minute giving some background context on the company, and then sort of eight minutes giving a demo and technical, technical overview.

[0:43](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=43s) Um, so if you have exhaustive verification, then you can ship code at the speed that your agents write it. If you don't, then someone, somewhere at your organization is spending time verifying code, and that is now your new bottleneck, and you're forced into a position where you're trading off velocity against bugs and user experience.

[1:12](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=72s) So I'll give, um, super quick context on Meticulous. So Meticulous gives you exhaustive or near-exhaustive verification of your front-end code base with zero developer effort. Um, it's deployed across the entire engine organization at all of these companies like Discord, Wiz, Dropbox, Notion, ElevenLabs, LaunchDarkly, and many, many other great companies. So if an engineer touches front-end code at one of these companies, they use Meticulous every, every

[1:42](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=102s) day. However, before we get into the product and talk more about verification, um, let's just cover the current, sort of, state of the world. So AI writes code faster than humans can review it, and review and verification is now the new bottleneck.

[2:04](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=124s) The other state of the world is that assertion-based testing alone isn't enough. So no matter how hard a human or an agent tries to define the correct behavior of software, a priori, up-front in assertions, the space of possible regressions is too vast to exhaustively cover.

[2:28](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=148s) And so a good clarifying question is, if an engineer in your organization, uh, AI-generated this pull request, would you feel comfortable hitting the, the merge, merge and ship button? And in most organizations, the answer is no. You would want to go and do the hard work of checking out all the different feature flags, all the different roles, permissions, settings, configurations, and the various different edge cases in order to understand the exhaustive

[2:58](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=178s) impact of this, of this change and see if you can spot any issues.

[3:04](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=184s) So there are three sort of like downstream consequences of that current state. The first one is bugs or regressions, uh, which have a, a business impact. The second one is engine organizations will spend double-digit percentages of their time maintaining end-to-end test suites. So across manual validation, review, uh, debugging flakes or updating or maintaining the test suite, um,

[3:34](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=214s) all spend a lot of time maintaining, maintaining, maintaining tests. And then the third, like, problem or downstream, downstream consequence of, of the state of the world is that, um, if you, if you can get exhaustive verification, then you can program in a new and different way. So all of a sudden, you can bump all of your dependencies, you can do sweeping refactors, you can make any AI-generated change with complete, complete confidence.

[4:04](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=244s) So then the question becomes, um, that sounds great. How do you, how do you get exhaustive verification? What does it look like, and how do you, how do you get there? Um, so I'll now give you a demo of how, how Meticulous, Meticulous works. So we give you-- Uh, give me one second to set this up.

[4:34](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=274s) Great. Um, so we give you one line of JavaScript to inject onto non-production environments, so that's localhost QA dev staging. That JavaScript instruments the web browser and records thousands or tens of thousands of flows or workflows, so someone clicking the login button, clicking the settings panel, clicking the analytics panel. And then when you open a pull request on your CI runner, you spin up your web application on localhost three

[5:03](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=303s) thousand, and Meticulous takes a subset of those recorded workflows, and it replays them. So it dispatches each event one by one. And as it dispatches those events, so click the login button, click the settings panel, click the analytics panel, it takes a screenshot at each atomic moment throughout time. And so it generates a sequence of screenshots for every workflow, one before your code change and one after your code change. It then diffs those two sequences together

[5:33](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=333s) to show you what would be different about your application if you were to merge that code in before, before you do. So in this example, there's two changes here. One is someone's changed the name, and the second is they've introduced an error to a, to a dropdown. And so when you open a pull request, Meticulous posts a comment, typically within a few minutes, and when the developer clicks into this comment, the Wi-Fi is slow, so I'm just gonna switch tabs. But when a

[6:03](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=363s) developer clicks into this comment, Meticulous will not tell you whether or not there's a bug. What it will show you is a set of diffs that show you what's different about that application if you were to merge that code in. And so each diff has a before state and an after state. And so by reviewing the diff, you can determine whether that change is expected or unexpected. So here's the name change on light mode, here's the name change on dark mode, and then this is a

[6:33](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=393s) manifestation of that logical, logical error. So typically, when you write an assertion-based test, you, um, use your business context and judgment to encapsulate the correct behavior of software upfront and, and encapsulate that into your assertion-based test. In Meticulous, we just show you what's different, and you exercise your judgment at review time or, or, or an agent, agent does. Um, give me

[7:03](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=423s) one second to switch this back.

[7:10](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=430s) Cool. Cool. Um, so there are sort of three technologies that are really important for helping build a mental model of the tool and how it works, how it works and why it works. So the first one is that everything is mocked out. So, um, at record time, we record all the network requests and responses, and then at replay time, we stub those in. And we perform that mocking for two reasons. One is to make the test idempotent, so you can run them a

[7:40](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=460s) thousand times in a row and get the same results each and every time. And the second reason is it means that every test is isolated from every other test, which eliminates the risk of race conditions and allows you to parallelize the test horizontally and get, get the results in a, in a few minutes. The second key technology is that you get radically less or orders of magnitude less flakes with Meticulous than any other tool, including Cypress or Playwright. And the reason why is we augment the

[8:10](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=490s) browser from the scheduling engine layer up to be fully deterministic. So when browsers were first designed, determinism was not a design goal, and so there's many different sources of randomness. For instance, an animation spinner depends upon the clock speed of the CPU or the machine rendering the browser, or the interleaving between setTimeout and setInterval. And so we handle all of that randomness and, uh, make the browser deterministic or near deterministic so that you have radically, radically less flakes.

[8:40](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=520s) And then the third technology, which is the most, um, important one for grokking, like, why this works, is if you want this to be exhaustive, it has to cover every feature flag combination, every permission, every role, every config, every possible branching through the application. So how do you, how do you do that? So one technique that we use is that for every session or flow that we record, we replay it once against main branch or master branch, and we monitor what lines of

[9:10](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=550s) code get executed. And then we build a map or an index that maps each individual workflow to lines, lines of code executed and choose a subset of workflows that maximizes code coverage across your application. And typically, uh, give me one second. Typically, I would say that code coverage, in our opinionated view, is a terrible metric for every tool in the world, apart from Meticulous. And the reason why is you could write a Cypress test or Playwright test that covers a hundred percent

[9:40](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=580s) of your code base but only makes a single assertion. And so code covered is not the same as code tested. But with Meticulous, it actually is approximately the same because we do this really unusual and radical thing, which is we're taking a screenshot at every possible moment throughout a flow. So if there's a four hundred and twelve-step flow and there's a single-pixel diff, Meticulous, Meticulous will, will, will flag it. And so you can start to see how all these technologies layer

[10:09](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=609s) together. Um, you only get exhaustive verification because of this code coverage algorithm. That algorithm only really works because you take a screenshot at every possible moment. If you take a screenshot at every possible moment, you're taking on the order of tens, hundreds of millions of screenshots. And so traditionally, you would just drown in noise or drown in flakiness. And so you have to solve flakiness at the root level, um, which is, which is what we, what, what we, what we do by, by augmenting, augmenting the browser.

[10:40](https://www.youtube.com/watch?v=HLTa7Vcs4X0&t=640s) Um, these are some nice things that our customers, customers have said about us. Um, and that concludes today's talk. If you're interested in finding out more, then come to booth LG6, and thank you so much for listening.
