← Blog

AI debugging when the agent can't see — how a screen recording became a shipped fix

2026-07-08

Our email verification was broken in production. Not hypothetically — a user clicking "Verify email" in the message we'd just sent them landed on a browser error page: This site can't be reached.

We found it the way you usually find these things: by being the user. And instead of writing a bug report, we recorded two minutes of screen, handed the recording to an AI agent, and shipped the fix.

This post walks through that loop with the actual artifacts — including the exact one the agent read. It's the clearest demonstration we have of what AI debugging looks like when you stop typing descriptions of what you saw and start handing the agent the evidence itself.

The bug: a dead domain hiding in an email

The verification link in our signup email pointed at email.thinkbrowse.io — our old domain, left over from a rebrand. DNS for that host no longer resolved, so every "Verify email" click died with a resolution error.

This is a nasty class of bug, and it's worth naming why: it doesn't live in code. No unit test exercises the rendered URL in a production email template against live DNS. Code review saw nothing wrong — the template was "working" when it was written; the world changed around it. The only place this bug exists is on the screen of a real user, in a real inbox, clicking a real link.

Which is exactly the place your coding agent can't go.

The evidence problem

Coding agents can increasingly drive a browser live — OpenAI ships a Codex Chrome extension and computer use; Anthropic ships Claude in Chrome for Claude Code. Live control is real, and it's useful. But it doesn't solve this bug, because this bug already happened — to a user, in their inbox, in the past. Live control means trying to catch the bug live: the problem has to be reproducible on demand, in front of the agent, right now. Most real bugs aren't:

  • The moment is gone. The failing click happened in an email client during signup. There's no URL an agent can navigate to that replays it.
  • Describe it in prose instead? "The verify email link is broken" gives the agent almost nothing: which link, pointing where, failing how, at what step?
  • Paste a screenshot? Better — but one image loses the sequence. The visual context gets lost: the agent sees the error page but not the email it came from, the address it resolved, or what happened before and after.
  • Write a proper bug report? Steps-to-reproduce, environment, expected/actual. This works. It's also twenty minutes of unpaid technical writing every time something breaks — and people are out there searching codex screenshot and codex screen recording precisely because they'd rather hand over the evidence than write the essay.

And when the agent works without evidence, you get the loop every agent user knows by heart: "I fixed it." "No you didn't." Five rounds of an agent guessing at pixels it can't see.

The thing an agent needs for a bug that already happened isn't a live browser. It's the evidence — captured once, structured, and readable by whatever agent you use.

Recording instead of reporting

So we recorded it. Two minutes with ThinkRun running: open the email, click "Verify email", watch it fail, narrate what we expected. Here's the actual recording:

ThinkRun turned that into a share artifact — one link that renders as a readable page for humans and as structured JSON or Markdown for agents. For this recording, the artifact contained:

  • A timeline of key moments — email opened at 0:03, link clicked at 0:09, DNS error on screen at 0:13
  • 12 screenshots, each with a text description an agent can read without vision
  • The narration transcript — including "the verification email has a bug in it," which is the user's intent in the user's words
  • Direct observations — e.g. "the verification link points to email.thinkbrowse.io, which results in DNS resolution failure when clicked"
  • Suggested changes — the analysis already proposing where to look: verify the DNS records and the domain the verification flow depends on

That last bullet matters. The artifact isn't a video file an agent has to somehow watch; the analysis has already turned the pixels into claims with timestamps and evidence behind them.

Don't take our word for the contents — the link above is the live artifact, exactly as the agent received it.

What Codex did with it

We gave the artifact to OpenAI Codex with a one-line prompt — essentially: review this product feedback and determine the issue.

Codex read the Markdown, correlated the observations (verification email → link → email.thinkbrowse.io → DNS failure), identified the root cause as a dead-domain reference in the verification flow rather than a code-logic error, and proposed the fix direction. No back-and-forth reconstructing what happened. The evidence answered the questions an agent would otherwise have to ask you one message at a time.

The human's job shrank to what it should be: confirming the diagnosis and deciding what ships.

The fix, shipped

The fix landed the same week. As of publication, the full loop — register, receive the email, click verify, account activated — is confirmed working in production. We re-ran it end to end rather than trusting the merge.

(Honesty beat: yes, the dead domain was our own rebrand leftover. That's rather the point — the bugs that survive code review are the ones that live in config, DNS, and third-party state. They're found by using the product, and they're communicated best by showing, not telling.)

One recording, one artifact, one agent session, one shipped fix. The bug report was never written, because the recording was the bug report.

FAQ

How do I give Codex a screenshot or visual context? For live sessions, OpenAI now ships a Codex Chrome extension and computer use. For anything that already happened — a bug a user hit, a flow you recorded — the reliable pattern is structured evidence: screenshots with text descriptions, a timeline, and a transcript. A ThinkRun share artifact packages all of that behind one URL with agent-readable JSON and Markdown formats, so you can paste a single link into any Codex session, including the plain CLI.

Codex and Claude Code can control a browser now — why record at all? Live control is synchronous and vendor-bound: the agent must reproduce the problem itself, in its own session, and each vendor's extension only serves its own agent. A recording captures what actually happened — once — and the artifact works across Codex, Claude Code, Cursor, and human reviewers alike. Live control and captured evidence are complements, not substitutes.

Can an AI fix a bug from an image or a screen recording? Yes — if the visual evidence is translated into something the model can read. A raw video is opaque to a coding agent; a structured artifact (timestamped observations, screenshot descriptions, transcript, suggested changes) is directly actionable. That translation step is what ThinkRun automates.

What should a bug report for an AI agent contain? Evidence, not prose: a timeline of what happened, screenshots (with text descriptions), the user's narration or intent, direct observations tied to timestamps, and any console/network context available. Structured beats narrative — an agent can quote and correlate structured fields.

Does this work with Claude Code too? Yes. The artifact is agent-agnostic — the same JSON/Markdown link works in Claude Code, Codex, Cursor, or any agent that can fetch a URL. A Codex-vs-Claude-Code comparison on the same recording is coming next.

Try it on your own bug: thinkrun.ai — record it, share the artifact, hand it to your agent.