A keyboard-driven graph-based capture workflow

TL;DR: I’m contemplating the idea of a non-linear note taking workflow that involves the following general steps:

  1. Create a sandbox to hold the notes for whatever you want to capture
  2. Start from an anchor note
  3. Use fast and intuitive keybindings to create new notes in relation to the anchor notes
  4. Briefly navigate to child notes and write short notes (like annotating text on an edge or changing color of a node) and easily return to anchor note
  5. Change anchor note when the focus changes
  6. Optionally bring main vault notes into the sandbox as well
  7. After the meeting, save the sandboxed notes according to sessions. Keep a record so parts of it can be merged into the main vault or discarded.

Quality of life improvements to make this process even better:

  1. A minimap of the notes in the current session, so you know where you are and where your current anchor is
  2. A set of template nodes, tags, and the actions for them, e.g. you like to use color to annotate the type of entities being captured
  3. A training game where you are given a few target graph shape and text, and you train yourself to be fast at taking these notes

At the beginning of my note-taking experiments, I thought it was just the speed at which I took the notes. But even if I try to reuse my vim keybindings from my programming work, it still doesn’t quite work out. I realized that it’s the difference between how I processed information. I think in a relational way, and yet I was trying to put it down in a linear manner. This introduced extra mental overhead, and constantly broke my flow when capturing contents. So why not just draw a mindmap in real time?

And this makes sense: Many people use mind map to organize ideas. But why not directly create them when capturing? Imagine some notes that you might take when listening to a podcast. The contents that people talk about are usually non-linear and go back and forth between a few key points. Typing plain words in this case is usually unsatisfactory for me since it’s slow and doesn’t follow the way my brain actually processes these information - you will usually be busy writing down the details and miss the most important things, the relationships between ideas / objects.

But here we are - using obsidian and enjoying (hopefully) the great spontaneity provided by organizing notes with graphs. Obsidian has proved that taking non-linear notes efficiently is not only possible but also desirable when we have the right tools for it. The visualization, the ease of linking with brackets, and the various quality of life features such as search and tags make what wasn’t possible with just notebooks now possible.

Now the big question - why don’t we take graph-based notes when capturing contents again? It’s probably because we don’t have an adequate tool. One the one hand, we can simply draw the mindmap; and on the other hand, there really isn’t a way to draw things fast on a computer - drawing graphs is an inherently analog action, and it’s hard to just digitize it.

But if we think hard enough about it, we see that the action of physically drawing the mindmaps has a lot of redundancies - in theory, the most compact amount of information that you need is just the connections and the nodes. You don’t want your own brain to think about the irrelevant details like “where do I put this bubble”, and “how do I route these bubbles so they won’t block the other thing” - you should offload it to some other tools designed to do it, like obsidian!

That concludes the motivation section of this post - I only have some very fuzzy idea of how the detailed implementations are going to be, so I can’t really elaborate more on those. I listed my preliminary thoughts in the TL;DR section, and I would like to hear what you think about these ideas!