esc
Anthology / Yagnipedia / Reflect

Reflect

The One That Got AI Right and Keeps Its Notes Behind Glass
Tool · First observed 2022 (Alex MacCaw, ex-Stripe, ex-Clearbit, currently sailing and shipping) · Severity: Admired (three times, genuinely, each time with the same conclusion)

Reflect is the note-taking application that understood, before anyone else, that the point of AI in notes is not to write your notes — it is to read them back to you, in context, when you need them, as if a librarian had memorised your entire collection and was waiting for the question.

This is not a roast. This is not a love letter. This is a respectful nod from across the street — the nod of a developer who has used Reflect at least three times, who admired it each time, and who each time arrived at the same conclusion: the library is beautiful, the librarian is the best in the business, and the building has no back door.

“Reflect got the AI right. Reflect got the capture right. Reflect got the encryption right. Reflect got the design right. The Lizard approves of a team that takes its time and does each thing correctly. The Lizard does not approve of a vault that cannot be grep’d. The Lizard is conflicted. The Lizard does not enjoy being conflicted.”
— The Lizard, experiencing an unfamiliar emotion

The Team

Reflect was built by Alex MacCaw — ex-Stripe engineer, co-founder of Clearbit (scaled to $50M ARR, 200 employees), who stepped down as CEO to build a note-taking app while sailing around the world, which is either the most or the least relatable career decision in this encyclopedia, depending on whether you have a sailboat.

The team is four people. Four engineers who use their own tool, who ship with the cadence of people who care more about getting it right than getting it out, and who have built something that feels — in every interaction — like it was designed by people who take notes seriously.

This is not Octarine’s velocity. Octarine ships weekly with the energy of a carpenter who sleeps at the workbench. Reflect ships when the feature is ready, with the energy of a team that has decided, consciously, that the correct number of times to ship a feature is once. The Lizard considers this the higher virtue. The Caffeinated Squirrel considers it a form of paralysis. Both are wrong. It is simply a different clock.

Reflect has gained less functionality in two years than Octarine gains on a typical Tuesday. This can be read as a criticism. It should be read as a compliment. Every feature Reflect ships works. Every feature Reflect ships is elegant. Every feature Reflect ships feels like it was argued about, tested, reconsidered, and shipped only when the team was certain it was correct. This is the anti-Mem. Mem shipped AI before shipping features. Reflect ships features only after they are features.

The AI That Actually Works

This is the section that matters. This is the section that makes riclib come back, every time, to sit in the reading room and talk to the librarian.

Reflect’s AI integration is the best implementation of “talk to your notes” in the PKM landscape. Not “technically impressive.” Not “a good demo.” The best. The one that works the way you imagined AI-powered note-taking should work before you tried it and discovered that every other tool’s version is a parlour trick.

The workflow:

  1. Semantic search — not keyword matching, semantic. You describe what you’re looking for in natural language. The system finds notes by meaning, not by string. The notes that match are not the notes that contain your words — they are the notes that contain your idea.

  2. Show you the list — the matching notes appear. You can see them. You can read them. You can understand what the AI found and why. This is not a black box. This is a librarian showing you the books before reading from them.

  3. Talk with the content — now you converse. With the notes. In context. The AI has the content. You have the questions. The conversation is grounded in your writing, not in the AI’s training data. The answers come from your archive, cited, traceable, yours.

This three-step flow — search, review, converse — is the correct architecture for AI-powered knowledge retrieval. Mem tried to skip to step three without steps one and two, which is like a librarian answering your question without showing you which book they’re reading from. Reflect shows its work. Reflect lets you verify. Reflect treats the human as a participant, not a recipient.

riclib used this. riclib admired this. riclib wanted this for his own notes. riclib went home and built something approximating this with Claude, lg, and NotePlan’s markdown files — because the AI was right, and the architecture was right, and the only thing wrong was that riclib’s notes were on the other side of a wall.

The Capture

Reflect got capture right early. This is not a small thing. Capture is the first interaction a user has with a note-taking tool, and most tools treat it as an afterthought — the thing you configure after you’ve set up your vault, installed three plugins, and chosen a daily note template.

Reflect’s browser extension captures web pages the way web pages should be captured — cleanly, formatted, into your notes, without a detour through a configuration screen. The Readwise integration imports Kindle highlights automatically — the passages you underlined at 2am arrive in your notes by morning, attributed, linked, ready to be found by the semantic search six months later when you’ve forgotten the book but remember the idea.

