BubbleCode: supervise Claude Code without watching it

Introduction

I built BubbleCode because I kept catching my agents doing nothing.

I run Claude Code across several projects at once. The pattern was always the same: kick off a long task, switch to something else, come back twenty minutes later — and find the agent frozen on line three, waiting for me to approve a git push it asked about nineteen minutes ago. The work wasn't slow. The supervision was.

Every fix I tried was a worse version of the problem. Tiling terminal panes so I could see all the sessions meant I was back to staring at terminals. Turning on YOLO mode and skipping approvals entirely meant handing an autonomous process my shell with no supervision — fine right up until it isn't. Neither is a real answer, because neither addresses the actual mismatch: agents work in the background, but they ask for permission in the foreground.

BubbleCode is a native Mac app that closes that gap. Your Claude Code sessions run in the background, and a floating bubble taps you on the shoulder the moment one of them needs a human decision — including over apps in true fullscreen.

To be clear about what that does and doesn't change: you still approve every single permission request. BubbleCode doesn't decide anything for you and doesn't reduce how often your agents need you. What it removes is the waiting between those moments — the part where you keep a terminal in view, check tabs, and find out after the fact that nothing has happened for twenty minutes. You stop polling your agents and start getting interrupted by them. Same decisions, none of the vigilance.

The Problem

If you run Claude Code seriously, you're paying for a Pro or Max subscription and running two to five agentic tasks in parallel. The bottleneck isn't the model. It's you.

An autonomous agent that needs permission is a blocked agent. It sits there, burning wall-clock time, until you happen to look at the right terminal tab. So you end up in one of three bad states:

• Babysitting. You keep the terminal visible and watch it, which defeats the point of running an agent in the first place.
• Blind running. You go do something else and discover twenty minutes later that nothing happened after the first permission prompt.
• Skipping the safety rail. You disable approvals so it never blocks — which works until an agent does something you'd have said no to.

The uncomfortable part is that the permission prompt isn't the flaw. It's the one moment where your judgment actually matters. The flaw is that claiming that moment costs you a full context switch: find the window, find the tab, read the scrollback, remember what this session was doing.

The Solution

BubbleCode is a human supervision layer for Claude Code. It doesn't try to make your agents more autonomous — it makes supervising them nearly free.

It's a native Swift/AppKit app that runs each chat as a real claude CLI subprocess, one per project directory, talking JSONL over stdin/stdout. Every open chat keeps running in the background whether or not you're looking at it. When any of them hits a permission request, the floating bubble pulses orange. Click it, it expands onto the chat that needs you, you approve or deny, and you go back to what you were doing. The main window is optional.

The bubble is a .fullScreenAuxiliary, non-activating panel at status-bar level, which is a technical way of saying: it shows up over a fullscreen video, a fullscreen game, or a Keynote presentation, it doesn't kick you out of fullscreen, and it doesn't steal focus. Drag it anywhere on screen you like.

It uses your existing Claude Code login. There's no API key to paste, no proxy, no credentials for BubbleCode to store — it launches the official CLI you already have installed and relays your decisions to it.

Key Features

• The bubble. A draggable, always-on-top presence that reflects the state of every chat at once and pulses when any of them needs you. Expands into a live chat you can reply from directly, over fullscreen apps, without leaving what you're doing.
• Parallel background chats, one per project. Each chat is its own claude process bound to a project directory, and it keeps working while you're on another chat or with the window closed entirely. Chats and full transcripts persist across restarts, so reopening the app gives you everything back.
• One-click permission decisions with context. BubbleCode intercepts Claude Code's own permission request, shows you what's being asked, and relays your explicit allow or deny. Claude Code stays in its conservative default permission mode — nothing is silently auto-approved.
• Terminal session tracking. Toggle it on and claude sessions you started yourself in Terminal, iTerm, or Ghostty show up in the bubble alongside your BubbleCode chats — read-only status, cost, context, and git branch. It adds a status line and a few hooks to ~/.claude/settings.json additively, backs the file up first, and removes only its own entries when you toggle it off.
• Native notifications and per-chat model selection. macOS notifications for needs-approval, finished, and crashed, plus per-chat model and thinking-effort settings, and a first-run health check that tells you if the claude CLI is missing or logged out instead of failing mysteriously.

Frequently Asked Questions

What problem does BubbleCode solve?

Blocked agents. Claude Code pauses for permission, and if you're not watching that specific terminal, it stays paused. BubbleCode makes the pause cost about two seconds instead of a context switch, so you can genuinely run agents in the background without either babysitting them or turning off the approvals that keep them safe.

Who should use BubbleCode?

Claude Code Pro and Max users running multiple long agentic tasks at once — indie hackers, senior engineers, solo founders who currently juggle this with tmux or a wall of split panes. If you already pay Anthropic for the model, BYO-login is a feature: BubbleCode charges for the app, never for AI usage, and never touches your credentials.

When is BubbleCode the right choice?

When you're running two or more agents in parallel and the thing slowing you down is your own attention. If you run one Claude Code session at a time in a terminal you're already staring at, you don't need this. The value shows up exactly when sessions outnumber the windows you can watch.

How is BubbleCode different from alternatives?

Two honest comparisons.

Versus Claude Code GUIs (Clarc, Conductor, Anthropic's own Claude Desktop): those are windows you look at. They're good at being a workspace; they still assume you're in front of them. BubbleCode is designed around not being looked at — the main window is the optional part, the bubble is the product.

Versus the notch apps (notchi, Vibe Island, AgentPeek, and others): these already do ambient agent notification, several of them free and open source, and most support far more CLI agents than BubbleCode's deliberate Claude-Code-only scope. I'm not going to pretend that category doesn't exist. What's different here is a bubble you can put anywhere on screen rather than a UI anchored to the physical notch, rendering that's built to survive true fullscreen, and a full two-way chat you can actually reply in from the bubble — not just an approve/dismiss chip. If the breadth of 20-plus agent support matters more to you than depth on Claude Code, one of those is probably the better pick, and I'd rather you know that up front.

Conclusion

Autonomous coding agents are getting better fast, and almost all the tooling around them is racing toward removing the human. I think the more useful problem is the opposite one: keep the human in the loop, and make being in the loop cost almost nothing.

That's the whole idea behind BubbleCode. Your agents work; the bubble waits; you show up only for the decisions that need you.

BubbleCode is a native Mac app for Claude Code, and it's in early access now. If you're running agents in parallel and you're tired of finding them stalled on a question nobody answered — try it, and tell me what breaks.