Alter

I’ve been rebuilding one idea (a place that actually understands the things you throw at it) under one name or another for a year and a half. Five rewrites later, this is what it became. (The whole story, if you want it.)

One dock in, two questions out

You drop a thought into a dock that’s always there: a note, a question, a half-formed idea, a voice ramble on a walk. Alter reads it, decides what it is, and files it where it belongs, then tells you what it did and why: filed under Turkey Trip. You’ve been planning flights all week. One tap undoes it.

Everything after that is two questions, which are the only two the app has:

• Today: what needs you now. A short, chosen few, promoted each morning, with the reasoning behind the choice visible rather than mysterious.
• Life: where everything stands. Your whole workspace at a glance: one tile per endeavour, weighted by how live it is, in a map that doesn’t rearrange itself while you’re looking at it.

Underneath, a wiki compiles itself: once a few captures accumulate against a topic, a worker compresses them into that page (always preserving what you wrote by hand) and re-indexes it for search. (The idea of an LLM quietly keeping a clean, self-compiling knowledge base out of a messy stream of inputs is one I took from Andrej Karpathy.)

Five modes were the product’s headline, and the problem

For most of this year the product’s headline was five modes: five different things a capture could become, each with its own surface, each explained to you during onboarding. I was proud of them. They were also the problem.

A new user had to learn about fifteen concepts before the app made sense, against a working-memory budget of about four. The information architecture gave system processes their own rooms (a page for the inbox, a page for the wiki, a page for briefings) when the user only ever had three questions: where did that go, what needs me now, and where does everything stand?

So in August the whole surface came down. Five pages became two tabs. The modes went internal. They’re still the response contract underneath, but you never pick one; recognition does, and shows you its choice as a chip you can flip. In exchange for taking the machinery off the screen I had to add something back: receipts, everywhere, because filing that happens invisibly is filing you can’t trust.

That trade (fewer rooms, more evidence) is the single most useful thing I’ve learned building this.

Eleven services, 289K lines, 40% of it tests

Eleven TypeScript/NestJS services behind REST boundaries: recognition and orchestration, the wiki and its compilation queue, vector search (pgvector), a stateless encryption service, billing, audit, with a Next.js front-end. Streaming is SSE end to end; LLM output is enforced as structured data through tool-use and Zod schemas, never “please return JSON”; every prompt has a golden eval suite with a per-run cost budget. Content is encrypted at rest by default, and CI fails if a change could let content leak into logs or telemetry.

Some numbers, for scale: ~289K lines of TypeScript across 2,171 files (about 40% of it tests), 111 database migrations, 750 test files, 29 end-to-end paths, 31 architecture decision records, and roughly 1,270 commits over nine months, fourteen phases, 178 merged pull requests.

Almost none of which I typed. The agent org that builds it is a project in its own right.

Autonomy is split by reversibility, not by size

• Prompts are versioned, tested components. Each with a golden eval suite and a dollar cap per run.
• Encryption by default, with CI checks that fail if content could leave the box.
• A per-user daily LLM cost cap that degrades gracefully instead of cutting off.
• A custom Postgres-backed compilation queue (FOR UPDATE SKIP LOCKED, per-entity coalescing, user-edit-wins) instead of reaching for another dependency.
• Autonomy split by reversibility, not by size: filing is automatic because a misfile is one tap from undone; anything structural (merging two projects, renaming, archiving) can only ever be proposed.

Green CI did not mean it worked

The most useful lesson was a humbling one: for a while, “shipped” didn’t mean “works.” Every service’s own tests passed and CI was green, but none of that exercised the composed system, with the real services talking to each other, real models, and streaming over the network. So a feature could clear every check and still be broken end to end. The fix was as much cultural as technical: trust the running stack, not the mocks.

The sharpest recent one came from the models rather than the code. A prompt that had run fine for weeks started coming back refused: not a bad answer, a categorical decline of the whole task class, after a routine model change. Prompts aren’t code: they don’t break loudly, they don’t break deterministically, and the fix (a reframe, plus a fallback to a second model when a refusal is detected) is a thing you only build once you’ve been bitten.

The rest of them (the database default that looked empty but wasn’t, the tests that were green for the wrong reason, the cost check that turned out not to be an entitlement check) are collected, honestly, on what broke.

Live, paid, used every morning

It’s live, it’s paid, and I use it every day. Onboarding is three screens, the two tabs are real, search covers everything, billing runs, and the invisible half (backups with a rehearsed restore, staging, monitoring, GDPR mechanics) has been done and verified rather than promised.

What I’m working on now isn’t more surface. It’s the gap between a system that files your life correctly and one you actually open in the morning, which turns out to be a much harder problem than the filing was. Try it and tell me where it loses you.

Go deeper

Fittingly for a product that compiles wikis, the details have a small wiki of their own:

• How it got here: a year and a half, five rewrites, one lesson learned three times.
• The restructure: why five modes went internal, and what had to be added back.
• The surfaces: Today, Life, Activity, and the dock that owns capture.
• The agentic layer: moving decisions out of hand-written rules and into the model, without giving up the spine.
• The five modes: the internal response contract, and what each one still does.
• Architecture: the eleven services and how they talk.
• The self-compiling wiki: compression, a plain-Postgres queue, user-edits-win.
• Evals & cost control: golden suites, dollar caps, model routing.
• Privacy & security: invariants enforced by CI, not convention.
• Observability: including a zero-dependency Sentry client.
• What broke: the incidents and the lessons they left.
• Launch readiness: backups with a rehearsed restore, staging, GDPR mechanics.
• Everything it talks to: the full integration inventory.