Notes That Sort Themselves, v2

Three months ago I wrote about my note system that sorts itself, and I bragged that I could capture a thought from a locked phone on a subway platform. What I left out, because I didn’t know it yet: if that request failed underground, the note just died. No retry, no queue, no error. Gone.

The system mostly held up. Filing still works, the vault hasn’t rotted, and the morning card kept surfacing old notes. But capture, the part I was proudest of, was the weakest thing in the building. I’ve replaced it entirely, and once the replacement existed, resurfacing moved into it too.

What actually broke

Version one’s capture was an iOS Shortcut wrapping a raw GitHub API call. Elegant in the post, flaky in the hand. Shortcuts aren’t software you can debug: share-sheet input arrives in different shapes depending on the app, and some got quietly mangled. When the network hiccupped, the whole thing failed silently. A capture system you can’t trust is worse than none, because you stop saving things and don’t notice you’ve stopped.

And it lived on exactly one device. The Shortcut, and the repo-write token inside it, existed on my iPhone and nowhere else. Reading something on my laptop meant emailing myself a link like it’s 2009. That’s the quiet failure mode of clever demos: they don’t collapse, they erode. Every small breakage shaves off trust until you’re back to a graveyard of half-used tools.

The replacement is an app, and that’s the point

I resisted this, because “just build an app” felt like defeat after the no-backend brag. But the requirements had grown up: work on every device, survive having no signal, handle a whiteboard photo as easily as a pasted link, never lose a thought silently. That’s not a Shortcut. That’s software.

So I built Capture, a small web app I can install on anything with a browser. One screen, one button. It infers what you give it: text becomes a note, a URL becomes a link capture with the page title fetched, a photo gets compressed, a PDF gets attached. Everything still lands in Inbox/raw, so the sorting layer didn’t change by a line.

The part that fixed the trust problem is the queue. Every capture is written locally first, then synced. Offline, it waits. Failed, it retries on its own. I’ve watched a capture made in airplane mode sit patiently and commit itself the moment the plane hit wifi. That one behavior, capture first and network later, is worth more than everything elegant in version one.

I was wrong about the token, too

In v1 I wrote that a leaked token could at worst “leave notes in my inbox.” Generous. It could read and rewrite the entire vault, and it sat on a phone.

The token now lives on the server. My devices carry a small app key the server accepts for exactly one thing: create a file in the inbox. It can’t read, can’t delete, can’t wander. Lose the phone, rotate one environment variable, done. The clever version kept its most dangerous secret in the most losable place I own.

Resurfacing moved in, too

One piece still ran on a scheduled cloud job: the morning card, spending one of my five daily runs. Same shape as everything else I’d replaced: a scheduler, a quota, one device.

So Capture grew a second tab, Reflect. It shows one garden note a day, chosen by hashing the date over the list of content notes. That’s the whole algorithm. No cron, no state, nothing to jam. Every device agrees on the day’s note, past days collect into a trail, and a note can’t return within two weeks because the app recomputes the last thirteen picks and skips them. The phone’s key still can’t browse the vault; it can read one note per day, the one the date says.

Day one, it resurfaced a page called “Design Tools & Resources.” A pile of links, not a thought. The picker now skips index pages and the sources folder: resurface thoughts, not tables of contents. The trade-off is that a tab is a pull, not a push, so nothing pings me at 7am. I open Capture a dozen times a day anyway, and the note is there when I do.

Scheduled-job count for the whole system: zero.

The pattern, two versions in

The clever part breaks first. The real-time sorting jobs jammed within a day. The Shortcut eroded in months. Even the morning card fell to a hash of the date. The boring parts, plain text in a Git repo, a batch job, a folder called Inbox, haven’t hiccupped once.

The thesis survived: capture must be thoughtless, filing must be careful, and they should never share a tool. What changed is that I stopped treating the capture path as a place to be impressive. It’s the thing I do twenty times a day. It gets the boring, tested, works-everywhere version; the fun lives in the layers that read the notes, not the one that catches them.

My notes still aren’t where ideas go to die. Now the ideas survive the subway, too.