This is what Evernote did well, before Evernote forgot how to do anything well. Capture everything, worry about organisation later. The difference is that Reflect has the AI to make “worry about organisation later” actually work, because the semantic search finds things without folders, without tags, without the taxonomic anxiety that turns every note-taking tool into a filing exercise.

The Vault

This is the section where admiration meets the filesystem, and the filesystem loses.

Reflect is end-to-end encrypted. XChaCha20-Poly1305. Client-side encryption. The Reflect team cannot read your notes. This is genuinely good. This is the correct security architecture for personal notes. The Lizard approves of encryption so thorough that even the builders cannot see inside.

The consequence of this encryption — and of Reflect’s cloud-first architecture — is that your notes live in Reflect. Not on your filesystem. Not as markdown files in a folder. Not as anything that grep can search, that sed can transform, that lg can index, or that Claude can read directly through a file path.

Your notes are in the vault. The vault is beautiful. The vault is secure. The vault has a librarian who is the best in the business. And the vault has a very small window through which notes can be passed, one at a time, to the outside world.

Reflect has an MCP server. This is good. This is forward-thinking. This means Claude can, in theory, access your Reflect notes through the Model Context Protocol — the standard interface for AI tools to talk to data sources.

In practice, an MCP is a straw.

riclib has 253 notes in NotePlan. lg indexes them in 200 milliseconds. The blog serves them — all of them, rendered, wiki-linked, with covers and infoboxes — in under two seconds. grep searches them in 23 milliseconds. sed transforms them in less. Claude reads them directly from the filesystem, as files, because they are files, because NotePlan stores notes as files, because files are the universal interface.

Drinking 253 notes through an MCP straw takes longer than 200 milliseconds. Publishing 253 notes through an MCP straw is not a workflow — it is a hostage negotiation conducted one note at a time through a slot in the vault door. Running sed on notes inside Reflect is not possible, because sed operates on files, and Reflect does not have files. Reflect has a vault. The vault does not have a back door. The vault was not designed to have a back door. The vault’s entire security model depends on not having a back door.

This is not a criticism. This is a trade-off, acknowledged honestly. Reflect chose security and elegance over filesystem access. The choice is defensible. The choice is correct for most users, who do not need to pipe their notes through a shell pipeline or publish a satirical encyclopedia from a folder of markdown files in two seconds.

The choice is incorrect for riclib, who does.

“The vault is impregnable. The librarian is excellent. The developer outside the vault is holding grep and a bag of 250 files and a facial expression that suggests he has done the arithmetic on MCP throughput.”
— The Caffeinated Squirrel, who briefly suggested building a Reflect-to-filesystem bridge before being talked down

The Things It Got Right

Every problem gets an elegant solution. Reflect does not ship ugly features. The task management is clean. The daily notes are structured. The calendar integration works. The voice transcription uses Whisper. Each feature feels considered — not bolted on, not MVP’d, not shipped-then-abandoned. The team takes their time because the team has taste.

$15/month, no tricks. Not a $79 lifetime (that’s Octarine’s bet). Not a $500 Believer tier (that’s Roam’s tax on faith). Fifteen dollars a month for a tool that works, with AI included, no API keys required. This is the pricing of a team that is profitable and not optimising for a Series B deck.

Opinionated by design. No plugins. No community extensions. No “you can configure it to do anything” which means “you must configure it to do anything.” Reflect decides how things work. Reflect’s decisions are correct. The user opens the app and takes notes. The user does not spend a weekend installing plugins.

End-to-end encryption that was audited. Not “we say it’s encrypted.” Independently audited by Doyensec. No vulnerabilities found. The vault is real. The security is real. The trade-off is real, and the trade-off was made with eyes open.

The Three Visits

riclib has used Reflect at least three times. Each visit follows the same arc:

  1. Import notes. Admire the interface. Use the AI. Be impressed by the AI. Talk to the notes. Receive answers that are genuinely useful.

  2. Try to do the other thing. The thing where you manipulate your notes programmatically. The thing where you publish from them. The thing where you grep across them, pipe them through sed, index them with lg, serve them as a blog, generate covers, build an encyclopedia. The thing that requires files.

  3. Close Reflect. Return to NotePlan. Return to the markdown files. Return to the filesystem where 253 notes sit in a folder, indexable in 200 milliseconds, searchable in 23, publishable in 2 seconds, readable by Claude without an MCP straw.

The admiration does not fade. The limitation does not change. The three visits are three data points on the same curve: Reflect is excellent for people who interact with their notes through Reflect. riclib interacts with his notes through everything.

Measured Characteristics

See Also

See Also