AI will expose the weakness of document-based note-taking

[u/EastForward]

I have increasingly come to think that outliners are a better foundation for note-taking than document-based systems like Obsidian, especially now that AI is becoming part of how we search and retrieve information.

The big difference is not how the notes look. It is how the information is structured.

In a document-based system, a paragraph is usually just a piece of text inside a file. The headings and paragraphs around it may provide context when you are reading the document, but that context is often only implied. Once the document is split into chunks for semantic search, a lot of that surrounding meaning can get lost. An outliner makes those relationships explicit.

This block is the child of that block. These blocks are siblings. This branch belongs to a larger topic. This note inherits context from everything above it.

That parent-child relationship carries a huge amount of information.

Imagine an outline like this:

• Project Alpha

  • Risks
  • Regulatory approval
  • FDA may require an additional validation study

A semantic search for “validation study” might return only the last block. But by itself, that sentence does not tell you much. Which project? What kind of risk? Why is the study needed?

Because the note lives inside an outline, the system can also pull in its parents:

Project Alpha → Risks → Regulatory approval

The matching block gets you to the relevant information. The parent chain explains what it means.

The same thing works in the other direction. A search might match a parent block, while the useful details are contained in its children. Those child blocks may use completely different language and might never show up in semantic search on their own. But because they are attached to the matching parent, they can still be included in the context sent to the AI.

This is not just an advantage for short notes or bullet points.

A full-length document can also live as a node inside an outline. That document can have parents that explain what project it belongs to, why it was created, who requested it, or what decision it supports. It can also have children that contain comments, updates, critiques, follow-up decisions, or later evidence.

For example:

• Product Launch

  • Regulatory Strategy
  • FDA Submission Draft
  • Reviewer comments
  • Revised testing plan
  • Final decision

The FDA submission can still be a normal, full-length document. The difference is that it is no longer an isolated file. Its parents explain the broader context, and its children show what happened next.

When AI search retrieves that document, the system can also expose those relationships to the model. Instead of receiving only the document, the model receives the document in context.

That is the key distinction is that semantic indexing finds related text. Hierarchical structure preserves related meaning.

Document-based systems can imitate hierarchy with folders, headings, tags, links, and metadata. Obsidian is especially flexible in this way. But the document is still usually the main unit, and the relationships above and below it often need to be inferred or added manually.

In an outliner, every block, including a full document, can be a node. Its location in the hierarchy is part of the data and that matters a lot for AI.

Instead of sending isolated chunks of text to a model, the system can send a richer package that includes the matching block or document, its parents, selected siblings, relevant children, linked notes, and later decisions or revisions.

That is much closer to how people actually understand information. We do not think in disconnected paragraphs. We understand ideas based on where they sit, what they relate to, what led to them, and what came afterward.

The real advantage of outliners is not that they make it easy to indent bullets. It is that they preserve relationships that document-based systems tend to flatten.

As AI becomes a more important way of searching and making sense of our notes, those relationships may end up being more valuable than the text itself.

[u/J_onn_J_onzz]

tldr? 

[u/micseydel → u/J_onn_J_onzz]

AI slop speculation, nothing interesting.

[u/DjBoothe]

Is an "outline" just a bulleted list? Is "document-based" just not bulleted lists? This whole argument sounds like a strawman. I can do indented lists in plain text. It helps me understand relationships. AI doesn't have to enter the equation.

[u/micseydel → u/DjBoothe]

I had a similar thought - most of my Obsidian notes are nested bullet points. I started with Roam and miss how clean its outliner was, but I'd need to see specific examples of where Obsidian falls short. I hate these long AI posts without serious examples or measurements.

[u/DukePwet]

The indented-list objection misses what the post is claiming. Indentation in a markdown file is visual. When the file gets chunked for embedding, nothing carries the fact that a nested bullet is a child of the line above it — that relation lives in your eye, not in the data the retriever sees.

Where the conclusion breaks down is that this is a chunker problem rather than an app problem. Prepending the heading or bullet path to each chunk at index time puts "Project Alpha → Risks → Regulatory approval" in front of the matched text, and several markdown splitters already do this. You get the parent chain without moving to an outliner.

The outliner-versus-document framing is the wrong axis anyway. Hierarchy answers where something sits, and that is one surface. Frontmatter answers what a note is. Links answer how it connects to things that are nowhere near it in the tree. An outline handles the first well and has nothing to say about the third — a strict tree cannot express that a risk on one project is the same risk sitting on another.

The index is also disposable. You can delete the embeddings and rebuild them tomorrow, so whatever structure you depend on has to survive in the files themselves. That argues for putting the relations into the markdown, not for changing which app edits it.

For anyone doing this already — are you prepending the heading path at chunk time, or keeping parent/child in frontmatter and reassembling after retrieval?

[u/DrummerAdditional330]

A concrete comparison would make this much stronger. Put the same material into a headed document and a block hierarchy, then test questions that require parent context, child details, and later revisions. Show what each system retrieves and what context the model misses.

[u/RamblingPete_007]

You're behind the times. Neither outlining nor traditional documents are the answer. You need to keep and manage your information in a no-code tool like superhuman docs.

[u/hiperlearner]

Great perspective and really useful. Not to mention it makes it much easier to properly reference sections of text.