What a Version 2 Actually Takes: 206 Commits of Honest States
GeekBye v2 was not a feature release. It was 206 commits aimed at a single idea: the app should never lie about its own state. Here is what that costs — including the one-line lockfile mistake that nearly stopped us from shipping any of it.
Most "version 2" releases are a pile of new features with a bigger number on them. GeekBye v2 was the opposite. It shipped almost no new user-facing capability. Its 206 commits were aimed at a single, unglamorous idea:
The app should never show you a state that isn't true.
That sounds obvious until you count how many ways a desktop app quietly lies. It shows a checkmark on an upload that's still in flight. It says "connected" over a socket that died a minute ago. It stays silent while your transcript is being dropped on the floor. None of these are crashes. They're worse than crashes, because the app looks fine while being wrong — and you only find out later, when the recording you needed isn't there.
v2 was the release where we went hunting for every one of those small lies.
The lie we hated most: the upload that "worked"
GeekBye can back your recordings up to Google Drive. In v1, the connection to Drive was treated as a background detail — if it worked, great; if it didn't, the failure was mostly invisible. The app would go on looking connected. You'd assume your recordings were safe. Sometimes they weren't.
v2 rebuilt this around honest connection states. Drive is now always in one of a few explicit, truthful states — connected, reconnecting, disconnected — and the app broadcasts every change of that state to the whole interface the instant it happens. When the connection is down, a global reconnect banner tells you, everywhere, plainly. The app no longer pretends an upload succeeded when it didn't. If your backup can't happen right now, you know right now — not next week when you go looking for the file.
Underneath, this is a small architecture, not a slogan: one source of truth for the connection, an event that fans out to every part of the UI when it changes, and a banner that reads directly from that state. There is no path where the connection is down and the UI looks up, because they read from the same fact.
The lie of the lost recording
The second big honesty fix was recording recovery. Real-time transcription needs a live connection. In v1, if that connection hiccupped mid-session — a Wi-Fi blip, a tunnel, a VPN reconnect — the audio during the gap could simply be gone. The transcript would have a hole in it, and nothing told you.
v2 changed the contract: audio is preserved locally during a connection gap and reconciled afterward. When the link drops, GeekBye keeps the audio safe on your machine; when it comes back, that buffered audio is sent and stitched into the transcript in the right place. A bad thirty seconds of network no longer costs you thirty seconds of meeting. This is the groundwork the later reliability releases built directly on — the reconnect-and-buffer machinery in why your AI notetaker stops on bad Wi-Fi is the same idea, hardened.
The lie of the popup storm
There's a subtler dishonesty in how apps report trouble: they over-report it. One flaky network moment can fire the same error five times, and suddenly you have a stack of identical red toasts burying the one message that matters. That's not honest either — it's noise pretending to be information.
So v2 added category-keyed toast throttling and error routing. Errors are grouped by what they actually are, and each category is rate-limited so a single underlying problem produces one clear message, not a barrage. A rate-limit issue routes to a rate-limit message; a connection issue routes to a connection message. The app tells you what's true, once — the same discipline that later kept a 429 from masquerading as a logout in the day our app DDoSed itself.
The 206 number is the point
Honest states, reconnect banner, recording recovery, toast routing — that's four ideas. The release was 206 commits. Where did the rest go?
Into the unglamorous long tail that "never show a false state" actually requires. Every place the old UI could get out of sync with reality had to be found and rewired to read from the truth instead of a stale copy. Every reconnect path had to be made to update the shared state instead of guessing locally. Dozens of small reliability fixes across recording, transcription, and uploads — each one closing a specific gap where the app could look right while being wrong.
This is what a real "version 2" costs when the goal is trust instead of features. There's no single headline commit. There are 206 small ones, and the release only feels like one thing — calm — because all 206 pull in the same direction.
The release almost didn't ship
Here's the war story, and it's a good one, because it's about our own app lying to us.
When you cut a release, a version-bump script stamps the new number across the project. On v2.0.0 it updated the app's version — but the package-lock.json, npm's exact dependency ledger, was left pointing at the old version, 1.9.0. Locally, everything was fine; nobody reinstalls dependencies just to build. But CI runs npm ci, and npm ci's entire job is to refuse to proceed if the lockfile disagrees with the manifest. It's a strictness feature — and it did exactly what it should, by failing the build for the biggest release we'd ever cut.
Then a second, sneakier one surfaced underneath it. A newer npm had pruned an optional transitive dependency — the encoding package that node-fetch pulls in — out of the lockfile as unnecessary. Except our CI's clean install did need it, so the install broke in a way that had nothing to do with our code and everything to do with the ledger being subtly wrong.
Both were one-line fixes: resync the lockfile to the real version, restore the pruned entry. Both are also perfect, humbling examples of the exact thing v2 was about — a state that claimed to be true and wasn't. The lockfile is supposed to be the honest record of what the app depends on. When it drifted from reality, the build did precisely what our app now does for users: it refused to pretend everything was fine. Shipping a reliability release turns out to be a reliability problem all the way down.
Three things v2 taught us
- The dangerous failures are the silent ones. A crash announces itself. A false "connected," a phantom successful upload, a transcript with an invisible hole — those cost you trust precisely because nothing looks wrong. Hunt the quiet lies.
- Honesty is an architecture, not a message. You can't bolt "tell the truth" onto a UI as a banner. The banner has to read from the same single source of truth as everything else, or it becomes one more thing that can be wrong. One fact, fanned out — never two copies that can disagree.
- A version 2 worth the number is mostly invisible. If your v2 is a feature list, it's a v1.5 with marketing. A real v2 is 206 commits nobody can point to individually, adding up to a product that simply stops lying to you.
GeekBye v2.0.0 is the foundation every release since has built on. For what that foundation carries, see why your AI notetaker stops on bad Wi-Fi, the day our app DDoSed itself (v2.0.1), and live transcription when the firewall blocks WebSockets (v2.0.8). For the calm it was all in service of, what's new in GeekBye v2.
