Note-Taking for Output

I have 4,217 notes in Obsidian. I know this because I just checked. Of those, maybe 300 have been useful in the past year. The rest sit in folders I haven’t opened since I created them, carrying the faint promise that someday, somehow, they’ll be exactly what I need for a project I haven’t imagined yet.

They won’t. I know this. You probably know this about your own notes too.

The dirty secret of the note-taking world is that most note-taking produces nothing. Not “produces less than it could.” Literally nothing. The notes get taken. They never get used. They accumulate like sediment at the bottom of a river, and the person taking them feels productive the entire time.

This post is about why that happens and what to do instead. Not a note-taking system review. Not a tool comparison. A diagnosis of the fundamental problem and a practical approach to fixing it.

The collector’s fallacy, and why your brain loves it

There’s a term for the failure mode that traps most note-takers: the collector’s fallacy. Christian Tietze coined it on the Zettelkasten.de blog, and it describes something you’ll recognize immediately.

The collector’s fallacy is the belief that saving information is the same as learning it.

You read an interesting article about distributed systems. You highlight the key passages. You clip it to your note-taking app. You tag it “distributed-systems” and “architecture.” You feel a small hit of satisfaction, like you’ve accomplished something. You move on to the next article.

But here’s what actually happened: you moved information from one place (the internet) to another place (your notes). The information did not pass through your brain in any meaningful way. You don’t understand it better than you did before. You can’t explain it from memory. You can’t connect it to other things you know. You’ve done the knowledge equivalent of moving a book from one shelf to another and calling it reading.

The neuroscience explains why this feels productive even when it isn’t. When you save an article or highlight a passage, your brain registers a small dopamine hit. The act of collecting triggers the same reward pathway as the act of learning. Your brain can’t tell the difference between “I saved this” and “I know this.” So you keep collecting, because collecting feels like progress.

This is why people can have 10,000 notes and still struggle to write a single essay. The notes aren’t knowledge. They’re inventory. And inventory that never ships is just overhead.

The gap between collecting and processing

The collector’s fallacy points to a deeper structural problem. There’s a fundamental gap between two activities that most people treat as one:

Collecting is easy. You read, you highlight, you save. The information flows in one direction: from source to storage. No transformation happens. The note is a copy.

Processing is hard. You read your highlights, you close the source material, and you try to restate the idea in your own words. You ask: “How does this connect to what I already know? What does this contradict? What does this make possible that wasn’t possible before?” The information gets compressed, transformed, and integrated. The note is an original thought triggered by someone else’s.

Most note-taking systems are optimized for collecting. They make it trivially easy to clip, save, highlight, and tag. And because collecting feels productive, people do more of it. They build elaborate tagging taxonomies. They create intricate folder structures. They write custom CSS for their note-taking app. All of this is collecting behavior dressed up as organization.

The processing step, the step that actually produces understanding, requires something most note-takers avoid: sitting with an idea and doing the uncomfortable work of thinking about it until you can say it in your own words.

Three systems that take processing seriously

The note-taking world has produced three systems that explicitly address the output gap. They’re different in mechanics but share a common insight: notes are not the product. Notes are raw material for producing something else.

Zettelkasten: the original output machine

Niklas Luhmann was a German sociologist who published 70 books and over 400 scholarly articles. He credited his productivity to a box of index cards.

Not a filing cabinet. Not an archive. A thinking partner.

Luhmann’s Zettelkasten (German for “slip box”) contained roughly 90,000 index cards when he died in 1998. Each card contained a single idea, written in his own words, with a unique identifier and explicit links to related cards. The key word there is “his own words.” Luhmann didn’t copy quotes from books. He processed what he read and reformulated it as a standalone thought.

The system had a few structural principles that made it work:

One idea per card. Not one topic. One idea. A card that says “Three things about distributed consensus” is a topic card. A card that says “Paxos requires a majority quorum because the alternative (unanimous agreement) makes the system unable to tolerate any failures” is an idea card. The difference matters because idea cards can be linked in unexpected combinations. Topic cards can only be filed.

Explicit links, not folders. Luhmann didn’t organize cards by topic. He linked them by relationship. Card 21/3g might link to card 54/2a because they share an argument structure, even though one is about sociology and the other is about epistemology. This cross-pollination is what generated new ideas. If he’d filed them in separate topic folders, the connection would never have been made.

