Filling slots instead of writing text
What memory hands back to you matters as much as what it keeps. For several weeks, a card came back as text the screen had to interpret in order to display it properly. We reversed the relationship: the screen declares a template with typed slots, and memory comes to fill them. Nothing left to guess at reading time.
Text that had to be guessed at
At first, a memo card arrived as text, with its formatting written in raw characters: hashes for headings, stars around bold words, dashes for bullets. Displayed as-is, that gave a block punctuated with symbols, exactly what you don't want to read on a phone propped up on a kitchen counter.
First reflex, write a small reader for that formatting. Deliberately limited: two heading levels, bold, bullets, numbered lists, blank lines as breathing room. No external dependency, because the surface to cover was narrow and stable, and because a homemade reader let us style every element to the product's palette exactly rather than inherit a generic rendering.
We added one useful gesture to it. Under a heading that mentioned ingredients, utensils, equipment, supplies or shopping, bullets no longer appeared as dots but as tickable boxes. You could cross them off as you went, while cooking or shopping.
The reversal
It worked, and it stayed fragile. Recognizing a checklist from a word spotted in a heading is guesswork that succeeds often and fails without warning. A slightly different wording, a singular where a plural was expected, a card dictated in another language, and the tickable box went back to being an inert bullet. The behavior depended on how the sentence happened to be phrased, which is the very definition of behavior you cannot promise.
The real problem wasn't the recognition, it was the direction of the relationship. Memory wrote a document, the screen tried to understand it. We swapped the roles: the screen declares a template, with named and typed slots, and memory fills the ones that make sense for this card. There is nothing left to guess, because there is nothing left implicit.
Declared sections, not recognized headings
In that template, everything is optional. A kind of illustration, a title, a few short labels such as a duration, a number of servings or a difficulty, a source quote, a memory note recalling why this card exists and when it came to be, then a series of sections. Each section carries its type: checklist, numbered steps, bullets, paragraph. A shopping list has only one, a recipe lines up several, meeting notes mix both.
Two very concrete consequences. The screen can show a single progress bar covering every ingredient group at once, because it knows which ones are checklists, something impossible to do reliably when all you do is read text. And a card's thumbnail in the list can reuse the illustration of the card itself, since the kind is declared rather than inferred from an expression found in the content.
The template breaks nothing when it arrives empty. When no usable slot is filled, the display falls back to the text reader from the first version. The new path is an improvement, not a condition to be met.
Reading your recipe is not auditing a memory
One access detail changed in the same movement. Tapping a card in the list used to open the memory inspection view: its labels, its mention count, its memory tier, its links to other memories, its silence and delete actions. That is the right tool for examining a neural memory node. It is the wrong one when you simply want to read your recipe or make progress through your lists and checklists.
Both views still coexist, but they are no longer on the same level. The card opens with a single tap. Inspection stays reachable from the settings, one notch further away, and that notch is deliberate.
What wasn't settled yet
In that version, ticked boxes didn't survive closing the card. The display had become correct, the state had not yet: ticking an ingredient was still a visual gesture, not a memory. Making that state persistent came afterwards, and that is what turned the checklist into a living object rather than mere layout.
The principle set down that day, however, hasn't moved since: what the screen shows must be declared, never reconstructed. It is the same requirement that, the day before, had moved settings off the phone and into memory.