Dmytro Vovk ← Home

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, and closed it without making anything usable. Seven months later I have one I use every day, released 82 times, and I haven’t read a line of its code.

That isn’t because the AI is magic. It’s because the job changed. 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

My work is backend and network infrastructure: Go for most of the last twelve years, C for data planes, and a lot of databases and observability. 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.

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 Whatever the model suggests Explicit non-goals in every spec
Done means It runs on my machine Tests pass: 67 test files, written alongside the code they test
Review None, or a glance A different model reviews every change; findings are verified, then fixed, not waived or blindly trusted
Integration Copy, paste, hope CI builds and tests every push to main since May
Release A zip on a drive Versioned, signed and notarised: 82 tagged releases
Verification “Looks fine” A 554-line manual test checklist, run on the real app

The agents are fast and capable, but fast and capable without constraints is how you get a pile of code nobody trusts. The constraints are the product of my experience. The agents supply the speed.

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, not the documents or the code. 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 on the same day.

I didn’t catch either of these by reading code. Review caught the first; the second showed up as a crash at launch. 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 ended up managing the team that builds it.

When an agent did break something

This is the part most developers ask about first. 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. 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:

  • One source of truth. The app now knows when it is under test, and everything that touches user state asks first. The token goes to a scratch Keychain entry, files go to a scratch folder, and the settings migration doesn’t run.
  • Proof, not a promise. 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.
  • A guard that stays. The check is part of the code now, not something to remember.

The damage was one sign-in and a rewritten history file. The lesson was bigger than the bug: 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. And the constraints cut both ways: more than once an agent has refused to deploy because it judged the change would break production.

I’m not confident because agents don’t make mistakes. They do, at the same speed they do everything else. I’m confident because I’ve made my own mistakes with them, learned what a guard looks like, and built the setup that decides how far a mistake can get.

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.

Losing the token. An early version cleared the old Keychain entry before checking that the new token worked. It now verifies first and writes second.

How is it going now?

Seven months on, the app is at v0.22.5: 278 commits, 82 tagged releases, about 23,000 lines of Swift and 67 test files. Releases are signed and notarised, so a downloaded copy opens without a warning.

CC Usage Stats milestones in 2026: launch week in April, eleven quiet weeks, then October onward25 April: v0.1.0 in the menubar. 27 April: burndown chart and forecast. 2 May: open source, MIT, CI. 27 July: per-model weekly meter. 7 October: Codex usage tracking. 8 October: MCP server for agents. 16 October: signed and notarised. 16 November: v0.22.5, latest. No commits between mid-May and late July.11 weeks, no commitsMayJunJulAugSepOctNovApr 25v0.1.0 in the menubarApr 27Burndown chart and forecastMay 2Open source, MIT, CIJul 27Per-model weekly meterOct 7Codex usage trackingOct 8MCP server for agentsOct 16Signed and notarisedNov 16v0.22.5, latest
Milestones from the git history, 2026.

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, one spec at a time: a burndown chart that forecasts when you will hit the cap, alerts with their own sounds, Codex limits beside Claude’s, a list of running agent sessions, and an MCP server so the agents themselves can check how much headroom is left before a long task.

From engineer to engineering manager

I don’t read the Swift, and I couldn’t tell you whether a given function is idiomatic. A year 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 of skilled specialists who happen to be agents.

There is a limit to this, and I’d rather name it. It works here because the stakes are a menubar gauge and the source is public for anyone to read. For software that handles other people’s money or data, 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; each finding is verified before it is fixed, not taken on trust
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 first version of this app lasted less than a day, and nobody minded.

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 and Codex 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.

The CC Usage Stats dropdown: running agent sessions at the top, then Claude, Codex and Gemini usage meters with a burndown forecast

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