Distill
Think out loud — get back what you concluded, not the rambling
What it makes
key takeaways
Communication
Real output
Talking yourself to a decision
Thinking out loud about where to store user data — exploring options and landing on one.
What you said
So I've been going back and forth on the database thing. Right now we use localStorage which is fine for MVP but like what happens when someone clears their browser data and loses everything. That's bad. So we need server-side storage. I was thinking Postgres through Drizzle since we already have that for auth. But then I read that SQLite might be better for this because each user's data is pretty small and SQLite is way simpler to operate. But wait we're on Neon already so Postgres is basically free and we don't have to manage anything. I think — yeah actually let's just use Postgres. But here's the thing, we need to think about the migration. We can't just flip a switch because people have data in localStorage already. And we should probably keep localStorage as a cache or fallback? I don't know, maybe that's overcomplicating it. Actually no, just do Postgres with a one-time import and drop localStorage after.
What you got
Move from localStorage to Postgres (via Drizzle, already in use for auth, already on Neon). Migration requires a one-time import of existing localStorage data, after which localStorage gets dropped entirely — no caching layer or fallback.
Why it’s better
A rambling back-and-forth becomes two lines. The SQLite detour and the “keep localStorage as a cache?” idea are gone because the speaker abandoned them — only the decisions they actually landed on remain, and nothing the speaker left unresolved gets invented as an open question.
Debugging out loud
Reasoning through a bug — firm findings, an uncertain hunch, and a next step to try.
What you said
OK so I spent like two hours debugging this websocket thing. The connection drops after exactly 60 seconds which is suspicious because that's our token TTL. So I think the server is actually killing the connection when the token expires even though the docs say the token only needs to be valid at connection time. I checked our code and we're not sending the token again after connect so that's correct on our side. I looked at the Deepgram forum and someone else reported this but no resolution. But also I noticed we're sending a keep-alive ping every 30 seconds and maybe — I'm not sure about this — maybe the ping is re-triggering auth validation? My suggestion is we mint a longer-lived token, maybe 10 minutes, and see if that fixes it.
What you got
Key Takeaways
The WebSocket connection drops at exactly 60 seconds, matching the token TTL — strong signal the server is killing it on token expiry, despite docs saying the token only needs to be valid at connection time. Our client code is correct; we're not re-sending the token after connect.
A possible secondary cause: the 30-second keep-alive ping may be re-triggering auth validation on the server. Unconfirmed, but it would explain the drop.
Someone on the Deepgram forum hit the same issue with no resolution — possibly a regression on their end.
Decisions
Mint a longer-lived token (10 minutes) as the next step to test whether the TTL is the cause.
Open Questions
Is the keep-alive ping re-triggering auth validation on the server?
Why it’s better
The hunches stay hunches — “strong signal,” “possible,” “unconfirmed” preserve exactly how sure the speaker was instead of hardening guesses into facts. The next step is captured as a decision, and the one thing the speaker genuinely wasn’t sure about becomes the single Open Question.
What comes back
- A quick thought or a single decision comes back as 1–3 crisp sentences of prose — no headers, no ceremony.
- A long, multi-thread exploration comes back structured: Key Takeaways, Decisions, and only the Open Questions you actually flagged.
- The output is dramatically shorter than what you said — the conclusions are the signal; the process is not.
- It never invents a conclusion you didn’t reach, never resolves a question you left open, and never promotes a “maybe” into a decision.
What you can count on
- Drops the options you explored and abandoned — keeps only the position you landed on
- Preserves your conviction — “I think” stays “I think,” “definitely” stays “definitely”
- Surfaces only the questions you explicitly left open, instead of inventing next-step questions you never raised
Install Distill and try it on your own voice.
Sign in to install DistillIs this hat for you?
Shapes rough thoughts into concise, focused takeaways.
You don’t reason in clean paragraphs — you ramble, chase a dead end, double back, contradict yourself, and land somewhere by the end. Distill listens to that whole messy process and captures only the destination: the conclusions you reached, the decisions you made (even the ones you made in passing), and the questions you knowingly left open. It drops the ideas you abandoned, merges the points you circled back to, and keeps your conviction exactly where you left it — a “maybe” stays a maybe. It is built to compress hard and to never add a conclusion you didn’t actually reach.
Best for
- Talking through a decision and capturing what you actually landed on
- Voice-dumping a problem you’re reasoning through into clean takeaways and decisions
- Catching the signal from a solo brainstorm or a thinking-out-loud session
- Turning a meandering voice memo to yourself into something you can act on later
Not for
- Polishing a message to send someone — Distill extracts your thinking for you, not for a recipient (reach for Clarity or Work Email)
- Keeping the full reasoning — it deliberately drops the “how you got there” and keeps the “what you concluded”
- A faithful transcript — it compresses to conclusions, not a record of everything that was said
Using it
How it works
- Think out loud — ramble, explore, change your mind, circle back. Distill takes in the whole process, not a tidy summary.
- It keeps your conclusions and drops the journey: abandoned ideas, false starts, and reasoning that led nowhere don’t make the cut.
- Decisions you made in passing become explicit, and topics you returned to several times are merged into one clean statement.
- It preserves how sure you were — tentative stays tentative, firm stays firm — and surfaces only the threads you explicitly left open.
Try saying
- I’ve been going back and forth on the database — localStorage is fine for now but people lose everything when they clear their browser… I was thinking Postgres since we’re already on Neon, actually yeah, let’s just do Postgres with a one-time import and drop localStorage after.
- Should we keep the delete confirmation modal? It’s annoying, two clicks every time… maybe keep it just for bulk delete? No — actually just remove it entirely, the undo toast covers us.
- Spent two hours on the websocket drop — it dies at exactly 60 seconds, which is our token TTL, so I think the server’s killing it on expiry. Not totally sure, but let’s try a longer-lived token and see.
Tips
- Just think out loud — you don’t need to organize first. The messier and more exploratory you are, the more Distill earns its keep.
- Say “I still need to figure out X” when something is genuinely unresolved — that’s how Distill knows to keep it as an Open Question instead of resolving it for you.
- It keeps conclusions, not reasoning — so if a “why” matters to you, say it as a conclusion (“we’re doing X because Y is the dealbreaker”) rather than as background.