macOS Menu Bar Tool Tracks Claude Code and Codex Usage

A developer has released a free, open-source macOS menu bar utility that displays Claude Code and Codex usage as a battery-level indicator, giving AI-assisted developers a quick glance at how much of their quota they have consumed. The lightweight tool reads local state files instead of making API calls, offering a privacy-friendly approach to tracking AI coding tool consumption.

The project, now available on GitHub and Product Hunt, addresses a growing pain point for developers who rely heavily on AI coding assistants but lack a simple, always-visible way to monitor their usage limits.

Key Takeaways

• Displays Claude Code and OpenAI Codex usage as a battery gauge in the macOS menu bar
• Parses local state files — no API requests or network calls required
• Fully open-source with code available on GitHub
• Free to download, though it requires a manual security override since the app is unsigned
• Designed for developers who want passive, at-a-glance usage monitoring
• Works natively on macOS without additional dependencies

Why Developers Need Usage Monitoring Tools

The rise of AI coding assistants has fundamentally changed how software engineers work. Tools like Anthropic's Claude Code and OpenAI's Codex have become integral parts of modern development workflows, handling everything from code generation to debugging and refactoring. However, both services come with usage limits that can catch developers off guard.

Unlike traditional software tools with predictable resource consumption, AI coding assistants burn through tokens and requests at variable rates depending on task complexity. A simple code completion might use a fraction of the quota that a complex multi-file refactoring session demands. This unpredictability makes passive monitoring essential.

Most developers currently check their usage through web dashboards or CLI commands — both of which require active effort and context switching. A persistent menu bar indicator eliminates that friction entirely, functioning much like the battery indicator already built into macOS but for AI resource consumption.

How the Tool Works Under the Hood

The utility takes a notably privacy-conscious approach to usage tracking. Rather than intercepting API calls or connecting to Anthropic's or OpenAI's servers, it reads local state files that Claude Code and Codex maintain on the user's machine. This means the tool never sends data anywhere and operates entirely offline after installation.

The battery metaphor is intuitive and immediately understandable:

• Full battery: Most of your quota remains available
• Half battery: You have consumed roughly half your allocation
• Low battery: You are approaching your usage limit
• Empty/critical: You have nearly exhausted your available quota

This visual representation converts abstract token counts and rate limits into something developers can process in under a second. The detailed parsing logic is documented in the project's README on GitHub, allowing technically curious users to verify exactly what data the tool accesses and how it calculates the displayed percentage.

Installation Requires a Security Workaround

One notable friction point is that the app is unsigned, meaning macOS Gatekeeper will flag it and suggest moving it to the trash upon first launch. This is a common issue with independent macOS utilities distributed outside the Mac App Store, particularly from solo developers who haven't invested in Apple's $99/year Developer Program membership.

To install and run the tool, users need to follow these steps:

• Download the latest release from the project's GitHub releases page
• Attempt to open the application (macOS will block it)
• Navigate to System Settings → Privacy & Security
• Scroll down to find the blocked application notification
• Click 'Open Anyway' to grant the necessary permissions
• The app will then launch and appear in the menu bar

While this process adds a small barrier to entry, it is a standard procedure that most macOS power users are already familiar with. The open-source nature of the project also allows security-conscious developers to audit the code and build the application from source if they prefer.

Fitting Into the Broader AI Developer Tools Ecosystem

This menu bar utility arrives at a time when the ecosystem of meta-tools — tools that help developers manage their AI tools — is rapidly expanding. As AI-assisted development matures beyond the early adopter phase, practical usability concerns like quota management, cost tracking, and workflow optimization are becoming increasingly important.

Compared to more comprehensive solutions like Cursor's built-in usage dashboard or enterprise-grade API management platforms, this menu bar tool occupies a deliberately minimal niche. It does one thing and does it well, following the Unix philosophy that has long resonated with developer tool builders.

The timing also aligns with significant developments in the AI coding space. Anthropic recently expanded Claude Code's capabilities and availability, while OpenAI launched Codex as a cloud-based coding agent within ChatGPT. Both companies are aggressively competing for developer mindshare, and usage limits remain a key differentiator — and source of frustration — across both platforms.

Similar community-built utilities have emerged for other AI services. Token counters, cost calculators, and usage dashboards for the OpenAI API have been popular on GitHub for over 2 years. However, tools specifically targeting the newer agentic coding assistants like Claude Code and Codex are still relatively rare, making this project an early mover in a growing category.

What This Means for AI-Powered Development Workflows

For individual developers, the practical benefit is straightforward: no more surprise rate limits interrupting a productive coding session. Knowing that your Claude Code allocation is running low allows you to prioritize remaining usage for the most impactful tasks or switch to an alternative tool before hitting a wall.

For teams and organizations, tools like this highlight a broader need that platform providers themselves should address. The fact that a community developer felt compelled to build a third-party usage monitor suggests that Anthropic and OpenAI's native usage visibility features may not be meeting user expectations. Both companies could learn from this kind of grassroots innovation.

The project also demonstrates the value of local-first design in developer tooling. By avoiding network requests entirely, the tool sidesteps concerns about API key exposure, data collection, and network latency that plague many monitoring solutions. This approach is only possible because both Claude Code and Codex store state information locally — a design choice that may not persist as these tools evolve.

Looking Ahead: The Future of AI Usage Management

As AI coding assistants become as essential as text editors and version control systems, usage management will likely evolve from a nice-to-have into a critical workflow component. Several trends point to where this space is heading:

• Platform-native monitoring: Anthropic and OpenAI will likely build more robust usage dashboards directly into their tools
• Cost optimization tools: Expect more utilities that help developers minimize token usage without sacrificing output quality
• Multi-provider management: As developers use multiple AI assistants simultaneously, unified dashboards will become essential
• Team-level allocation: Enterprise features for distributing and tracking AI usage across development teams
• Predictive usage alerts: Smart notifications that warn developers before they hit limits based on current consumption patterns

For now, this lightweight macOS menu bar tool fills an immediate need with an elegant, minimalist solution. Developers interested in trying it can download the latest release from the project's GitHub page or show support by upvoting on Product Hunt.

The project is a reminder that some of the most useful developer tools are not billion-dollar platforms but small, focused utilities built by developers who scratched their own itch. In the rapidly evolving AI coding landscape, these community contributions often signal where the mainstream platforms need to go next.