# memorize

> Create and connect atomic Zettelkasten notes in memory/

- Author: Darshil
- Repository: superinterface-labs/agent1
- Version: 20260209003526
- Stars: 0
- Forks: 0
- Last Updated: 2026-02-09
- Source: https://github.com/superinterface-labs/agent1
- Web: https://mule.run/skillshub/@@superinterface-labs/agent1~memorize:20260209003526

---

---
name: memorize
description: Create and connect atomic Zettelkasten notes in memory/
type: skill
status: active
version: 1
created: "2026-02-07"
tags:
  - type/skill
---
# memorize

> Create and connect atomic Zettelkasten notes in memory/.
>
> Part of [[.agents/SKILLS|Skills Directory]]. Used by: [[.agents/hierarchy/exec-memory|Memory]].

## When to Use

- A genuine, durable insight that will be valuable months from now
- A pattern noticed across multiple projects or sources
- A mental model, principle, or hard-won lesson
- Human explicitly says "remember this" or "note this down"

## When NOT to Use

- Operational observations ("triage is done", "profiles are complete") → daily log
- Task status updates or completion notes → ## Progress section of the task
- Trivial facts, news, or time-sensitive information → superprojects/scratchpad/
- Anything that will be stale in 2 weeks → superprojects/scratchpad/

## Inputs

| Input | Required | Description |
|-------|----------|-------------|
| concept | yes | The idea or insight to memorize |
| type | no | fleeting, literature, or permanent (default: fleeting) |
| memory_kind | no | episodic, semantic, or policy (default: episodic) |
| signal | yes | What triggered this write: failure, surprise, pattern, or decision. No trigger = don't create the note. |
| applies_to | no | Tags or short selectors for when this memory applies |
| confidence | no | 0.0-1.0 subjective confidence; low means "verify before using" |
| source | no | Where this came from (URL, note path, conversation) |
| connections | no | Related memory/ notes to link to |
| template | no | memory-note (default), source-note, or hypothesis-note |

## Process

0. **Check the trigger.** Name the signal (failure, surprise, pattern, decision). If you cannot identify a clear trigger, stop — do not create the note.
0.5. **Dedup check.** Search memory for existing notes with matching `applies_to` tags and similar content. If a note already exists covering this concept with higher confidence, skip writing. If it exists with lower confidence, update the existing note instead of creating a duplicate.
1. Distill to one atomic concept (if multiple concepts, create multiple notes)
2. Create note in `superinterface/knowledge/memory/` using [[_templates/memory-note]]
3. Name: `superinterface/knowledge/memory/YYYYMMDDHHMMSS-slug.md`
4. Set frontmatter: type, memory_kind, signal, applies_to, confidence, source, connections, tags
   - `source` is your event/evidence pointer:
     - If this came from doing work: `source: "[[superinterface/ops/tasks/...]]"` (the task is the episodic log; the memory is the distilled belief).
     - If this came from reading: `source: "<url>"` and/or `source: "[[superinterface/knowledge/memory/<source-note>]]"`.
5. Write the concept in your own words (even for literature notes, paraphrase)
5.5. Fill the `## Relates` section: at minimum, 1 is-a/supports/example-of (parent), 1 contradicts or second supports (sibling/contrast), 1 used-for/depends-on (application) — this is the Rule of 3
6. Link to 2+ existing memory/ notes (search for related concepts)
7. If no related notes exist yet, add tags for future discovery

## Outputs

- New atomic note in `superinterface/knowledge/memory/`
- Links to/from related notes (bidirectional via wiki-links)

## Conventions

- One concept per note — always
- Event log vs belief: step-by-step narratives live in task `## Progress` / daily logs. Memory notes are non-narrative and should link back via `source`.
- Fleeting notes are low-effort, quick captures. Don't overthink.
- Literature notes summarize a source. Always link to the source.
- Permanent notes are refined ideas. Worth spending time on.
- Dense linking > perfect prose. Connections matter more than polish.
- **High bar.** Ask: "Will this be useful in 6 months?" If no → don't memorize. Most task completions don't deserve a memory note. The daily log captures operational history.
- **Write cap.** 0-1 memory notes per task unless the human explicitly asks for more.
- **Narrow `applies_to`.** Use specific domain/task tags (e.g., `domain/research`, `task/code-review`). Broad tags like `general` cause false retrieval.
- **Tag hierarchy for `applies_to`:** Use hierarchical tags: `domain/research`, `domain/coding`, `domain/ops`, `domain/design`, `task/analysis`, `task/build`, `task/review`, `task/triage`, `project/<slug>`. These render as nested trees in Obsidian's tag pane.
- **Prefer policy notes.** If you've seen the same episodic pattern 2+ times, skip the episodic note and write a `memory_kind: policy` note directly.
- **Policy notes are structure notes.** Every policy note must include a `## Evidence` section linking to the episodic notes it distilled. This creates hub-and-spoke patterns in the graph.
- **Rule of 3 linking.** Every note must have at least 3 `[[wikilinks]]` under `## Relates`: one "parent" (is-a/supports/example-of), one "sibling or contrast" (contradicts or another supports), one "use" (used-for/depends-on). If you can't fill 3 slots, search harder. If no related notes exist yet, create a fleeting note for the missing concept and link to it.
- **Collision check.** Before creating any permanent note, search for existing notes that the new note might contradict. If found, link under `### contradicts` in both notes (bidirectional). Contradictions are the most valuable edges in the graph.
- **Source notes.** When processing a reading source, use [[_templates/source-note]]. Fill Reading Intent before highlights.
- **Hypothesis notes.** When a belief is testable, use [[_templates/hypothesis-note]]. Start confidence at 0.3.
- **Wikilink everything.** Every reference to another note must be a `[[wikilink]]`, never plain text. This is how the graph grows. If you mention a concept that doesn't have a note yet, link it anyway — Obsidian creates a placeholder. Filling that placeholder later is how the graph densifies.