The most annoying part of debugging a bug you can't reproduce
Someone files an issue. "The form breaks when I submit." You ask for details. They send a screenshot of an error toast — no stack trace, no network tab, no nothing. You spin up the app, poke around for ten minutes, can't reproduce it, and then spend another ten trying to explain what information you actually need.
That loop is exhausting. /watch breaks it.
What /watch actually does
/watch is a browser monitoring tool built into lac-cli. When you run it, it opens a local web interface and starts capturing everything that happens in your browser session — clicks, form inputs, page navigation, XHR and fetch requests (including headers and bodies), and JavaScript errors.
It's not a screen recorder. It captures structured event data. Every event gets a timestamp, a type, and the relevant payload. By the end of a session you have a real timeline — not a vague description of what happened, but an exact ordered log of what the browser did.
And there's a floating "Send to AI" button. One click ships that entire timeline to lac agent.
Running it
If you've already got lac-cli installed (pip install lac-cli or the install script), you just run:
lac /watch
It opens the local interface in your browser. From there you do whatever you were going to do — navigate to your app, reproduce the bug, fill out the form, hit the endpoint. While you're doing that, /watch is quietly recording the event stream in the background.
When you're done, hit "Send to AI." That's it. The full session timeline goes straight to lac agent as context.
What gets captured
Here's the breakdown of what /watch tracks:
- Clicks — element, coordinates, timestamp
- Inputs — field identifier and value as you type
- Navigation — every URL change including pushState and replaceState
- XHR and fetch — method, URL, request headers, request body, response status, response body
- JavaScript errors — message, stack trace, file, line number
The network capture is the part I find most useful. You don't need to have your DevTools open, you don't need to remember to filter by XHR, and you don't need to manually copy a request out of the network tab. /watch gets it all automatically, headers and body included.
A real use case: chasing a 422 that only happens in production
I had a form that was throwing a 422 on a specific user flow. Worked fine in my local testing, failed for certain users on prod. Classic.
I asked one of the users to run lac /watch, walk through the flow, and hit "Send to AI." The session timeline that came back showed exactly what was different — the request body had a field formatted differently depending on which browser autocomplete filled in a value. The AI spotted it instantly from the captured payload and pointed me at the exact field.
Without /watch, that would have been a 30-minute back-and-forth asking the user to open DevTools, find the network tab, locate the right request, export it as HAR, send it over... and half the time they'd send the wrong one anyway.
Pairing it with lac agent
Once the session hits lac agent, you've got the full agentic toolkit available. The agent can read your source files, cross-reference the captured request against your API route handlers, check your validation logic, and suggest a fix — all in one shot.
The combination of /watch and lac agent turns a browser bug report into something the AI can actually work with. Instead of "the form breaks," it sees: POST /api/users/update, 422, request body includes dob: "29/02/1995", validation schema expects ISO format. That's a solvable problem.
When voice recognition comes in
/watch also has voice recognition support. This is useful when you're doing a session walkthrough and want to narrate what you're doing in real time — "clicking the submit button now," "this is where it errors" — so the AI gets extra annotation alongside the raw event data. It makes the timeline easier to interpret when there are multiple ambiguous clicks or navigation events close together.
Who this is actually useful for
Obviously it's useful for debugging. But a few other cases I've found myself reaching for it:
- API exploration — point /watch at a third-party app, poke around, and let it capture all the API calls the frontend makes. Instant undocumented API discovery.
- QA sessions — run a test flow with /watch active, send the timeline to the agent, and ask it to flag anything that looks wrong. It'll catch 404s, unexpected redirects, and slow requests without you having to interpret a DevTools session yourself.
- Reproducing user reports — ask the user to record the session themselves and share the timeline. The timeline is structured JSON, not a screen recording, so it's small and easy to share.
Try it today
If you haven't used /watch yet, the easiest way to start is just to run it on a page you're actively working on. Let it capture a normal session, send it to the agent, and ask "anything here that looks wrong?" You might be surprised what it picks up.
Install or update lac-cli first:
pip install --upgrade lac-cli
Then:
lac /watch
Do your thing in the browser, hit "Send to AI," and let lac agent do the reading. That's the whole workflow.