For developers who use AI but still want to do the thinking
You already know the fix. You just haven't said it out loud yet.
You hit a bug, and the reflex is to paste it into the AI and run with whatever it spits back. Ducky sits on your desk to slow that reflex down. Press the button and it reads the failure from your terminal, then asks one sharp question back. You talk it through out loud while you think; the question comes from your terminal context, not a microphone. When you want the answer, it gives you a focused one, not a wall of seven things to try.
Open sourceRuns in your terminalYou see what it sends
Read the source ↗Why a duck
A lot of problems solve themselves the moment you explain them out loud.
Rubber-duck debugging works because saying the problem out loud forces you to slow down, and that’s usually where you notice the thing you missed. Most AI tools jump straight to suggestions, so you never get that moment.
Which process grabbed that port first?
Want monitoring in place before the next one bites?
Is this gold-plating? What’s the smallest version you can ship today?
Who’s the one user you’d build next week for?
Compare
- ChatGPT voice: “Here are 7 things to try…”
- Ducky: “Which process started first?”
How it works
It asks first, and gives you the answer when you ask for it.
Ducky pulls the relevant context from your terminal, blanks out anything secret, and shows you that preview before it sends a thing. Then it talks the problem through with you, asking the questions that point you at the right place. When you want the answer, it gives you a focused one: the most likely cause and a safe next step. It never runs anything for you.
$ duck think --stuck
→ one bounded answer, max 4 sentences
Press the button
One press starts the capture. There’s no hotkey to remember and no window to switch to.
Approve the preview
Ducky shows you the captured context and flags any secrets it’ll redact, and you decide whether it sends.
Talk it through
Ducky asks one clarifying question. Answering it out loud can surface the fix before the AI is even involved.
Get the answer when you want it
Talked it through and still want a hand? Run ‘duck think --stuck’ and you get a focused answer: the most likely cause and a safe next step.
The ‘--stuck’ flag tells Ducky you’ve already talked through the problem and want one concrete next step. It returns a single likely cause and one safe action to take. It does not execute anything.
Why it works this way
Built around how focus actually works.
Asking first, showing a little, and never interrupting aren’t style choices. They line up with how memory and attention actually behave, which is why the loop helps you think instead of piling on noise.
- You work it out; you remember it. You hold on to what you work out yourself far better than what you’re handed. Psychologists call it the generation effect.
- One question and a few facts, never a wall. Working memory only holds about four things at once. A twenty-line context dump competes with the bug you’re already carrying in your head.
- It waits for your press. It never pops up. Getting pulled out of flow costs minutes, not seconds. Ducky never grabs your attention on its own, so the focus stays yours.
Eight personalities
Pick the duck that thinks like you.
Same loop, eight ways to be asked. Switch the duck’s voice to match how you debug, or just the mood you’re in. These ship today.
Analyst
Separates config, environment, and code-change causes by one observable fact.
Debugger
Isolates the one input that changed: command, env, dependency, or port.
Meme
Unsticks you with light humor, still asks for one useful breadcrumb.
PM
Connects the failure to the user-visible workflow that is blocked.
Rubber Duck
Surfaces the gap between what you expected and what actually changed.
Senior Engineer
Asks for the smallest reversible check to confirm or falsify the cause.
Senior Reviewer
Frames the failure as a reviewer: the smallest diff that proves the fix, and the regression to guard.
Student
Guides you to restate the error and point to the first line that proves it.
OPENAI_API_KEY="sk-proj-••••••••••••••••"problem = ctx.get_terminal_error()persona = "senior-engineer"DB_PASS="hunter2"duck.think(problem, persona=persona)2 secrets redacted before sending
Privacy
You see what it sees before anything leaves your machine.
Before every external AI call, Ducky shows you the captured context and marks which values it will redact. You confirm before it sends. Redaction is a required gate, not an optional setting. Local-only is the default; an external provider is used only after your explicit opt-in, and the context goes from your machine to your chosen provider directly.
- Context preview before external AI calls — You approve every call yourself, and nothing goes out in the background.
- Redaction required before real LLM provider — The prototype enforces this, and you can’t switch it off.
- Local-only mode is the default, and it works today — Nothing leaves your machine unless you explicitly opt in to a provider — and you pick which one.
- No always-listening microphone in MVP — Input only happens when you press the button, so there’s no ambient audio capture.
The object
A real duck on your desk.
Right now it’s a USB dev-board prototype, and we’re not going to pretend otherwise. But the point was never the chip. Pressing a real thing on your desk puts one small pause between you and the machine, and a button you can actually feel makes that habit stick in a way a hotkey or a browser tab never does. If you’ve backed a Flipper Zero or a Playdate, you know the type: a small, honest piece of hardware with a clear reason to exist. We’re building the first run in the open, and we won’t order a single unit until enough developers say they want one.
Would you actually put this on your desk?
There’s no price and no commitment. Tapping this just tells us the hardware is worth building.
Validation status
Let’s be straight about where this is. The software is real and it works today. What we’re still missing is you: developers outside our own machines telling us the physical duck is worth building.
1,400+
the Listener→answer loop is tested, not a mockup
Open
macOS today: shell, tmux, and agent-session capture; read every line
0
that’s exactly what the first 50 are for
The brain is done and free. The open question is the hardware: we want 50 developer signals before we order a single duck.
Join the first 50 dev testers.
No price and no launch date yet. You’ll get early access when the prototype is ready to leave the desk.
No spam, and you can unsubscribe any time. It’s a macOS prototype with limited early access.