Dmytro Vovk
The best skill for building a Mac app was managing people
I had never built a Mac app. Seven months and 82 releases later, the skill that mattered wasn't Swift: it was running a team, except this team was agents.
I have been writing software since the late nineties, but I had never built a Mac app. No Swift, no idea how a menubar icon gets onto the screen. I had opened Xcode a couple of times to see what it was, but Mac development was never my focus and I never made anything usable. In April I started this app. Seven months on, I use it every day, it has been released 82 times, and I haven’t read a line of its code.
What made it possible was a change of job. I stopped being the engineer who writes the code and became the one who runs the team that does. The team is agents, and the skills that made it work came from the years I spent leading people.
Background
Over the years I have worked on web apps, fintech, networking and data processing, mostly in Go for the last twelve years. By day I am a senior backend engineer at Spamhaus. In the evenings I build things with Claude Code and Codex.
I have also been on the other side of the work. As a team lead I managed up to 35 people across five locations, and later, as head of infrastructure, I ran two teams: sysadmins and Go developers. Either way the job was the process around the engineers: what gets built, how it is specified, how it is reviewed, and when it is done. I didn’t expect that experience to matter for a side project. It turned out to be the part that mattered most.
Those evenings kept ending the same way. Halfway through a long agent run I would hit the rate limit with no warning. Claude knows how much I have left; my menubar didn’t.
So I wanted a small menubar gauge: how much of each window is used, when it resets, and a nudge before I hit the wall. A Mac app was the obvious shape for it, and the one thing I had never built.
This is not vibe coding
“Another person vibe-coded another app” is a fair first reaction, so let me answer it up front. Vibe coding is prompting until something runs and hoping it keeps running. What I did is ordinary software engineering, the process any decent team follows, with agents doing the typing. The one thing a normal team has that this one doesn’t is a human who can read the code; I come back to where that matters further down.
| Vibe coding | How this app was built | |
|---|---|---|
| Before code | A prompt | A written design spec and an implementation plan, both reviewed before any code; 8 commits are fixes to spec and plan reviews |
| Scope | Open-ended | Explicit non-goals in every spec |
| Done means | It runs | Tests pass: 67 test files, written alongside the code they test and reviewed with it |
| Review | Optional | A different model reviews every change; findings are verified, then fixed, not waived or blindly trusted |
| Integration | No CI | CI builds and tests every push to main since May |
| Release | Unsigned build | Versioned and tagged: 82 releases, signed and notarised since October |
| Verification | A quick try | A 554-line checklist of manual tests, which agents work through on a running build |
The agents are fast and capable, but fast and capable without constraints is how you get a pile of code nobody trusts. The constraints come from my experience, and they are what make the speed safe to use.
How it went
I didn’t learn Swift first. I worked the way I already did, one level up: I brought an idea of what I wanted, the agents and I brainstormed it into a design spec and a plan, the agents wrote the Swift, and tests decided what counted as done. My input was the intent, the questions and the decisions. I read the specs; the code I leave to the agents and the reviewers. Every feature since has started the same way; the repo now holds eleven specs and plans.
On 25 April the agents and I brainstormed the first spec in the morning. By early afternoon there were about twenty small commits, each one module with its test, and v0.1.0 was in my menubar. It read the rate limits Claude Code passes to its statusline script.
By the evening I had thrown it away. A second spec replaced the statusline trick with a poller that asks the API directly, and the first version was deleted the same day, along with a migration to remove it from my machine. That was the moment I stopped worrying about not knowing Swift: when the spec is the source of truth, code is cheap to replace.
The agents were not always right, and the mistakes were instructive.
The timeout that never fired. The plan said to wrap a command with a timeout. The first implementation read the pipe in a way that blocks while the pipe is open, so the timeout loop never got a chance to run. The plan itself had prescribed that code, word for word. The review caught it, and the fix landed the same day.
The forecast that crashed. The burndown forecast divided by the slope of usage over time. When usage barely moved, the slope was tiny and the app crashed. The chart and the crash fix landed within twenty minutes of each other.
Losing the token. An early version deleted the stored token before checking that the new one worked, so cancelling the settings dialog left you with no token at all. It now verifies first and writes second.
I didn’t catch any of these by reading code. Review caught the timeout; the forecast bug showed up as a crash at launch, and its fix came with tests for the case. Every change goes through a second reviewer: Claude Opus does the work; for review it hands the change to a different model, Claude Fable or OpenAI’s Codex, and 24 commits are named after review findings. Different models miss different things.
Which reviewer gets the job depends on whose usage limit has more room left. That is why the app grew its own MCP server: before a review or a long task, Opus asks CC Usage Stats how much of each model’s limit is left and plans around it. The tool now feeds the team that builds it.
The problem with macOS
Swift was never the hard part. The hard parts were the platform’s rules, which no test of mine could see because they depend on how the app is signed and what the machine has been doing.
The Keychain prompt on every build. The app keeps its OAuth token in the Keychain. On ad-hoc and self-signed builds, macOS ties access to the exact build hash, so every commit produced an app the Keychain no longer trusted, and macOS asked for access again. Little Snitch flagged every build as modified for the same reason. A stable self-signed dev certificate in May didn’t fix it. A Developer ID certificate did, in October: it carries a Team ID, and the Keychain trusts the team instead of the hash.
Gatekeeper. A downloaded app needs a Developer ID signature, the hardened runtime and Apple’s notarisation, or macOS warns people away from it. Releases have been signed and notarised since 16 October, almost six months after v0.1.0.
Sleep. A laptop that sleeps through a rate-limit reset wakes up showing stale numbers. That bug arrived two days in and came back in a new form as late as November.
When a test run signed me out
This is the part most developers ask about. They’ve read the stories: an agent wiped a disk, an agent dropped a production database. “I’m too scared to let agents near anything real.” I understand the fear because I’ve been on the wrong end of it, in a small way, and it was my mistake, not the agent’s. What I learned from it is why I now design the guard before I hand over the access.
On 31 July my own menubar told me I was signed out. The culprit was one run of the test suite. The test target was hosted by the app itself, so the suite was launching real copies of it on my machine. One test exercised the Keychain by deleting the stored token before and after each case, and it did that to the real Keychain. The same runs rewrote my real usage history, and on a fresh machine they would have rewritten Claude Code’s settings file too.
Nothing went rogue. The test did exactly what it said, and the agent did exactly what the test asked. The gap was in the setup I had built: nothing separated “the app under test” from “the app I use every day”. That was on me. Most of the horror stories I’ve read have the same shape: someone handed an agent real access and put nothing between it and the damage.
So I handled it the way I’d handle an incident on a team: no blame, a process fix, and proof that the fix holds. It landed the same day:
- The app knows it is under test. Everything that touches user state checks first, and the check is part of the code now, not something to remember. The token goes to a scratch Keychain entry, files go to a scratch folder, and the settings migration doesn’t run.
- Proof that it holds. I had the agents plant sentinel values in the Keychain entry, the history file and the settings file, then run the whole suite. All three came out byte-identical, with no new files anywhere.
The damage was one sign-in and a rewritten history file. What I took from it: safety doesn’t come from trusting the agent, it comes from the setup around it. It’s what we already do for a new hire: no production keys on day one, every change through tests and review, a small blast radius by design, and every incident leaves a guard behind.
Each mistake like this one became a guard, and the guards add up. Today agents can only edit the files a task declares, reviewers run read-only, and a change isn’t done until it is deployed and checked on the live machine. On my own projects, agents do deploy to production servers. The one thing they don’t do alone is a production change that needs a maintenance window: that stops and waits for me. Occasionally the setup pushes back on its own: more than once an agent has stopped a deploy because it judged the change would break production. I count that as a bonus, not a control.
Agents do make mistakes, at the same speed they do everything else. My confidence comes from having made my own mistakes with them, learning what a guard looks like, and building the setup that decides how far a mistake can get.
How is it going now?
Seven months on, the app is at v0.22.5: 278 commits and about 23,000 lines of Swift.
Most of it came in two bursts: 55 of the 278 commits landed in April and 162 in October and November. Between them came eleven quiet weeks, from mid-May to late July, when the app simply did its job, and a steadier trickle through August and September.
The first spec ruled out alerts, charts and anything beyond Claude. Most of that arrived anyway, each through a deliberate new spec rather than drift: a burndown chart that forecasts when you will hit the cap, alerts with their own sounds, Codex and Gemini limits beside Claude’s, a list of running agent sessions, and the MCP server.
From engineer to engineering manager
I don’t read the Swift, and I couldn’t tell you whether a given function is idiomatic. Two years ago that would have stopped me. Now it doesn’t, because I am no longer the individual contributor on this project. I am the manager of a team, and the team is agents.
There is a limit to this, and I’d rather name it. The app does handle credentials. Its Claude sign-in is kept in the user’s own Keychain; for Codex it reuses the sign-in the Codex CLI already has, and for Gemini it asks Google’s own CLI. They are used only to query the providers’ own servers, the code that touches them went through adversarial review by independent agents, and the source is public for anyone to check. For software that moves money or keeps personal data on a server, I would want a human who reads the language in the loop.
A manager doesn’t review every line their team writes. They make sure the work is well specified, that there is a shared definition of done, that nobody approves their own work, and that problems turn into process fixes rather than blame. I learned that leading people. It transferred to agents almost one for one.
| What I did as a team lead | What it became with agents |
|---|---|
| Write a clear brief before anyone starts | A design spec for every feature, including what we won’t build |
| Agree on a definition of done | Tests that gate every change, not the agent’s confidence |
| No one approves their own work | Fable or Codex reviews what Opus writes |
| Judge outcomes, don’t micromanage | I check the running app, not the source |
| Change course early when the plan is wrong | The first version was replaced on day one |
| Turn every incident into a process fix | The test run that deleted my token became a check on every run |
One thing doesn’t transfer, and it changes how I work. With people, throwing work away has a cost beyond the hours. I have seen people leave after a project they had worked hard on was judged the wrong direction and shut down. Not everyone is comfortable watching months of their code thrown away, whatever the reason, and a good lead weighs that before calling it.
Agents don’t carry that weight, so experiments become cheap: build something, see if it works, and throw it away if it doesn’t.
The skills that didn’t help were the ones I’d have expected to need: Swift, AppKit, Xcode. The skills that did were the ones nobody lists on a developer’s CV: briefing, setting the bar, building review into the process, and trusting a team you have set up well.
That is the level-up. Not a new language, but a new role, built on experience I already had and tools I didn’t have two years ago.
Meet CC Usage Stats
CC Usage Stats is a free, open-source macOS menubar app that shows how much of your Claude, Codex and Gemini rate limits you have left, forecasts when you will hit the cap, and warns you before you do. Its read-only MCP server lets your agents ask the same question before they start something long.

It is MIT-licensed. Download it from ccusagestats.app, or read the code, specs and all, at github.com/dmytro-vovk/cc-usage-stats.