The bar for adopting an open-source app used to be “meets 90% of my needs.” Anything below that and you’d either live with the gaps or fork it and maintain your own patched build forever, which nobody actually does — rebasing against an upstream that keeps moving is a chore you signed up for once and quit on twice.

That bar has changed. With Claude Code sitting next to me, the actual bar is now “the core mechanic is sound.” Everything else (features that are missing, features that are in the way, UI I don’t like, defaults I disagree with) I can reshape in a session. This isn’t hypothetical. I did it twice this week, in opposite directions, on two menu bar apps.

The pattern is the point. Case 1 is additive: I found a battery app I liked, hunted down the useful ideas scattered across its abandoned upstream and a couple of active forks, then had Claude Code stitch them together and add a few features nobody had built yet. Case 2 is subtractive: I found a network monitor with the right numbers buried under a hundred features I’d never use, and stripped it down to the ones I actually wanted. Both took an afternoon. Both are now installed on my Mac. Neither is on the App Store, neither is shared with anyone, and that’s fine — they’re for me.

Case 1: Rescuing Stasis From Fork Purgatory

My M1 MacBook Pro is five years old. Great machine still, but the battery has been through enough cycles that I’d like to actually pay attention to it. Something in the menu bar that tells me not just the percentage (which macOS already shows) but the health, the wattage in and out, whether the charging circuit is doing something weird, and ideally a live gauge in the Dock icon.

AlDente is the well-known Mac battery app. It’s paid. I’m sure it’s great; I’m not paying a subscription to look at a battery. No thanks.

Poked around GitHub. Found Stasis — a small SwiftUI app with a beautiful power-flow visualization: an animated diagram showing energy moving between the wall, the battery, and the SoC depending on state. The original repo (srimanachanta/Stasis) has been quiet for a long time. But the fork ecosystem was alive: dvbthien’s fork had shipped fixes (XPC leak, combined metrics call, restart-on-close), and DinanathDash’s fork had a few UI tweaks. None of them was the app I wanted, but the combination was.

So I forked from srimanachanta, added the other two as extra remotes, and started integrating. Merged in Dinanath’s UI branch, cherry-picked dvbthien’s leak fix and metrics rework. Stripped the fork release machinery I didn’t need — Sparkle updater, GitHub CI, Homebrew Cask formula, appcast — and repointed code-signing to my local development team so it just built and ran on my Mac. That gave me a clean, buildable base that combined the best of three separate forks.

Then the fun part. I noticed Mac 4 Breakfast had ideas none of the Stasis forks had. Rather than just copying, I opened Claude Code in my repo and had it design and build around a few things I actually wanted: a glow-ring app icon with a live battery gauge painted onto the Dock icon (so I don’t even need to look at the menu bar), battery health history with projection (showing where the health line is trending), auto-calibration with proper stall detection when macOS blocks the calibration charge, a sticky force-discharge daemon mode for when I want to run down the battery deliberately, a Keep Awake toggle, a small plug-in celebration animation because why not, and energy usage insights that break down what’s actually drawing power.

Two and a half hours of active work on the first day, plus a couple of short debugging sessions over the following two days as edge cases showed up in real use (the daemon SMC writes were reverting on some transitions, calibration would stall silently on certain charger types, one of the daemon protocol handshakes needed self-heal logic when the app relaunched). Fifteen commits total. Now I have a battery menu bar app with Stasis’s original power-flow visual, dvbthien’s plumbing fixes, Dinanath’s UI polish, Mac 4 Breakfast’s insight ideas, and half a dozen features that didn’t exist in any of them. It’s not the original Stasis. It’s not any of the forks. It’s mine, and I’m the only user.

Case 2: Stripping Netfluss Into Tachyon

Second act. Battery was solved, but I still had Stats (the popular open-source system-stats app) running in the menu bar for CPU, memory, network, disks, GPU. Stats is genuinely excellent. Once battery moved to its own dedicated app though, I noticed that of everything Stats gave me, I actually used exactly four things: current network up/down, per-process network breakdown, UniFi WAN bandwidth pulled from my router, and the occasional speed test. Everything else was noise.

