Yeah I used the “message to self” approach for a while too — it works surprisingly well 🙂
What I ended up building is basically a very minimal “capture layer”, where no matter the context (share, paste, shortcut, etc.), everything goes into the same place instantly, without deciding upfront what it is or where it belongs.
It’s not really a note-taking tool — more like a universal entry point.
If you’re curious: https://github.com/oldany/dropmind
Good question 🙂
For me it’s mostly the small, in-the-moment things:
Not really structured notes — more like “things that appear during the day” that I don’t want to think about organizing right away.
That’s also why tools like Joplin or OneNote never quite fit for me in that specific moment — they work great once you sit down to write something, but not as much as a quick, frictionless entry point.
Yeah that makes sense — treating a folder as the universal entry point is a clever way to unify things.
I think that’s exactly the direction: trying to reduce everything to a single “drop zone”.
Where I personally kept feeling friction is that you still need something in between to get things into that folder (scripts, gestures, automations, etc.).
So the entry point becomes “save to this folder”, but the way you get there still depends on context.
That’s the part I always found hard to make truly uniform.
That’s actually a really interesting direction — using screenshots as a universal entry point.
It kind of shows how strong the need is for a single capture flow, even if it means bending everything into one format.
What always stopped me there is exactly what you mentioned — once you need OCR, scripts, post-processing… it starts adding friction again.
I kept wondering if the entry point could stay just as universal, but without needing to transform the content first.
That’s actually a really solid setup.
What always got me personally is exactly that — over time I’d end up with multiple “entry points” depending on context (screenshot, chat, browser, notes…).
Each one works, but I’d still need to mentally switch between them depending on what I’m capturing.
I kept wishing for something where the entry point is always the same, no matter the context.
Yeah Syncthing solves the “where does the data live” part really well.
What I kept struggling with is the step before that — actually capturing something in the moment, from whatever context you’re in.
Even with sync in place, I always felt like I still had to decide where to put things and which tool to use.
That’s where it starts to break down for me.
Yeah I get what you mean 🙂
Shortcuts work (that’s what I’m using on iOS right now), but they can feel a bit “indirect” compared to something more native like share sheets or drag & drop.
Curious to hear how it feels once you try it — especially what feels frictionless vs what doesn’t.
Yeah I tried going the “second brain” route too (Trilium, Obsidian, etc.)
What I kept running into is that they’re great once something is already in the system — but capturing still feels like a separate step where you have to think about where it belongs.
I started wondering if capturing should be completely independent from organization, and almost “context-free”.
More like a thin layer you can hit instantly from anywhere, without deciding anything upfront.
Sure 🙂
What I ended up building is basically a very minimal “capture layer”.
The idea is simple: no matter where you are (phone, browser, desktop), capturing something should always be the same action.
In practice:
Everything goes into the same place instantly, without deciding upfront what it is or where it belongs.
No tags, no structure, no “mode switching”.
Just capture first, decide later (or never).
I built it mainly because I was tired of stitching together different tools depending on context.
If you want to take a look: https://github.com/oldany/dropmind
Yeah — that’s exactly the feeling I kept running into.
At some point I stopped trying to adapt existing tools and ended up building something around this idea of “uniform capture”.
It’s basically a very minimal layer where you can send anything (text, links, quick notes, etc.) from any device in one step — without worrying about where it goes or how it’s structured.
Still early, but it’s been working surprisingly well for me in daily use.
Good question — I don’t mean organizing or saving things long-term.
I mean that moment when you see or think something and don’t want to lose it.
Like:
The problem for me is that if capturing that takes more than a second, I often just don’t do it — or I postpone it and forget.
So “capture” is really just that instant: taking something from wherever you are and storing it somewhere with zero friction.
Yeah KDE Connect is great for device-to-device flow, I’ve used it too.
What I always found tricky is that it works really well once you’re already “in the flow”, but not so much as a quick capture entry point.
Like, it helps moving things around — but not necessarily deciding to capture something instantly in the first place.
That’s where I always felt something was missing.
Yeah that makes sense — I ended up with similar setups at some point.
What always bothered me a bit is exactly that fragmentation: different tools depending on what you’re capturing and from where.
It works, but it feels like you’re constantly switching “mode” depending on context.
I keep wondering if capturing should really depend on the destination at all, or if it should be something more uniform.
Pretty much everything 😄
The problem (for me) wasn’t what to capture, but how fast and from where.
I tried things like Linkwarden too — great tool, but still feels tied to specific entry points (browser extension, app, etc.).
What I kept missing was something more “universal”, where capturing is always one step away regardless of device or context.
Yeah I tried similar approaches too (notes to self, chat apps etc.)
They kind of work, but I always felt they weren’t really designed for this use case — more like a workaround.
What I was missing was something more “frictionless”, where capturing is basically instant and doesn’t depend on context.
That’s a really good way to frame it.
I kept coming back to the idea that the “act” shouldn’t be something new you have to learn — it should reuse what you’re already doing in each context.
So instead of one single physical gesture, it’s more like a single intent expressed through different native actions:
The key (for me) wasn’t forcing one gesture, but making all of those feel like the same action underneath.
So the mental model becomes: “this goes into my inbox”, regardless of how I triggered it.
That’s where things started to click for me.