How do I debug a bug I can't reproduce?

Fix from the captured data instead of a live reproduction: use the symbolicated stack trace (which often reveals the cause directly) and the device and breadcrumb context (which gives the conditions), and group occurrences to find the shared trigger that single reports hide. Since you can't reproduce it locally, verify the fix in the field by watching whether the issue stops occurring on the fixed version. You diagnose from the evidence across everyone who hit the bug, rather than from a reproduction you can't achieve.

Can I really fix a bug without reproducing it?

Often yes. When a bug is captured with a symbolicated stack trace and context, the cause is frequently clear enough to fix without triggering it locally, common for device-specific or intermittent bugs you can't recreate. Grouping many occurrences reveals the shared conditions, and you verify the fix in the field by watching the issue stop on the fixed version. 'Can't reproduce' doesn't mean 'can't fix' when you have the captured data to diagnose from.

How do I find the cause of an intermittent bug?

Use the aggregated field data. A symbolicated stack trace points at the failing line, and grouping many occurrences exposes what they share, a device, an OS, a trigger action, that single reports hide. That shared pattern usually points straight at the cause, even though the bug is intermittent. Intermittent bugs aren't random; they depend on conditions that vary, so capturing and grouping enough occurrences reveals the condition behind the inconsistency, which you then fix and verify in the field.

Tips for Debugging Hard-to-Reproduce Bugs

Quick answer: When a bug resists reproduction, fix from the captured data: a symbolicated stack trace reveals the cause, device and breadcrumb context gives the conditions, and grouping occurrences exposes the shared trigger. Verify in the field.

Bugs you can't reproduce are the most frustrating, you know they're real but can't make them happen. The trick is to stop trying to reproduce and start debugging from the data. Here are practical tips for debugging hard-to-reproduce bugs.

Fix From the Stack Trace and Context

Many unreproducible bugs are still fixable from what's captured. The tip: use the symbolicated stack trace (which often makes the cause clear, a null dereference at a line) and the device and version context (which tells you the conditions) to fix from the evidence rather than a live repro.

Bugnet captures symbolicated stack traces and context with every crash, so the cause is frequently obvious enough to fix directly. 'Can't reproduce' doesn't mean 'can't fix', when the captured data reveals the cause, you can act on it without ever triggering the bug.

Find the Pattern Across Occurrences

A single unreproducible bug is hard, but many grouped occurrences often reveal the pattern, all on one GPU, all after a certain action, all at high memory, that single reports hide. The tip: group occurrences and look for what they share, which frequently points straight at the cause.

Bugnet groups occurrences and surfaces their shared context, so an unreproducible bug becomes tractable once you see what every instance has in common. Aggregated field data does what manual reproduction can't, it shows you the common trigger across everyone who hit it.

Verify the Fix in the Field

Since you couldn't reproduce the bug, you can't confirm the fix locally either. The tip: verify in the field, watch whether the issue stops occurring in reports from the fixed version onward. If occurrences drop to zero on the fixed build, your fix worked, even though you never triggered it.

Bugnet tracks issues per version, so you can confirm an unreproducible bug's fix by watching it stop in the field. So debug hard-to-reproduce bugs by fixing from the stack trace and context, finding the pattern across occurrences, and verifying in the field, no local repro required.

When a bug resists reproduction, fix from the captured data, the stack trace reveals the cause, context gives the conditions, and grouped occurrences expose the shared trigger. Verify in the field; no live repro needed.