Memos Learn, Too

Last time we built the loop where records teach templates. Run a task once and something usually shifts — you grab one more material, you drop a step — and when you want, you fold that difference back into the template.

This time we widened the same loop to cover memos. And moving it over, we found the loop fit more cleanly here, precisely because a memo is simpler than a task.

A memo is simpler

In Fecit, a memo is parallel to a task — there’s a template, and records spawned from it. But a memo holds essentially one thing: a body of text. No preparation, no steps, no expected duration.

And crucially, a memo has no “completed.” A task has a lifecycle — you start it, you finish it — but a memo is just written. It’s capture, not achievement.

At first this looked like an obstacle. For tasks, we used “a completed record is a settled statement” as the signal for the drift comparison. A memo has no such signal at all.

So on-demand fit even better

But the decision to make the fold-back something you call for, not automatic paid off here.

For tasks, we once generated suggestions automatically on completion, then switched to manual because suggestions you never look at pile up as garbage. A memo has no “completion” to hang an auto-trigger on in the first place. So manual was the only natural path — there wasn’t even an auto-behavior to remove.

After you edit a memo’s body, you open its menu and tap Generate suggestions — and only then does Fecit compare it against its origin template and pin the changed text beside the template. The model we refined on tasks dropped straight into the simpler memo.

We didn’t rewrite a line of the hard code

The part I like most is on the engineering side.

A memo’s body and a task’s plan (description) use the same serialization format. They’re edited with the same rich-text editor, with the same line structure (bullets, checks, headings). Which means the line-level diff and patch algorithm we carefully debugged could be reused verbatim — only the field name changes.

So we pulled that algorithm out into pure functions that tasks and memos share. The only new code on the memo side is thin wiring: which collection to store in, which screen to surface on. The hard logic — where bugs live — sits in one place, and both sides point at it.

The principle is simple: share the bug-prone core, keep the per-entity glue thin. The already-working task code was left almost untouched, and memos started life on top of a proven algorithm.

Even quick notes become a blueprint

Memos are usually thought of as “something you jot down fast.” But write the same kind of memo over and over — meeting notes, reading notes, a journal — and a better shape of your own grows there too.

Now that shape can be fed back. A better sentence learned in one memo no longer dies inside it; next time, you start from a slightly more refined template.

Not just achievement, but capture too — the more you live, the more the blueprint comes to resemble you.