A macOS Notch for the Era of AI Coding Quotas

AI coding assistants have become standard equipment, but their limits remain stubbornly opaque. Claude Code, Cursor, GitHub Copilot, OpenCode, Grok, Codex, Antigravity, GLM—each carries its own quota windows, reset timers, and tiered restrictions. A developer in a Facebook group recently asked for a desktop widget to pin Claude usage to the taskbar, hoping to avoid the mid-mission surprise of hitting a cap [7]. The frustration is specific: you are deep in a flow state, the agent is churning through a refactor, and then it stops. No warning, just a silent refusal or a cryptic message about usage. Vendor dashboards are web pages you forget to check. CLI usage commands are easy to miss. The need is for ambient, glanceable relief.

Codenotch’s core insight is architectural: it refuses to sign in anywhere. Instead, it reads the authentication artifacts that the coding tools themselves have already scattered across a Mac. Claude Code’s own usage output is queried directly from the installed binary; if that is absent, the app falls back to the OAuth token in the login keychain. Cursor’s signed-in session is lifted from its local SQLite state or the cursor-agent keychain entry. Codex piggybacks on ChatGPT’s local sign-in. Grok reads the auth.json file in its CLI directory. GitHub Copilot reuses the GitHub CLI session already established on the machine. Antigravity is queried through its local language server first, then Google’s quota endpoint, falling back to a plain request count when neither answers. GLM borrows a key from Claude Code’s settings file, ZCode, or OpenCode.

This is not merely convenient; it is a statement about trust boundaries. The app never asks for an API key, never opens a browser for OAuth, and never stores its own credentials. It simply asks the existing tools for their own readings, or reads the files those tools already own. The project documents this provenance in a provider table that reads like a field guide to where each vendor hides its state: internal endpoints, language-server RPCs, local databases, and keychain items.

Because the source of each reading varies in authority, the app declares a fidelity level for every provider—official, derived, or manual—so the UI never presents a guess as a vendor-sanctioned fact. This is a rare moment of epistemic honesty in a utility category that often pretends to certainty. A usage store polls the providers on a timer, keeps the last good reading across launches, and degrades every failure to a visible status rather than a fabricated percentage.

The design also accommodates developers who keep multiple identities. Anyone who isolates a work Claude Code account by pointing the tool at a separate config directory gets a second ring labeled Claude (work) beside the personal one, with its own limits and sessions. The app discovers any alternate config directory at launch and orders them alphabetically after the default, so the rings never swap places. Switching a provider off in Settings stops its credential from being read at all and forgets prior readings; it does not sign you out of the tool that owns the account, and the UI says so explicitly.

The app’s name and form factor are deliberate. Codenotch pins itself to any of the four screen edges. Right and left keep a vertical column; top and bottom lay the readings side by side. It anchors to the usable edge, so a bottom notch rests on the Dock and follows when the Dock hides or moves. On a Mac with a hardware notch, top placement takes its exact shape, so the software and hardware read as a single object rather than a bar parked underneath.

The layout engine works in one-dimensional stack space—along and across—regardless of which edge it occupies, with a placement module mapping that abstraction back to screen coordinates. The layout object holds every measurement, quoted from a design frame screenshot so the layout can be checked against the spec directly. At rest, it is a small pill. When the pointer reaches it, the notch unfolds. An orb below it shows an arc at rest and a gear on hover, opening Settings.

Settings allow the notch to always show, or to hide entirely. Appearance options include a choice between countdown timers and absolute reset dates, plus an accent colour ring. The app can show a Dock icon, a menu bar icon, or neither. Updates are handled by Sparkle, checking daily and installing signed builds in the background without prompting.

Codenotch does more than count tokens. A thin arc spins inside a ring while a session is busy; a pulsing amber ring appears when an agent is blocked waiting on human input. Hover, and the tooltip names every live session, where it is running, and what it wants.

When a session ends or stops to ask something, the notch can open itself for five seconds and sound an alert, raising the host application by walking up the process tree from the agent’s process ID. The author is explicit about the limits here: choosing the specific terminal tab is impossible because Terminal.app and iTerm2 expose ttys, while Warp and Ghostty publish no scripting dictionary. The app raises the application, not the tab, and names the session in the tooltip. It is a pragmatic compromise, documented with refreshing candor.

The notification logic is equally careful. Alerts fire only when a session leaves the busy state, not when a question is being answered, and not for every session discovered at launch. A session that vanishes mid-turn—what quitting Claude Code looks like—is not announced at all, because there is no window left to jump to. The sound is played as a file on the ordinary audio output rather than handed to the system alert channel, because that channel can be muted in Sound settings, and the system API reports success even when nothing is heard. Both the visual peek and the sound can be toggled separately in Settings, on the theory that they fail differently: the peek is useless behind a full-screen window, and the sound is useless in a meeting.

The most technically revealing part of the project is its frank admission that no vendor publishes a clean usage API. Every adapter is a thin layer over an internal endpoint, a local SQLite schema, or a language server’s RPC, and any of those can change without notice. The app handles failure by degrading to visible status states—stale, needsAuth, error—rather than inventing a percentage.

There are specific, gritty details. Claude’s endpoint returns HTTP 429 if polled too hard, with an unhelpful retry-after header of zero. The back-off treats that as a floor of 60 seconds, doubling per consecutive failure, capped at fifteen minutes, and the deadline is persisted across relaunches so restarting the app does not waste an attempt. Claude Code’s keychain token rotates frequently, filing a new keychain item whose access list does not carry Codenotch, so an Always Allow grant against the old item dies silently. The workaround is to ask the Claude binary itself, avoiding the keychain entirely. Where the keychain is still necessary, the app reads the item’s modification date—which is not behind the same access prompt as the credential—to check if the secret has changed before attempting to read the secret itself, minimizing prompts. These are the war stories of native Mac development, and the author documents them not as bugs but as environmental hazards.

Codenotch is not the only entrant in this space. CodexBar, published by the founder of OpenClaw, offers a similar menu-bar experience and has accumulated significant attention [3][6]. ClaudeBar and TokenBar are open-source alternatives with their own provider lists and macOS floor requirements; TokenBar is ad-hoc signed and not notarized, while ClaudeBar requires a newer macOS release [9]. SessionWatcher, a commercial product, also tracks the category [9].

What distinguishes Codenotch is its combination of open-source licensing, its deliberate no-sign-in architecture, and its physical notch metaphor. It also ships a Windows port, built in Rust with Tauri 2, replicating the same design and provider coverage—a surprising commitment for a utility that began as a Mac-native experiment.

Yet the project’s future is explicitly uncertain. The author open-sourced it under the MIT license because maintaining adapters for tools he does not personally use is unsustainable [8]. The hope is that the community will extend provider support and keep the integrations current. This is a familiar trajectory for native utilities that sit at the fragile intersection of vendor internals and user convenience. Whether the community picks up the adapter burden will determine if the notch stays filled.