The system as a conversation partner. In his 1981 paper “Communicating with Slip Boxes,” Luhmann described the Zettelkasten as an independent thought partner capable of surprising him. He would follow link chains through the box and encounter juxtapositions he hadn’t planned. The system generated ideas that neither he nor any individual card contained. The ideas emerged from the connections.

Sonke Ahrens popularized Luhmann’s method in his 2017 book How to Take Smart Notes. Ahrens’ key contribution was making the system actionable for non-academics. He classified notes into three types:

The crucial step is the transition from literature notes to permanent notes. That’s where the processing happens. That’s where you go from “this person said X” to “X means Y for my understanding of Z.” Without that step, you have a well-organized archive of other people’s thoughts. With it, you have a growing network of your own.

Progressive summarization: Tiago Forte’s compression layers

Tiago Forte came at the same problem from a different angle. His system, progressive summarization, is designed for people who don’t want to build a Zettelkasten but still want their notes to produce output.

The core insight: most notes are consumed in one of two modes. Either you’re looking at a note right after you captured it (when the context is fresh and you don’t need much help), or you’re looking at it months later (when you’ve forgotten everything and need to quickly figure out if this note is relevant to what you’re working on now).

Progressive summarization addresses the second scenario by creating layers of compression:

The trick is that you don’t do all layers at once. Layer 0 happens when you save. Layer 1 happens when you first review. Layers 2 and 3 happen only when you return to the note for a specific project. Layer 4 is the actual writing.

This is progressive because you invest more effort only in notes that prove their value over time. Most notes never get past Layer 1. That’s fine. The system assumes that most of what you capture won’t be useful, and it optimizes for quickly identifying the minority that is.

The criticism of Forte’s system is that it can still enable collecting behavior. If you never reach Layers 3 and 4, you’ve just built a more elaborately highlighted archive. But the system at least names the problem (most notes never produce output) and provides a mechanism for gradually promoting notes toward output as they prove relevant.

Andy Matuschak’s evergreen notes: thinking in public

Andy Matuschak, a former Apple engineer and Khan Academy researcher, takes the most radical position of the three. His central claim: “Better note-taking misses the point; what matters is better thinking.”

Matuschak’s evergreen notes are designed to evolve and accumulate over time, across projects. Each note is:

Atomic. One idea, fully developed. Not a collection of bullet points about a topic.

Concept-oriented. Titled with a claim, not a topic. Not “Machine learning” but “Machine learning models are only as good as their training data distribution.” The title itself is an assertion you can agree or disagree with.

Densely linked. Every note connects to other notes through explicit links, creating a web of ideas that can be navigated in unexpected ways.

Written for your future self. Each note should be comprehensible without any surrounding context. If you read it cold, five years from now, it should make sense on its own.

Matuschak’s most cutting observation: “People who write extensively about note-writing rarely have a serious context of use.” In other words, many people in the PKM community spend more time optimizing their note-taking system than actually using it to produce work. The system becomes the product instead of a tool for producing something else.

This is the trap. And Matuschak is right to name it.

The output gap

Here’s the problem that all three systems are trying to solve, stated plainly.

Most people who take notes are operating in a pipeline that looks like this:

Read → Capture → Store → (nothing)

The pipeline has a hole at the end. Information goes in, gets organized, and then sits there. The organization feels like work, but it produces no artifact that anyone (including the note-taker) can use.

An output-oriented pipeline looks like this:

Read → Capture → Process → Connect → Create

The difference is two additional steps: process (transform the raw capture into your own understanding) and connect (link it to your existing knowledge and current projects). These steps are where the actual value is created, and they’re the steps that most note-taking systems make easy to skip.

The output gap is the distance between what your notes contain and what you’ve produced from them. For most knowledge workers, this gap is enormous. They have hundreds or thousands of notes and a handful of blog posts, design docs, or presentations to show for it.

Closing the gap requires a shift in mindset. Notes are not a destination. Notes are a waypoint on the path to something else. The “something else” is the output: an article, a design document, a presentation, a decision, a piece of software, a conversation where you actually know what you’re talking about.