Found NetFluss — a mature open-source Mac network monitor with an excellent per-process live sampler and a solid UniFi integration. Also, unfortunately, an object lesson in what happens when a project keeps saying yes. NetFluss 2.4 ships with: a built-in VPN client speaking OpenVPN / WireGuard / IKEv2 / IPsec / L2TP, a DNS switcher, a Wi-Fi manager that scans nearby SSIDs and stores credentials in the system Keychain, historical bandwidth statistics with charts, native integrations for FritzBox, OpenWRT, and OPNsense routers, and a privileged helper daemon underneath most of it. All of it is well-built. None of it is what I wanted. Vibe coding gone the other direction — a developer who didn’t know when to stop, or maybe just enjoyed the building more than the using.

So I cloned the repo, created a lite branch, renamed the whole thing to Tachyon with a fresh com.local.tachyon bundle identity and local-only builds, and started deleting. Out went the VPN client and every protocol backend, the DNS switcher, the Wi-Fi manager, the historical Statistics screen with its charts and database, the FritzBox / OpenWRT / OPNsense router integrations, the entire privileged helper stack (once VPN and Wi-Fi were gone, nothing else needed root), the GitHub update checker, and the promotional context-menu items advertising the developer’s other projects.

What I kept: the menu bar rate display (up/down bytes per second), adapter and IP info, the Top Apps per-process breakdown (the actual reason I picked NetFluss over lighter alternatives), UniFi WAN bandwidth — which I also rewrote to use the Integration API key instead of username/password auth, because API keys are what UniFi actually wants you to use now — and the bundled speed test.

Claude Code did most of the mechanical work: trace this feature, find every file it touches, delete it, unwire it from the app coordinator, remove the settings tab, remove the localization strings, drop the assets. The kind of grinding refactor across an unfamiliar codebase that would have eaten a weekend, done in an afternoon. Twelve commits, all on July 15.

The final binary is a fraction of the original size. It launches instantly. It has a small settings screen with only the toggles that still matter. And it does exactly the four things I wanted, in the shape I wanted them.

What This Actually Changes

The interesting part isn’t either of the apps. It’s the shape of the relationship with open source.

Before: I’d install an OSS app, decide whether it fit, and either commit to using it as-shipped or move on. Small tweaks upstream were viable; anything shaped like “make the app substantially different for me” carried enormous friction — fork, learn the codebase, refactor, maintain, rebase, forever. So I either used what was shipped or I didn’t use it.

Now: the license and the source are the whole point of the transaction. What “open source” practically delivered, most of the time, was permission to look at the code. What it can now deliver is permission plus the practical ability to reshape it. Which is what the licenses always claimed but rarely felt like in day-to-day use.

Two consequences that matter.

The bar for adopting an app drops. Something that’s 60% right and structurally sound is now a better starting point than something that’s 90% right and calcified. I’d rather integrate three forks and graft on a few features than argue with a maintainer about whether feature X belongs upstream.

And the definition of “my app” gets weirder. My Stasis is a merge of three different forks with features from a fourth app grafted on. My Tachyon is NetFluss with two-thirds of its surface area removed and a new name. Both credit the originals faithfully, but describing either as “the app I use” would confuse someone who installed the actual upstream. They’re personal builds. The concept exists now and it didn’t before.

What’s next: nothing. Both apps run. Whichever OSS app I install next, though, I’ll be looking at it differently — asking “what’s the core here, and what would I change” instead of “does this fit as-is.” That’s the shift.

Tech stack: Swift, SwiftUI, IOKit, SMC, Network Kernel Extensions, Xcode, Claude Code Build time: Stasis ~1 day (main build + small follow-ups on days 2 & 3), Tachyon ~1 day Credits: srimanachanta’s Stasis (original), dvbthien’s Stasis fork and DinanathDash’s Stasis fork (both actively maintained), Mac 4 Breakfast for feature inspiration, and rana-gmbh’s NetFluss — a serious project that I’ve disagreed with about scope, not about quality