Kleinvieh macht auch Mist — managing small things with Tana
Managing many small things with Tana, in contrast to developing large thoughts in Obsidian — and what we can learn for tools for thought
“Kleinvieh macht auch Mist” is a German expression, best translated as “small beasts still make manure”. Even the small things in life require our attention, and be that just so they stop hogging our attention.
“Causing issues” is frustratingly easy for matters of mental attention. Any “open loop” suffices, any mental item from questions to ideas to insights to some task that needs doing suffices, and they can clutter our mental space all too readily. Our brain doesn’t like to forget unfinished things too readily.
Our brains aren’t cluttered with whole essays. They get cluttered with two-sentence ideas. Thankfully, these ideas are also easier to forget, depending on their importance. But that throws potential away. Obliviousness can be a functional state of mind, but it betrays the possibility of exploiting some idea we once had, for no reason or because we just experienced something, at a more relevant moment in the future.
I have lots of little ideas all the time. I don’t want to decide their relevancy then and there. I can’t even know if they’ll actually be relevant; I lack that context. So I need to record them in a way that makes their future discovery possible. Tana has made this possible for me.
In the world of note-taking tools like Obsidian, we are used to thinking in larger documents, be they daily notes or Zettels, which are context-rich elaborations of thought. They are multiple sentences long and link in natural-text elaborations to other notes by a context title. They are great tools to manage large thoughts. But they fail at building these records of small thoughts in ways that feel comfortable.
My experiences
I have been using Obsidian for three years. Yet when I took notice of Tana, I found something in it that resonated with me. And when I got access, I found it slotted into a place in my personal thought management that previously did not have a satisfying solution that made the system more whole — instead of more of a memory hole.
Empirically, Tana has helped me store and retrieve things such as:
- small ideas of one or two sentences
- small questions of one or two sentences
- small things I learned ono day
- reminders without deadlines (I keep Todoist around for the things I can assign deadlines to. I will postpone explaining the Why here.)
but also some more “big” things that are at the same time curiously small:
- projects with their component tasks, goals, and priorities
- Standard procedures
- Lessons learned (inspired by this work by CortexFutura)
where I profit from being able to compare specific kinds of data these things share, but can be compared across different entities — for example, comparing the objectives and priorities across multiple projects or looking back on the multiple recommendations I learned on various lessons learned.
All these things share a common theme that constrasts with my Markdown notes: they have few natural language text, and what they have are bullet points. They are terse, highly structured, stateful data moreso than a Zettel in a slipbox, linked by ghostly red strings.
Managing small thoughts
They are the titular “little beasts” of this article, “making manure” as they exist, because like everything Actionable (and thoughts are actionables, since you can spend time and attention on working them), they can be excellent open loop gremlins that get stuck in our memory and clutter it up until we either forget them or process them to an external memory process, so that our brain lets go. (Reference “Getting Things Done”, by David Allen.). We have to clean up after ourselves just for mental flow.
We can get these thoughts out of our head. That is not that hard. For months, my daily notes had headers for my ideas, questions and things I learned that day. But the retrieval of this information was terrible. I had managed to make myself oblivious to these small thoughts more than I had a system to actually exploit them. There was no fast way to pull these paragraphs out of the notes they were embedded in. For that matter, just the fact that I had to put them under specific headings could represent friction — and I did not want to pollute my notes with tags, nor would that serve a good purpose — Obsidian applies tags to the whole note, not paragraph blocks.
How Tana works in my process gap
Tana jumped into that hole because Tana excels, by design, at the idea that a multitude of different “Things” will emerge from days, meetings, reviews or some other event context, which will then come up again in a variety of other, different contexts. In a recent video, Olav Sinde Kriken called this workflow “think, write, tag” — which has some similarity to the way Logseq lets you associate outliner blocks with other notes (which, in terms of function, could rather be called “natural language context frames”).
Where Tana beats out Logseq is with its fields — fields can label more than one subsequent node of further natural language thoughts, giving tabular retrieval to a whole set of little “thought-lets”. This is extremely valuable for building contrast between more structured entities in one comprehensive view that is pleasant to browse.
Tana has also created a much better surfacing workflow thanks to its search nodes’ very intuitive and powerful query design and use experience. The Tana query builder is not as powerful as Datalog, lacking variables and the related inductive searches, amongst other things — but it is much easier to craft some quite advanced queries and present them in various ways than with writing Datalog queries. That reduces that all-important friction when working to peruse, select and contrast different thoughts of a type from your history of records. Low friction is vitally important here.
To me, it seems that for these small thoughts, we tolerate much less friction than for large thoughts. They come into our minds and need to be handled with as little attention as they have words; similarly, we should not spend much time pulling them back up. My tolerance for finding a longer elaboration in Obsidian is higher, maybe because of the higher thought density that longer notes inherently have with their very contextual elaborations.
In this way Tana is perfect for absorbing little thoughts as they occur during whatever other work event (in my case, they mostly just go in my daily note, since I will switch to Tana rather than do all of my work there), then surface them for review in dense presentations of tables or lists when it is time for weekly or monthly reviews. The later are a joy to work with, since I can browse a dense buffet of thoughts instead of going from small note to small note.
What Tana is not
Tana is not a good tool for managing large thoughts, ironically. Tana wants to treat every bullet you create as a fundamental building block. While writing large notes is certainly possible, this will block up the fast search and referencing workflow, overloading your writing-as-you-go association mechanism with noise. Tana also has very few formatting tools available. Logseq gives us headings to style and work within pages and lets us bundle many blocks and their contained thoughts under a single page and its natural language title — which is easier to remember and whose overall namespace is easier to search (especially with the / namespace separators that Logseq also supports).
This becomes a problem as thoughts get large. Zettelkastens or slip boxes, whatever we may call them, are full of very thought-rich individual elaborations. We call the Zettels “atomic,” but that does not mean they are single sentences — even a very complex, particular context frame can be atomic due to the way it derives some thought, more so with the elaborations about why it relates to other frames. There is nothing wrong with the verbosity of these notes, on the contrary. But they require their own tooling and escape the idea that a single paragraph can encapsulate everything that needs to be said. In that way they break Tana’s assumptions.
What we can learn for tools for thought at large
Thoughts occur in many sizes, and a good tool handles all the sizes because they flow into each other.
Many of the thoughts we have will be small and fleeting, sometimes related to something we were working on or experiencing, but often also serendipitous. We will not have time to expand on them when they occur, nor do we necessarily need to do that then — their small size means they can be reviewed and expanded quickly in dedicated windows. But we need to be able to capture them to keep them from overloading our working memory, and we need to be able to swiftly surface them without friction during our review process.
This requires a powerful, high-resolution query engine, and such query engines are best supported by properties that help enrich each object for discrimination in the search. The individual thoughts as they were first entered are archived and almost irrelevant — the user mainly experiences them through resurfacing in search queries.
This provides the foundation for more complex elaborations. Either by starting from scratch or drawing upon other more formed elaborations, the human user begins to build upon the initial small thought into a larger thread of in-depth thinking, capturing it in text and relating it to other thoughts using (semantic) links, poly-hierarchy building tools, and transclusions. These growing thoughts of larger size become addressable under some (semi)-natural language title with indexing functions. Sometimes these may make use of prefixes or postfixes such as datetime strings (202309162243) or Zettelkasten indices (1a4d2b) or some other such tooling to add uniqueness to what may otherwise be a still non-unique title.
Through further iterations of relationship building and drawing upon other thoughts, large documents are created. As these elaborations grow, further internal layout tools become important. Headings and maps of content help navigate the linear stream of dependent thoughts. On the other side, large (and nested) maps of blocks can be used. Multimedia content enriches the articulation, colors and graphics help set visual highlights the brain latches upon. These help create a rich, multi-channel structure that can be used during the model building that occurs inside the brain, feeding on the presentation of the thought. That aims not just at other people. We can just as easily become strangers to our own previous thoughts. Writing to our future selves as our own audience, with clarity and organization in mind, is a very helpful behavior in thought and knowledge work.
And these complex thoughts in turn can inspire small, quick thoughts, “written into the margins” in some way (such as an indented bullet point under a paragraph of text), giving rise to a cyclical system of new thoughts building upon old thoughts.
What is more so potent about the strong discoverability of small thoughts is that we can defer working with them to moments when we are mentally opportune. This lets us empower Luhmann’s “I only work on what I want” philosophy with our tool; it becomes a holder of avenues we might revisit, searchable by the topics that interest us.
Tiago Forte has made the relatable observation that good ideas don’t occur at the moment when they are imminently relevant. The ideas most relevant then either occurred in moments of serendipity before the need was identified or are likely to occur in moments of inspiration afterward. The former lends itself to “writing for the future”, with an understanding that to exploit an idea, it doesn’t necessarily need to be developed right then and there — it just needs to be discoverable. In creating reliable storage and discoverability tools for small thoughts, this future exploitation potential can be established for ideas of all sizes and development.
Cross-relations to outliners and long-form writing
Reflecting on these functions and outcomes, we find crossovers with the idea of the nodal outliner such as Logseq, or Tana. These tools encourage terse, in-the-moment recording of anything that comes to mind, letting us strip out the formalities of relational semantics for a fast and malleable bullet structure. They are ideal for “brain-dumping”, making records as thoughts occur in the brain.
But nodal outliners have limitations when it comes to long text that communicates a complicated elaboration of thoughts. Here, we need increasingly more tools to style and visually locate our elaborations and meld them together with multimedia content. Large thoughts have elaborative dependencies on other ideas and assumptions and a certain perspective. In a “brain dump”, a lot of this context is implicit and has good recovery. But as thoughts age out of the user’s own brain and into the second brain alone, “writing to our future self” with the same clarity as if we were addressing a stranger becomes more and more relevant. Here, quick, terse bullets are not sufficient. We require long-form writing tools to prepare our essays to our future selves… and others as well.
The importance of communicating formed thoughts
Because it is not purely sufficient to have a tool that captures and creates a workspace for working our own thoughts. Sharing our thinking is a powerful way both to enrich our own thinking with other perspectives and feedback (recordable as terse bullets of “small thoughts” that can be rolled into the development pipeline) and to enrich the community overall. Since anyone will only ever have a limited perspective, the strongest power of serendipity lies in sharing thoughts.
To share thoughts, we must prepare them for communication, relating them to our associative thought records for a solid custody chain of how a communication came to be and where it drew from. And once we have shared our thoughts in a communication, we must likewise build the custody chain forward from that communication with other people’s reactions and the new ideas they create for us.
Communication can take many forms, from short microblogs to long essays, evergreen note environments, scripts for video productions, or other kinds. All of these forms, in their various lengths, should again find support in a good tool for thought to ensure that the association chain remains strong between individual thoughts. Different work environments are good primers, but different work environments should not be confused with data silos. The point is to create as much isolation as needed to reduce friction — not break isolation to reduce friction. The latter reduces the user’s freedom to constraint.
In review
For me, Tana has become the tool that I use to manage my small thoughts — things that I don’t write many sentences about but that still have some relevancy in some manner, some states that I need to keep track of, things that I want to extract from widespread mentions in various places and view as dense, information-rich aggregations. This capability shows an interesting contrast to what I can achieve in Obsidian, where I curate and develop larger, more complex assemblies of thoughts and their associations. Analyzing these workflows, their outcomes, and how they relate to the science of human cognition shows us the potential of combining both kinds of thought sizes in a common tool for thought design. This combination would achieve many great outcomes as a “side effect” of this initial merger reason, empowering capture, development and sharing all together and the cycle of thought creation from previous thoughts.
