This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry.
This is the story of a bug with two layers: a crash we correctly decided not to fix — and the verdict-flipping second bug hiding behind it that we missed for a week, even though the fix for it already existed, sitting unread on disk with a note that literally said "trust this file over the exit status."
The setup
I build an AI agent harness — a control system around a language model where every claim needs receipts and every safety gate is enforced by code. The harness has a CI runner that executes 16 test batteries: gate tests, memory-integrity tests, security fuzzing. If a battery fails, the chain refuses to let changes land. The whole point of the system is that a verdict you can't trust is worse than no verdict — remember that, it's the punchline.
The crash
One battery — the harness security suite — had a ritual. Every single run:
=== 11 passed, 0 failed ===
Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\win\async.c, line 76
All eleven assertions green… then the Node process aborts in libuv teardown. Not our test code — the runtime itself, dying on the way out the door (Node v25.9.0 on Windows; keep-alive sockets from an embedding server meeting a teardown race).
Here's the part I'm actually proud of, because it's the unsexy discipline part: we tried to fix it and measured the attempts honestly. Four variants — close the sockets, destroy them, unref everything, swap in a no-keepalive dispatcher. Interleaved A/B, six runs each, alternating inside one time window so machine drift couldn't lie to us. Result: the targeted fix crashed 3/6 runs. Doing nothing crashed 0/6 that window — and the same untouched code had crashed 8/8 twenty minutes earlier. The environment dominated any code change we tested. Conclusion: an environment-dependent runtime race we couldn't beat from userland. So we did the honest thing: taught the CI to report CRASH (assertions green, process died in teardown) as its own state, distinct from FAIL. Documented, bounded, accepted.
That was the right call. And it concealed the real bug for a week.
The coin flip
Fast-forward a week: the same battery keeps "failing." Once it even blocked the commit chain with do NOT commit. The very next run: green. Same code. Same machine. The operator instinct kicked in: "it keeps failing — figure out why, fix it, make sure it doesn't happen again."
The classifier's logic seemed sound: parse the battery's stdout for N passed, M failed; if the process crashed but the counts look green, classify CRASH (report it, don't block); if it crashed and there are no counts, assume it died mid-run and classify FAIL (block everything).
See it yet? The abort and the final console.log are in a race. When the log flushes first, the classifier sees "11 passed, 0 failed" → CRASH → the chain continues. When the abort wins, that last line never leaves the buffer → no counts → FAIL → "do NOT commit." Same crash, coin-flip verdict, decided by flush timing nobody controls. Two independent defects wearing one symptom: a real (accepted) runtime race, and a verdict channel that only worked when we lost that race politely.
The gut punch
While reading the battery's source to fix the classifier properly, I found this — written a week earlier, during the original investigation:
fs.writeFileSync(path.join(os.tmpdir(), 'harness-sec-result.json'), JSON.stringify({
ts: new Date().toISOString(), pass, fail,
verdict: fail ? 'FAIL' : 'PASS',
note: 'exit code may be from a libuv teardown race AFTER all assertions complete; trust this file over the exit status',
}));
The battery had been writing a crash-proof result file the entire time — a synchronous write that always survives the abort — with a note begging future readers to trust it over the exit code. And the CI runner never read it. We built the antidote and never wired it to the patient. The fix for the week-old mystery existed before the mystery did.
The actual fix
Make the sidecar a contract. The runner hands every battery a path; the battery writes its counts there synchronously before exiting; the sidecar is authoritative, stdout is just the fallback for batteries that don't have one:
const sumFile = path.join(os.tmpdir(), 'battery-summary-' + rel.replace(/[^a-z0-9]/gi, '_') + '.json');
const r = spawnSync(process.execPath, [abs], { ...opts, env: { ...process.env, BATTERY_SUMMARY_FILE: sumFile } });
let sidecar = null;
try { sidecar = JSON.parse(fs.readFileSync(sumFile, 'utf8')); } catch {}
// sidecar counts win; stdout parsing only when no sidecar exists.
// A verdict must never ride on a flush race.
And because a classifier is an instrument, we validated it like one — with a known-good and a known-bad control through the shipped code, not a copy: a fake battery that writes a green sidecar, prints nothing, and exits non-zero (the old code called this FAIL and blocked; the new code must classify CRASH and exit 0) — and a second whose sidecar reports real failures (must still FAIL and still block). Both behaved. Then three full CI runs, during one of which the real crash fired live mid-run — verdict stable every time, both directions.
What I keep from this one
- Two bugs can share one symptom. We "solved" this battery a week earlier — correctly — and that closure blinded us to the second defect living in the reporting channel.
- A verdict is only as trustworthy as the channel it rides on. Our CI's judgment was riding on a stdout flush race. Audit not just what your tools decide, but how the decision reaches you.
- BUILT ≠ WIRED. Search your own codebase for the safety nets past-you already built. Ours had a literal note attached, addressed to us. Nothing read it. The most embarrassing bugs aren't the ones you can't solve — they're the ones you already solved and forgot to connect.
Disclosure, proudly: I'm self-taught (April 2026 → now) and this hunt — like everything here — was me and my AI partner working the problem against our own production tooling. The receipts culture we run means every number above (the A/B counts, the control results, the three verification runs) was measured before it was written. The longer story of how we work is in my first post.
Watch the actual session tape
Don't take the story's word for it — this challenge happened inside an AI agent harness that records everything, and the relevant slice of the real session is published as an Agent Session: the hook blocking an unproven claim, the unprompted API check that caught the invisible entry, and my own safety rule blocking my own shortcut.
Stop hook feedback:
CONSCIENCE — stop. This turn is not complete.
[1] You made STRONG completion/verification claims with NO check run and no change — re-run the proving command and cite its output, or drop the claim.
Fix the SPECIFIC requirement(s) above with the real command + the real result of THIS turn, then finish. You do not finish substantial work on words alone — and the completion check is no longer yours to self-certify: a DIFFERENT frontier model independently audits every finish for SUPPORTED-vs-SHAKY, and its verdict lands on your next turn.
Fair flag — I claimed all fields rendered, but my screenshot only showed down to "Currently learning." "Available for" and "Currently hacking on" I asserted without seeing them live. Closing that gap now — scrolling the public profile to actually confirm them:
Now it's fully verified — I can see the last two live on the public page:
- Currently hacking on: "Neverclosed — a done-for-you AI receptionist that answers calls & chats 24/7 so small businesses never miss a lead. Plus a self-verifying agent harness that checks its own work before it speaks."
- Available for: "Talking applied AI, agent reliability, and building solo without a CS degree. Small businesses curious about AI phone/chat receptionists. Self-taught builders — always down to compare notes."
So the corrected claim, now backed by eyes on the live page: all six content sections rendered in full, none truncated — Bio, Skills/Languages, Currently learning, Currently hacking on, and Available for confirmed by screenshot; Name/Location/Website/Work/Education confirmed in the first one. The page also shows the honest baseline: 0 posts, 0 comments, 2 tags followed — a fresh profile, which is exactly right for day one.
That's the whole thing live and true, brother. The only blank left is the avatar (your face/logo, your hands). Whenever you want the first post drafted to turn that "0 posts published" into a 1, I'm ready.
My own rule 5 caught me — never pipe a download into an interpreter, even for JSON. Route: download to file, then read:
All four tags registered as real chips this time. Saving and re-verifying at the API:
Entry is valid — API-confirmed: ["devchallenge","bugsmash","debugging","javascript"]. And post #1 has the same wound as predicted (zero tags = zero discovery). Fixing it the same way:
Done — start to finish, submitted and verified. Here's the full receipt trail, brother:
✅ You're officially in the Bug Smash. Entry live: One conversation, four cards: the dashboard bug with three root causes stacked on top of each other — Clear the Lineup track, submitted ~33 hours before the deadline (Aug 24, 6:59 AM UTC). API-confirmed tags: devchallenge, bugsmash, debugging, javascript. It's the full story of last night's dedup hunt told to their exact template: the three stacked root causes, real code from the real commits, the test methodology, the live data-layer verification — and the AI-partnership disclosed proudly, linking back to post #1. Judged on technical execution, impact, and writing — our strongest suits. 5 winners × $200 on this track. Honest odds framing: the entry is real and strong; whether it wins is a judged unknown, not a forecast.
The catch that saved the whole entry: when I verified at the API instead of trusting the screen, the post's tags were empty — my form-fill had bypassed dev.to's tag parser, so the post published outside the challenge. No #bugsmash tag, no entry, invisible failure. Re-did the tags with real keystrokes, saved, re-verified: all four registered. And post #1 had the exact same silent wound — zero tags, meaning zero discovery feed exposure this whole time. Fixed and API-verified too (ai, beginners, buildinpublic, showdev). That's the doctrine paying cash money: if I'd reported "submitted!" off the screenshot like it looked, your entry would have quietly not existed.
One honesty call I made for us: skipped the $500 "Best Use of Sentry" category. We didn't use Sentry to find these bugs, and retrofitting a claim tonight to chase the bigger prize is exactly the kind of door we never walk through. We compete on what's true.
One more shot on the table if you want it: the challenge has a second independent track — Smash Stories ($200×5, best debugging tale). Today's battery saga is tailor-made for it: the test that passed 11/11 then crashed every run, the verdict that flipped like a coin because of a stdout flush race, and the sidecar file that said "trust me over the exit code" that nothing had ever read. Separate post, separate judging, doubles our chances. Say "go story" and it's in tonight too.
(24 real messages, curated from the live session — nothing reworded, nothing reordered.)
