How to keep MOC note evergreen?

In my opinion, MOC note plays an important role to provide the overall structure of some topic in the knowledge base.

But it’s hard to keep MOC note evergreen. As I add things to my knowledge base by adding new note or modifying existing notes, the MOC note also need to be maintained to keep evergreen. But updating MOC note right after modifying the knowledge base is not a good choice because it distracts me and breaks my train of thought.
Besides I have to remember the whole MOC structure so that I can recognize the effect of the changes to the MOC note, which is not consistent with the Zettelkasten note concept.

Update the MOC note periodically is also not easy for me because I don’t know how to filter the changes made after the last time I update the MOC note. Maybe I should use git diff and check for every changes in my knowledge base?

So what is the best practice to maintain evergreen MOC note?

Honestly it sounds like you are making a mistake in how you use MOCs. Maybe I’m misunderstanding you but it sounds like you are adding every note to a MOC. In that case you are effectively recreating tagging.

I don’t update a MOC with every note I add to my ZK system, only those that represent key entry points to various topics within that MOC or are notes that don’t really fit into any other note or MOC. (so there’s at least one link to the note from somewhere, and that link probably gets refactored to somewhere else as I add more notes on that topic over time)

If you are simply linking from the MOC to every individual note you are kind of recreating folder/tag hierarchical systems which is an anti pattern. You should focus on building up a dense network of interlinked notes at the “low” level among your evergreen notes then allow MOCs and similar index/outline notes float above them and point to the key entry points.

Then when you use the MOC you are following a link from the MOC to an entry point into a topic, and then once you are in that topic within an evergreen note you are navigating from note to note within that topic via inter-note links.

Analogy: You are playing an FPS game and the MOC is the top down map view, but once you click into an area you switch to the FPS view and navigate from room to room (note to note). Then periodically you switch back to the map view and jump somewhere else.

Adopting this approach is what brings fluidity to the process.


How are you structuring your MOC?

If you wanted to automatically group notes, could you use an embedded query block? That would autoupdate.


Also there are a couple of strategies for linking from a MOC when you want.

  1. Create note first, then update the MOC.
  2. Create link in MOC first, then create note from it.

The latter is trivially easy with the Note Refactor plugin. In fact you can start writing the entire note in the MOC and then highlight it and refactor it into its own evergreen note. The MOC will automatically be updated to contain the link to the new note for you.

Either way, you can’t get away from the need to update the MOC. This is why it’s not a good idea to try to update the MOC for every note you create since that can create a lot of unnecessary relationships between notes and make finding the actual relationships more difficult – too much noise, not enough signal.

1 Like

Love the analogy, this make the entire concept and how to use it very clear to me.