Big Brother

The coding assistant which only speaks when you misstep

Inspiration

AI coding tools are excellent at fixing the bug sitting in front of you, but we've all shipped something that looked perfectly fine at the time and only fell over months later in production. Thus, we wanted an assistant built for that second kind of bug: one that stays silent by default and speaks only when it catches you making a mistake.

What it does

Big Brother is a passive coding assistant. It watches what you write, and every time you save, it reads the code and asks one question: is anything here quietly wrong? It has no opinions on your style, your naming, or your missing tests. It speaks up only for dormant bugs, and only when it can point at the line, explain what goes wrong, and give you a concrete example. Every decision it makes is logged along with its reasoning, including the decisions to stay quiet. The whole log can be replayed on a timeline to see exactly why it held its tongue or spoke.

In our demo, a developer writes an interest module for a banking ledger across six saves. Big Brother says nothing through the first three. On the fourth, it flags that one function rounds interest every day while another rounds once at the end, even though the module's own documentation says the two must agree, and it works the example out for you: $100 at 1.5% rounds to $0.00 every single day. Every test passes at that moment. The test that finally caught this bug in real life was written after the customers complained.

How we built it

The watching itself is done by a VS Code extension, which records editor events: edits, saves, test runs, file switches; and strips secrets before anything leaves the machine. From there, a set of cheap local rules decides which moments are even worth judging, such as a save or a repeated error; no model calls happen at this stage, which keeps the common case free. The moments that survive go to the judge, where Google Gemini (gemini-3.6-flash) receives the code that was just saved and returns a structured decision: speak or stay quiet, why, and what to say.

Watching the watcher is our replay tool, which runs recorded sessions back through the entire pipeline and scores the decisions against hand-labelled "should have spoken here" moments, letting us tune the prompt against data rather than by feel. The timeline then renders every decision into a single self-contained HTML page.

Challenges we ran into

The hard part of this project was never what to say, but rather when. Our first prompt interrupted three minutes into a session when the right moment was about eleven minutes in, and rather than arguing about it, we revised the prompt three times against the replay tool and watched false positives fall from 100% to 0% on our test session.

Being strict is the whole point, since each false alarm teaches a developer to ignore the assistant a little more. The prompt had to be willing to stay quiet on code that merely looks unusual: a documented 365-day-year convention, for instance, is not a bug. Latency is the one thing we can't yet talk our way out of: Gemini takes roughly ten seconds per decision at the 95th percentile, which is fine on a save, but far too slow for anything closer to real time.

Accomplishments that we're proud of

It caught a real, subtle bug at the moment it was written, with a correct worked example, while every test in the project was green. The entire system can be audited after the fact, because nothing it decides goes unrecorded, not even the silence. And we tuned it against measured results instead of guesswork, so we can show you exactly how each version of the prompt moved the numbers.

What we learned

Deciding when to speak is a separate problem from deciding what to say, and it is at least as important.

What's next for Big Brother

We want to put Big Brother in front of real codebases and real development, and teach it from the "bad timing" and "bad content" feedback we already collect but don't yet use. Beyond that, we'd like to grow it past Python, VS Code and pytest, have it reason across files rather than only the one you just saved, and cut that ten-second delay with smaller models or by sending only what actually changed.