An agent makes a mistake. You correct it. The correction lives in the conversation context — visible now, gone when the session ends.
You have two choices at that moment: write it down or encode it.
Writing it down produces a note, a comment, a memory entry. It survives if you remember to reload it, if the memory system is working, if the next session loads the right context. Memory is best-effort. It degrades.
Encoding it produces a constraint inside a skill. A never_say entry. A pre-flight check. A guardrail in the skill’s own instructions. It doesn’t need to be remembered — it executes every time the skill runs.
Memory is context. A skill is infrastructure.
The difference compounds. A correction encoded into a skill propagates to every agent that loads it, across every tool, every session. A correction written in a memory entry is one context window away from being lost.
When an agent leaked a Slack channel ID by bypassing a scrub step, the fix wasn’t a memory: “remember to scrub before sharing.” The fix was adding a guardrail to the posting skill’s instructions — a rule that makes bypassing the scrub gate structurally impossible, not just inadvisable.
The failure mode is now prevented, not remembered.
The practical question after every correction is: does this go in memory, or does it go in a skill? If it’s something you’d be frustrated to re-explain in three sessions, it belongs in a skill. Memory is for context that changes. Skills are for decisions that don’t.
Memories fade. Skills persist. The architecture of your agent infrastructure is the sum of which corrections you encoded and which ones you left in context.