I got tired of alt-tabbing between Claude Code sessions, so I built a floating status panel for macOS

Hayato Wada — Thu, 16 Jul 2026 15:00:00 +0000

If you run more than one Claude Code session at a time, you probably know this failure mode: a session hits a permission prompt and just... sits there. Silently. While you're heads-down in another window, one of your agents has been waiting ten minutes for you to answer "can I run this command?"

I kept doing this to myself. I'd kick off three sessions across different projects, get absorbed in reviewing one of them, and come back to find another had stalled on a prompt almost immediately after I looked away. The whole point of running sessions in parallel is throughput, and a stalled session is zero throughput that looks like progress until you check.

So I built ccglance — a small always-on-top floating panel for macOS that shows every running Claude Code session at a glance. This post is about what it does, how it works under the hood (the architecture is almost embarrassingly simple), and the slightly meta experience of building it almost entirely with Claude Code while it watched its own development sessions.

What it does

ccglance is a translucent HUD-style panel that floats above everything else. You park it in a corner — a secondary display works great — and it shows:

Every session, grouped by project. No more remembering which terminal tab belongs to which repo.
Working sessions show what they're currently doing, with elapsed time. If a session has been "running a build" for eight minutes, you can tell at a glance.
Sessions waiting for your permission pulse yellow. This is the whole reason the app exists. The pulse is impossible to miss in your peripheral vision, which is exactly where a status panel should live.
Subagents show up indented under their parent session, so a session that fans out into parallel workers reads as a little tree instead of a mystery.
Idle sessions show the PR's CI/review status for the session's branch — open, draft, merged, closed — so a "done" session tells you what to do next instead of just going quiet.

That's it. It's not a dashboard, it doesn't have settings pages, it doesn't want your attention. It's a glanceable answer to one question: do any of my sessions need me right now?

How it works

This is my favorite part, because the architecture is three arrows and no boxes worth drawing.

Claude Code has lifecycle hooks — SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Notification, Stop, SessionEnd. You register a command for each event, and Claude Code invokes it with a JSON payload on stdin whenever the event fires.

ccglance registers one tiny, dependency-free Node script for those events. The script reads the event from stdin and writes one JSON file per session to ~/.claude/ccglance/sessions/<session_id>.json — current state, tool being used, working directory, timestamps.

The app side is a native Swift/AppKit program that polls that directory every 0.5 seconds and renders whatever it finds.

Claude Code hooks → node script (stdin → JSON file) → AppKit app (polls every 0.5s)

No server. No sockets. No IPC. The two halves don't know about each other — they just share a directory. If the app crashes, hooks keep writing files and nothing breaks. If a hook fails, the app just renders slightly stale state. And when something looks wrong, the entire debugging story is:

cat ~/.claude/ccglance/sessions/*.json

I went back and forth on whether polling was too crude — file-system events (FSEvents) would be the "proper" way. But at a 0.5s interval on a handful of tiny JSON files, the polling cost is unmeasurable, and the code is dramatically simpler. Stale files from crashed sessions get cleaned up after 12 hours of no updates. Boring technology, chosen on purpose.

Design constraints I refused to compromise on

A status panel is an always-running utility, which puts it in a category of software I hold to a different standard than apps I open on demand. Three constraints shaped everything:

No Electron. Nothing against Electron for the right job, but I couldn't justify a Chromium instance for a panel that renders a list of session rows. ccglance is plain Swift/AppKit. There isn't even an Xcode project — the build is a shell script that calls swiftc directly, with zero external packages. The whole app compiles in seconds and the binary is tiny. If you've never built a Mac app without Xcode, I recommend trying it once; it's refreshing how little ceremony you actually need.

Never steal focus. This one is non-negotiable for a panel that floats over your work. The panel is a non-activating NSPanel — you can click it, drag it around, use its right-click menu, and the app you were typing in keeps keyboard focus the entire time. A status utility that yanks focus when you interact with it is worse than no utility at all, because it interrupts exactly the flow it was supposed to protect.

Zero dependencies, everywhere. The hook script is dependency-free CommonJS — no npm install, no node_modules, nothing to break when Node versions drift. The Swift side has no package dependencies. The fewer moving parts an always-on tool has, the fewer ways it can rot on someone's machine two years from now.

The meta part: it was built by the thing it monitors

Here's the bit I find genuinely funny: ccglance was built almost entirely with Claude Code. The Swift app, the hook scripts, the release CI (Developer ID signing and notarization on GitHub Actions), the Homebrew tap automation, the README, even the demo GIF pipeline — all of it came out of Claude Code sessions.

Which means that for most of its development, ccglance was sitting in the corner of my screen monitoring the very sessions that were building it. When a session paused on a permission prompt while implementing the yellow permission-pulse animation, the panel pulsed yellow to tell me about it. The tool debugged its own reason for existing in real time.

Beyond the novelty, one practical lesson from this project stuck with me: put your invariants in CLAUDE.md, not in your prompts.

CLAUDE.md is the project-level instruction file Claude Code reads at the start of every session. Early on I added this line (translated from Japanese):

The panel must never steal focus from the app you're working in — don't break this property.

That single sentence did a surprising amount of work. Across dozens of sessions — many of them touching window code with no prompt from me mentioning focus at all — Claude consistently reached for non-activating NSPanel APIs and avoided anything that would activate the app. I never had to re-explain the constraint, and I never caught a regression against it.

The general pattern: things you'd normally enforce through code review ("we don't do X in this codebase") work better as standing instructions than as per-task reminders. Prompts are ephemeral; the instruction file is institutional memory. My CLAUDE.md also encodes the build verification step, hook-testing procedure, and release rules, so every session starts already knowing how this project operates.

Did I write any code by hand? Barely. My job was closer to a picky reviewer with strong opinions about focus behavior and CPU usage. For a small, well-scoped utility like this, that division of labor worked better than I expected going in — the constraints were mine, the keystrokes mostly weren't.

Install

If you're on an Apple Silicon Mac running macOS 12+:

brew install --cask hatoya/tap/ccglance

Or grab the zip from the releases page. Releases are Developer ID signed and notarized, so Gatekeeper won't complain. Intel Macs aren't covered by the prebuilt binaries, but building from source is a git clone and one ./build.sh away — Xcode Command Line Tools are the only requirement.

On first launch the app wires up the Claude Code hooks automatically (it appends to ~/.claude/settings.json, leaves your existing hooks untouched, and saves a backup). Start a new Claude Code session and the panel picks it up. Uninstalling removes only ccglance's hooks — nothing else in your settings is touched.

It's free and MIT licensed: https://github.com/hatoya/ccglance

Current version is v1.6.0. It's an unofficial side project, not affiliated with Anthropic in any way.

Closing thoughts

There's a growing category of tooling problems created by agentic coding itself — not "how do I make the agent smarter" but "how do I, the human, supervise several of them without losing my mind." ccglance is my answer to one narrow slice of that: knowing when an agent needs me, without polling terminal tabs by hand.

If you run parallel Claude Code sessions, give it a try. And if you run more parallel sessions than I do, I'd especially love to hear how it holds up — issues and PRs welcome on GitHub.