Grove

The problem

Most note apps optimize for capture and then let everything rot. Meanwhile, AI chat apps answer from a model's general knowledge and know nothing about what you have read, saved, and thought. Grove's premise is that your saved context should make AI answers better, not just your memory worse. You save articles to read later, keep notes in a built-in markdown editor, and ask grounded questions against your own library: the AI answers about an article with the rest of your notes in context, and a dialectic mode turns that around to question your notes and surface things you hadn't considered.

How it was built

In January 2026 I first saw the "ralph loop" at my weekly Swift meetup, where my friend Josh, an iOS engineer at a frontier AI lab, walked through Geoffrey Huntley's technique of putting a coding agent in a bounded bash loop against a spec file. I wanted a real project to try it on, and something to bring back to the group. Grove became that project.

My role looked like a product manager's. I wrote tight, sequenced tickets into the spec, and the loop picked them up and worked through them one after another with little supervision. Each iteration got fresh context, and memory lived on disk: git history, a progress file, a JSON spec tracking what was done. What keeps it honest is backpressure. The build has to pass before anything commits, so you are asking the compiler whether the code is good, not the model. The exception was UI: interface work still needed a lot of hands-on fine-tuning, because "does this look right" is not something the compiler can answer.

It worked better than I expected. The iOS/iPad port landed in 28 commits over roughly 3 hours, a stress test on a real native codebase with SwiftData sync, App Groups, and platform-split navigation. I presented the approach at the CocoaHeads SF × SLUG meetup in March 2026, and the honest judgment calls (what to spec, when to step in, what the agent got wrong) are written up in the essay.

Product decisions

• Grounded answers over open chat. The AI features run against your own corpus, and the dialectic mode is closer to a Socratic partner than a chatbot bolted onto notes: it asks you questions rather than just answering yours.
• Native, not wrapped. SwiftUI and AppKit where each matters, SwiftData for sync, a share extension for fast capture. It behaves like a Mac app because it is one.
• Spec as source of truth. Building with an agent forced product clarity. If a feature couldn't be specified precisely enough for the loop, it wasn't ready to build.

Outcome

Live on the App Store for macOS and iOS. A few months later the mechanism itself felt less novel: Claude Code and Codex now orchestrate multiple parallel agents directly, which takes the trick out of a hand-rolled bash loop. But the durable lesson was never the loop. It was context management, the discipline of feeding an agent bounded, fresh context each pass and keeping its memory on disk. That idea outlasted the shell script, and it is the one I carry into everything I build with agents now.