Every morning at 6, I had a job trying to answer a surprisingly difficult question: what did I care about this week?
It could scan recent notes, look for something interesting, assign it to a section of my blog, and turn it into a draft. On paper, this sounded efficient. Let the computer reconstruct my intent while I sleep.
In practice, it was asking the least informed moment to make the most important editorial decision.
By 6 AM, the original conversation had lost its tone. A technical rabbit hole, a passing joke, a strong opinion, and a private detail all looked like text in a file. The job could retrieve what happened, but retrieval was not the same as knowing what mattered.
So I changed one small thing: when something feels blog-worthy, I tag it in the daily note immediately.
The tag is one line: a likely lane, what happened, and the hook. That tiny act of curation turned out to be more valuable than a much more elaborate search pipeline.
Archives answer “what happened?”
Raw conversation history is an archive. It is useful evidence, and I do not want to throw it away. If I need to verify a command, recover an exact decision, or revisit the sequence of a debugging session, the raw record is the right place to look.
But an archive has terrible manners. It preserves everything with equal confidence.
Tool output sits beside jokes. Temporary guesses sit beside final decisions. Private context sits beside public-safe ideas. A five-minute detour may occupy more text than the one sentence that changed my mind.
Searching that archive can retrieve a semantically similar passage. It cannot guarantee that the passage was important, current, safe to publish, or representative of what I actually concluded.
That is not a criticism of semantic search. It is a category error. Search ranks matches. Editorial judgment decides meaning.
Memory is an edited product
The more useful model for my setup is a two-stage pipeline.
During the day, while the context is still alive, I distill the moment into a small durable note. Later, the morning job consolidates those notes, checks for duplicates, researches facts, and drafts from the best candidates.
OpenAI's current context-engineering guide for personalization describes a similar pattern: capture dynamic insights during active turns, inject only relevant state into later sessions, consolidate notes into denser memory, and prune stale or low-signal material. The interesting part is that memory is not treated as a database that grows forever. It is maintained state.
That word—maintained—does a lot of work.
A useful memory system decides what enters, what gets updated, what conflicts, and what should disappear. If I save everything and retrieve the nearest chunk later, I have built searchable storage. I have not necessarily built memory.
My one-line seed is deliberately modest. It does not contain the article. It preserves the editorial signal that is hardest to reconstruct later:
- this moment mattered;
- this is the angle;
- this is roughly where it belongs.
Facts can be researched tomorrow. The feeling that made the topic worth writing about is much harder to regenerate.
Curation is also a privacy boundary
This matters even more because the output is public.
My conversations contain material that should never become a blog post: health, relationships, employment details, other people's information, and plenty of ordinary life that simply does not belong on a website. A morning job searching raw transcripts has to rediscover that boundary every day.
A curated daily note moves the first privacy decision closer to the source. I can preserve the public-safe lesson without carrying every private detail into the drafting stage.
That does not eliminate the final privacy check. It gives the check a cleaner input.
The difference is subtle but important. Redaction starts with a pile of information and removes what should not escape. Curation starts with judgment and records only what deserves to travel forward. For a public-writing pipeline, I would rather make omission the default.
Deterministic beats clever when the set is small
Before this change, I was tempted by more indexing, more embeddings, and broader transcript access. The eventual solution was a Markdown header:
## Blog seeds
- tech — what happened — the hook
The morning job can find that with a plain text search. No embedding service. No fuzzy ranking. No attempt to infer whether an hour of conversation contained one idea I cared about.
This does not mean plain text is better than vector search in general. It means a known marker is better than inference when I can create the marker at the moment of certainty.
If there are no tags, the job can still scan the full daily notes as a fallback. The archive remains available. The clever tools become recovery paths instead of the foundation.
That ordering feels healthier: explicit intent first, curated context second, raw reconstruction last.
The cost is attention, not storage
The obvious weakness is that I have to notice the moment and tag it. I will miss things. Any curated system reflects the limits and biases of the curator.
But the cost is tiny: one sentence written while the context is fresh. The alternative asks a later process to spend far more compute reconstructing a weaker version of the same judgment. Worse, a polished reconstruction can look authoritative even when it chose the wrong hook.
I would rather have an honest empty lane than a confident article about something I never cared about.
This small change reshaped how I think about agent memory. The goal is not perfect recall. Perfect recall is an archive's job. The goal is to carry the right meaning across time with as little distortion as possible.
When context is fresh, deciding what matters takes seconds. By morning, recovering that same decision can take an entire pipeline—and still get it wrong.