Why most note-taking tools make this worse

The note-taking tool market is enormous and growing. Obsidian, Notion, Logseq, Roam Research, Apple Notes, Capacities, Reflect, Mem, Tana. I’ve used most of them. Here’s my honest assessment of the landscape.

Every tool is optimized for capture. The onboarding flow for every note-taking app is designed to show you how fast you can get information in. Quick capture. Web clipping. Voice memos. Mobile sync. Import from Evernote. The message is clear: the value proposition is putting things in the box.

Almost no tool is optimized for output. Where is the “create from notes” workflow? Where is the feature that shows you which notes have never been used in a project? Where is the dashboard that tracks your capture-to-output ratio? These features don’t exist because they’d reveal an uncomfortable truth: most people’s notes are graveyards.

The tool comparison landscape looks something like this:

Notice the pattern. Capture ranges from good to excellent. Output ranges from manual to weak. The tools are designed for the first half of the pipeline, not the second.

This isn’t because tool makers are stupid. It’s because capture is where the market is. People buy note-taking apps to capture things. They don’t buy note-taking apps to write articles. By the time the output step happens (if it happens), the tool has already been purchased and the tool maker has been paid.

A system that actually produces things

After years of experimentation, here’s the system I use. It’s not perfect. It’s not novel. It’s a hybrid of ideas from Zettelkasten, progressive summarization, and Matuschak’s evergreen notes, adapted for someone who writes code and prose as their primary outputs.

The inbox (capture, don’t organize)

Everything goes into one place: a daily note in Obsidian. Articles, thoughts, code snippets, meeting notes, random ideas. No folders. No tags at capture time. No organization whatsoever.

The inbox is explicitly temporary. Its job is to hold things until I process them. If I’m reading an article and want to save a key insight, I paste it into today’s daily note with a one-line comment about why I found it interesting. That’s it. Total time: 30 seconds.

The critical principle: capture should be frictionless. If it takes more than a minute, you’ll stop doing it. And capture is the least important step, so it deserves the least effort.

The processing session (weekly, 60 minutes)

Every Sunday morning, I review the week’s daily notes. For each captured item, I ask one question: “Can I use this for something I’m currently working on or planning?”

If yes, I process it. Processing means:

1. Close the source material
2. Write the idea in my own words as a standalone note
3. Title the note with a claim, not a topic (“Eventual consistency requires explicit conflict resolution” not “Distributed systems notes”)
4. Link it to at least two existing notes
5. Tag it with the project it’s relevant to

If no, I leave it in the daily note. I don’t delete it. I don’t archive it. I don’t create a permanent note for it. I just leave it alone. If it’s important, it’ll come back. If it doesn’t come back, it wasn’t important.

This is the key discipline. Most note-takers process everything. They turn every captured item into a permanent note, because it might be useful someday. That “might” is the collector’s fallacy in disguise. Processing only what’s immediately relevant means my permanent notes are small in number but high in utility.

The project folder (output-oriented organization)

My notes aren’t organized by topic. They’re organized by project. A project is anything with a concrete output: a blog post, a design doc, a presentation, a codebase, a decision.

Each project folder has a single file at the top called _plan.md that answers three questions:

## What am I making?
A blog post about why most note-taking fails to produce output.

## What do I still need to figure out?
- How to present the collector's fallacy without sounding preachy
- Whether to include tool comparisons
- How to structure the "what to do instead" section

## What notes are relevant?
- [[Eventual consistency requires explicit conflict resolution]]
- [[Progressive summarization works because most notes are waste]]
- [[Zettelkasten produces output because it forces processing]]

When I sit down to write, I don’t start from scratch. I start from the project plan and the linked notes. The notes have already been processed into my own words. The plan tells me what’s missing. The writing session is assembly, not generation from nothing.

The archive (graceful decay)

Notes that aren’t linked to any project for six months get moved to an archive folder. I don’t delete them. I don’t review them. I just move them out of the way so they don’t clutter my active workspace.

About once a quarter, I glance through the archive out of curiosity. Occasionally I find something I want to pull back. Usually I don’t. And that’s fine. The archive is where notes go to quietly retire after a career of not being useful.

The metrics that matter

