Two Kids, Three Startups, One Voice

Every tool I've ever shipped started as a personal emergency. Keebye's emergency had two names, and one of them was under six months old.

Here's the situation the app was born into. I work with high-stakes startups — the kind where a seven-figure investment rides on whether the thing ships. Not one startup: several, in parallel, each with its own codebase, its own priorities, its own "this needs to be done yesterday." That work doesn't arrive as a tidy queue. It arrives as lanes: a migration in one, a review in another, an incident postmortem in a third, and a Slack channel per lane filling up in the background.

And then we had our second child.

Anyone who has held a sleeping infant knows the specific physics of it: you have one arm, maybe. You are, functionally, a single-handed developer for hours at a time. Meanwhile the lanes don't pause. The agent finished its refactor and is waiting for direction. The other client's question is sitting there aging. Your typing throughput — the thing your entire output secretly routes through — just got cut by more than half.

The math that broke

The promise of AI coding agents is real. Claude Code genuinely will execute a multi-file refactor while you do something else. Run two or three lanes and, on paper, you're operating at some multiple of yourself. Everyone chasing 10x output has read this pitch.

But the multiple has a denominator nobody mentions: every lane advances on natural language you produce. Prompts, redirects, reviews, replies. If producing that language requires two free hands and a full context switch into the right window, then your lanes aren't parallel at all — they're time-sliced through a single choke point. Adding a lane adds coordination cost until the "multiplier" quietly turns into overhead.

I could feel the choke point physically. I'd have the next instruction fully formed in my head — "revert the schema change, keep the API rename, rerun the migration" — and it would just sit there, queued behind a baby, a sandwich, or my own hands being mid-task in a different lane. The thought was instant. The delivery was the bottleneck.

You don't need 10x hands. You need a second output channel.

Why the existing tools didn't fit

I tried dictation tools — good ones exist, and we say so plainly in our comparison pages. But my requirements were shaped by exactly the day I just described, and three of them turned out to be non-negotiable.

It had to work in terminals. My lanes live in iTerm2 and tmux, often over SSH. Clipboard-paste insertion breaks in exactly those places. I needed something that could type — synthetic keystrokes, paced so a terminal keeps up.

It had to be local. The things I dictate are the interior of other people's companies: unreleased products, investor-adjacent decisions, security discussions. "We send audio to the cloud, but responsibly" is a fine answer for many users. It couldn't be mine. Speech-to-text had to run on my own hardware, provably, with Wi-Fi off if necessary.

It had to be invisible. No app window, no mode to enter. Hold a key, speak, release, gone. A tool that demands its own lane defeats the purpose.

So I built it. Keebye is a small native macOS menu-bar app — Tauri, so it stays light — that holds exactly that shape: hold Right ⌘, speak, and the words land wherever your cursor is. On-device models (an English-tuned default, an optional 25-language engine, or Apple's native one), offline after the first download, rule-based cleanup with an optional local-LLM polish, a dictionary for project jargon, text-only history that deletes itself after 30 days, and no telemetry. Those aren't brochure adjectives; they're the requirements list from that couch, with that baby.

What actually changed

I want to be careful here, because founder stories drift into fiction easily. I'm not going to give you a percentage improvement; I never measured one, and I'd distrust anyone's number anyway.

What I can tell you is what the days feel like now. The formed-but-undelivered instruction is mostly gone: when a lane needs direction, I look at it, hold the key, and say the thing. Replies to humans — the Slack messages that used to age for hours because answering meant abandoning a lane — go out in the gaps, spoken into whatever window has focus. And the one-armed hours stopped being dead hours. Some of the most productive direction I give happens standing up, pacing, holding a sleeping kid.

The honest limits are still there. Dictation doesn't think for you; a mumbled, half-formed prompt produces a mumbled, half-formed result, spoken or typed. Keebye is early-access software with the rough edges that implies. And voice is a supplement to hands, not a replacement — I still type plenty, just no longer as the single point of failure for every lane at once.

The thesis, if there is one

The 10x developer discourse always imagined one person typing faster. What's actually arrived is stranger: one person conducting — several semi-autonomous lanes, each waiting on a sentence. In that world your leverage isn't your WPM. It's how cheaply you can deliver intent to whichever lane needs it, in whatever physical situation you're in.

For me the cheapest channel turned out to be the one I'd had all along.

If your days look anything like this, the workflow details are in Driving Claude Code with your voice, and if English isn't the language you think in, read why dictation shouldn't be English-only. Keebye is in early access for macOS — builds are on GitHub releases. It was built in exactly the situation it serves: one arm full, lanes still moving.