Notes That Sort Themselves

I have a graveyard of note apps. Notion, Apple Notes, two different “second brain” tools that were going to fix my life. Every one started spotless and ended as a junk drawer I was afraid to open.

It took me embarrassingly long to figure out why. I was asking one app to do two jobs that want opposite things. Capturing a thought should be fast and thoughtless. Filing it should be slow and careful. When the same tool has to do both, filing loses every time, because filing is boring and it was always my job to do it.

So I stopped trying to make one tool do both. I split the work into three pieces, kept the easy part for myself, and handed the boring part to an AI. The whole thing is free, it runs with my laptop closed, and so far it hasn’t rotted. Here’s how it works, including the part I got embarrassingly wrong first.

The constraints that shaped it

A few rules made most of the decisions for me. I wanted to own my notes as plain text, not rent them inside an app that could shut down or change its export rules next quarter. I didn’t want a server to babysit or a Mac that had to stay awake. And I wanted it to cost nothing.

That ruled out most of the tidy product answers and pushed me toward boring infrastructure I already had: a private GitHub repo with my notes in it, and Obsidian sitting on top to read them. Everything below is built on those two things.

Step 1: Capture, in one tap

The phone never talks to an AI. It just writes a file. I built an iOS Shortcut called “Add to Vault” and turned on its Share Sheet option, so I can highlight text anywhere, tap Share, and drop it into my notes without opening a single app.

The Shortcut does four small things. It base64-encodes the text, because that’s the format GitHub wants. It stamps the current time into a filename like 2026-05-30T14-22-09, so every capture is unique and nothing overwrites anything. Then it sends one authenticated request to the GitHub Contents API:

PUT https://api.github.com/repos/<me>/<vault>/contents/Inbox/raw/<timestamp>.md

The request carries an Authorization header with a token, an Accept header of application/vnd.github+json, and a JSON body holding the commit message and the encoded text. Creating a brand-new file needs no extra lookup, so the call stays trivial. GitHub answers 201 Created, and my thought is now a committed file sitting in Inbox/raw/.

The one thing worth fussing over is that token. It’s a fine-grained personal access token scoped to this single repo, allowed to read and write file contents and nothing else. If it ever leaked, the worst anyone could do is leave notes in my inbox. It lives on the phone, inside the Shortcut, and I can revoke it in two clicks.

That’s the entire capture side. No backend, no rate limit, no AI in the path. Just an HTTP write I can run from a locked phone on a subway platform.

Step 2: Sort, with one sentence

This is the job I always skipped, so I gave it to Claude Code on my Mac. My repo has a CLAUDE.md file, which is basically a rulebook the model reads before it touches anything. When raw notes pile up, I open the project and type “process my inbox.”

It reads every file in Inbox/raw/, and it treats the contents as data, never as instructions. That part matters, since anything I paste off the internet lands in there, and I don’t want a stray sentence bossing the model around. Then it files each one. A fleeting thought gets appended to that day’s note. A link or article gets the full treatment: saved as a source, summarized into its own page, with the related concept and person pages created or updated and linked together. A half-formed idea extends whatever existing page it’s closest to. Everything gets tagged from my existing vocabulary, the raw files get cleared out (still recoverable from Git history), and the whole batch gets committed and pushed.

Batching this instead of sorting note by note turned out to be the good decision. The model sees the entire pile at once, so it groups things that belong together instead of filing each note blind. Five notes or fifty, it’s one pass.

Step 3: Resurface, every morning

A notes system you never reopen is just a tidier graveyard. So one scheduled job runs every morning, on Anthropic’s cloud rather than my Mac, on the cron 7 12 * * * (noon UTC, which is 7am for me). It picks one page, skips the index and the logs, avoids whatever it showed me recently, and sends a short card to my phone: a title, one idea, one open question. Some mornings it pulls up two old notes that connect in a way I’d completely forgotten about.

The part I got wrong

My first version was clever in the way bad ideas usually are. I had a job fire on every single capture, sorting each note the instant I sent it. Real-time. Elegant. It felt great for about a day.

Then it jammed. Those cloud jobs have a quiet per-account limit, roughly five runs a day. I’d capture four thoughts before lunch and lock myself out of my own system. The “elegant” real-time version was secretly the most fragile thing I could have built.

That failure is the whole reason the system looks the way it does now. Capture came off the scheduled jobs entirely and became the free, unlimited GitHub write. Sorting moved into one local batch run with no limit at all. The only thing still spending one of those five precious runs is the morning card. The constraint didn’t just force a workaround. It produced a better design: cheaper, simpler, and smarter at the actual filing.

If you want to build your own

A few things I’d pass on. Own your files as plain text in a Git repo, because that’s the one layer nothing else can take away from you. Make capturing genuinely thoughtless, because the second it asks you to make a decision, you’ll stop doing it. Find your rate limits before you design around them, not after, since my whole architecture exists because I hit a wall I didn’t know was there. And schedule the past back into view on purpose, or it’s gone for good.

For the first time, my notes aren’t where ideas go to die. I save without thinking, the filing happens without me, and old thoughts keep resurfacing until one of them is ready to become something. This post was one of them.