Most note-taking advice focuses on input metrics: how many notes you have, how many links, how many tags, how many daily pages. These metrics are vanity metrics. They measure collecting, not producing.

Here are the metrics I actually track:

The capture-to-output ratio is the one I care about most. It measures how many notes I have to capture to produce one output. Lower is better. A ratio of 100:1 means I’m hoarding. A ratio of 5:1 means my capture is well-calibrated and my processing pipeline is working.

When I first started tracking this, my ratio was north of 200:1. I had thousands of notes and was publishing maybe once a month. After switching to the project-oriented system, it dropped to around 8:1. Not because I’m capturing less (I’m capturing about the same), but because I’m processing more selectively and linking everything to concrete projects.

The uncomfortable math

Here’s a calculation that changed how I think about note-taking.

Assume you spend 15 minutes per day taking notes. That’s about 90 hours per year. If those notes never produce any output, that’s 90 hours of pure overhead. If you value your time at $50/hour (conservative for a knowledge worker), that’s $4,500 per year spent on an activity that produces nothing.

Now assume you spend the same 90 hours, but 30 of those hours go to processing and output instead of capturing and organizing. You produce 24 substantial outputs per year (two per month). Each output might be a blog post that builds your reputation, a design doc that saves your team a week of work, a presentation that lands a client, or a decision memo that prevents a bad strategy.

Same time investment. Dramatically different return. The variable isn’t how much you capture. It’s how much you process and ship.

The collector’s trap, revisited

I want to come back to the collector’s fallacy, because I think there’s a version of it that even experienced note-takers fall into.

The sophisticated collector’s fallacy isn’t about hoarding articles you never read. It’s about building an elaborate knowledge management system that becomes an end in itself. Customizing your Obsidian theme. Writing plugins for your note-taking app. Debating Zettelkasten vs. PARA in online forums. Reading books about note-taking. Creating templates for note types.

All of this activity feels productive because it’s related to knowledge work. But it’s meta-work, not work. It’s building the factory instead of building the product. And the factory never ships anything to customers.

Matuschak’s observation applies perfectly here: “People who write extensively about note-writing rarely have a serious context of use.” The most prolific note-taking bloggers are often the people who produce the least outside of note-taking content. Their output is about the system, not from the system.

The test I use on myself: when was the last time a specific note directly contributed to something I published, shipped, or decided? If I can’t point to a concrete example from the last month, my system is drifting toward the collector’s trap.

What “good enough” actually looks like

The note-taking community tends toward perfectionism. People want the perfect system, the perfect tool, the perfect workflow. They migrate from app to app looking for the one that will finally make everything click.

The truth is simpler and less satisfying. A good-enough note-taking system has three properties:

1. Capture is fast. Under 60 seconds from “I want to save this” to “it’s saved.”
2. Processing is regular. You have a weekly session where you transform captures into your own thoughts.
3. Output is the goal. Every processing decision is made in service of producing something concrete.

That’s it. Everything else is optimization at the margins. The tool doesn’t matter much. The folder structure doesn’t matter much. The tagging taxonomy really doesn’t matter. What matters is whether you sit down every week, process what you’ve captured, and use it to make something.

A plain text file with a weekly review habit will outperform the most elaborate Obsidian setup used only for capture. Every time. Because the bottleneck was never the tool. The bottleneck is the processing step that most people skip.

The note that writes itself

There’s a feeling I get when the system is working well that’s hard to describe. I sit down to write, open my project plan, look at the linked notes, and the outline almost writes itself. Not because the notes are brilliantly organized. Because they’ve already been processed into my own thinking. They’re not quotes from other people. They’re my own ideas, triggered by other people’s ideas, written in my own words.

When I pull three or four of these notes together, they interact. One note complicates another. A third resolves the tension. A fourth adds a dimension I hadn’t considered. The essay emerges from the notes like a picture emerging from puzzle pieces, except I cut the pieces myself during processing sessions over the preceding weeks.

That’s the promise of output-oriented note-taking. Not a perfect archive. Not a second brain. Not a digital garden. A workshop where raw materials gradually become finished products. The materials aren’t impressive on their own. The finished products are. And the system exists for the products, not for itself.

Stop collecting. Start processing. Ship something.