Appearance
Stop Managing Notes. Start Developing Concepts.
The unit of thinking was never the document. Paper got that right; software mostly forgot.
Your note-taking pipeline is perfect. Nothing compounds.
Your note-capture setup is probably excellent: highlights sync from your e-reader, a hotkey drops a thought into an inbox in two seconds, web clipper, share sheet, voice memo, meeting transcript. Everything you read ends up somewhere searchable, tagged, backed up, and on every device you own.
Now the harder question. In the last six months, how many ideas of your own came out of it?
Not notes retrieved. Not summaries generated. Ideas — the kind where two things you had been carrying around separately turn out to be the same thing, or exact opposites, and you have to go write something to work out which.
For most people the honest answer is: one or two, and they didn't come from the notes app. They arrived in the shower, or halfway through explaining something to a colleague. The app held 3,000 notes and contributed none of them.
Casey Newton spent a year putting his faith in Roam — not just to capture his writing, he wrote, but "to improve the quality of my thinking." Then he waited for the insights to come. They didn't. The original promise, he concluded, "fizzled completely," and he titled the postmortem Why note-taking apps don't make us smarter. For the diagnosis he reached for an observation from Andy Matuschak: note-taking apps emphasize displaying and manipulating notes, but never making sense between them.
That's the gap. Everything else here is about how it got there and what closes it.
The uncomfortable part is that your system isn't broken. It is working exactly as designed. It was built to manage documents — file them, find them, sync them, render them nicely — and it does that beautifully. Making sense between them was never in the specification. No amount of extra tagging discipline retrofits it, because the problem isn't your discipline. It's the unit you're managing.
This essay is about that unit. The claim is that the thing worth building a system around is not the note but the concept; that this isn't a new idea, it's about five hundred years old; that the people who did it on paper relied on a mechanism the digital tools quietly dropped; and that you can get it back.
If you write, research, teach, consult, or ship products — if your work is turning a large number of inputs into a defensible point of view — this is your problem, whatever app you're using.
By the end you'll have five specific tests you can run against any tool you're considering. I'll apply them to my own at the end, and you're welcome to skip that part.
A note is a container. A concept is a unit of thought.
Ask where a note lives and the answer is about where it came from: this book, that meeting, last quarter's project, that podcast episode. A note's address is made of its history.
Now ask where an idea lives. Say you've been circling something like experts get worse at explaining the thing they're expert in. Where is that? Part of it is in a book you read in 2023. Part is a remark a colleague made in a design review. Part is a paper you skimmed and half-remember. Part is the afternoon you tried to teach a kid to ride a bike and couldn't say what you do with your body to stay upright.
Four containers. One idea, in pieces, with no address of its own.
That's the whole problem in miniature. To use that idea you first have to remember which containers it's hiding in. Your recall is capped by your memory of provenance — which is precisely the thing the computer was supposed to take off your hands.
Matuschak states the alternative cleanly: organize notes by concept, not by author, book, event, or project. His analogy comes from software — a well-built module is about one thing, which is what makes it usable somewhere its author never imagined. Same logic here. A note called "Kahneman — Thinking, Fast and Slow" is about forty things and reusable for none of them. A note called "Experts lose access to the beginner's model" is about one thing, and every future encounter with that idea has somewhere to land.
That last clause is where compounding actually comes from.
When the unit is the source, note #900 is one more item on a list. The list gets longer and, item by item, slightly less useful. When the unit is the concept, note #900 usually thickens something already standing: a fifth piece of evidence, a case that doesn't fit, a sharper way of saying it, a link to a neighbour you'd never have put beside it. The collection stops growing outward and starts growing denser. That's the difference between a library and a mind.
There's a trap sitting right on top of this, and it has a name. Christian Tietze calls it the collector's fallacy: knowing about something feels almost identical, from the inside, to knowing it. Saving the article delivers a small hit of the same satisfaction that understanding it would. The modern capture stack is, among other things, a very efficient machine for producing that feeling — and the current wave of AI features mostly makes it cheaper still. A summary of something you haven't read hands you the sensation of comprehension without any of the work that normally produces it. Your archive gets richer while you get no smarter, and nothing in the interface will ever tell you that's happening.
So there are two verbs, and almost everything follows from which one a tool was built around.
- Managing is storage, retrieval, sync, structure, tidiness. Success means nothing is lost and everything is findable. It is measured in coverage.
- Developing is elaboration, connection, contradiction, revision, reuse. Success means something comes back out that you didn't put in. It is measured in surprise.
Nearly every tool you've tried is an outstanding manager. That's no scandal — managing is genuinely hard, and thirty years of software went into making it feel effortless. But if what you actually want is the second verb, you need to know what the second verb requires.
Conveniently, that question was answered a long time ago, by people working with paper and a box.
The Zettelkasten, and five hundred years of solving this with paper
The box most people know belonged to a German sociologist named Niklas Luhmann. He worked with it from 1952 until his death in 1997, filled it with roughly 90,000 slips of paper across two wooden cabinets, and published more than seventy books off the back of it. Asked how one person wrote that much, he said he didn't do it alone: much of it, he claimed, happened in the slip box rather than in his head.
He did not invent the thing. He inherited a craft.
In 1548 the Swiss naturalist Conrad Gessner described cutting his notes into strips with scissors so he could shuffle them into groups and re-cut the groups later. In 1685 John Locke published a method for indexing a commonplace book, because everyone keeping one had discovered the same thing: a notebook fills up in the order you happened to read, which is never the order you need. Around 1767 Carl Linnaeus started writing observations on paper slips of one standard size — about a thousand survive in London, and they are essentially the first index cards. By the late 1800s the same object had scaled up into the library card catalogue, the piece of infrastructure that made large libraries usable at all.
Then the practitioners. Roland Barthes kept over 12,000 cards across roughly forty years. Nabokov wrote Lolita on index cards, shuffling scenes into place rather than writing front to back; he died leaving an unfinished novel that was literally 138 cards. Beatrice and Sidney Webb wrote a whole book about the method in 1932. C. Wright Mills told a generation of sociologists to keep what he simply called "the file," and said the file was where the sociological imagination actually happened.
None of these people were being quaint. They were doing the job you are doing: taking in more material than one head holds, and needing it to turn into something.
The number of slips is the least interesting fact about any of them. What matters is four mechanisms — because each one turns out to be a requirement, and each one is easy to lose.
1. One idea per slip
A card is small. That constraint isn't a limitation, it's the design.
If a slip holds one idea, it can be pulled into a context you couldn't have predicted when you wrote it. If it holds your whole reaction to a book, it can only ever be pulled up as "that book." The slip is small so that its future is open.
2. The number is an address, not a category
Luhmann's slips are numbered like this: 21, then 21a, then 21a1. It looks like an outline. It isn't.
A new slip went physically behind whichever slip it was responding to, and took the next free number in that position. The number says where it sits, not what it's about. Slip 21a1 might be about ecclesiastical law while 21 is about organisational trust, and that's fine — it's there because it answers 21, not because it belongs to a category called 21.
His reason for refusing subject-based filing was practical, and he wrote it down: if you file by topic, "you would have to adhere to a single structure forever." The first year of a project would decide the shape of the next twenty. Anyone who has restructured a folder tree at 2am knows the feeling he was avoiding.
So storage location and meaning were deliberately pulled apart. Where a note lives tells you nothing about what it means, and that is a feature.
3. The index is a door, not a filing system
Here is the fact that breaks most people's mental model of this method.
Luhmann's collection ran to some 90,000 slips. The keyword register that opened it ran to about 3,200 entries — a few thousand doors for tens of thousands of rooms. And it never tried to be complete. Johannes Schmidt, the archivist who catalogued the collection, puts it flatly: the register "makes no claim to providing a complete list of all cards in the collection that refer to a specific term."
Read that again if you've ever felt guilty about your tagging. He was not labelling everything. He wasn't trying to make the index a complete map of the contents. The register was a set of doors: a few dozen places to walk in from. Once inside, you didn't search — you followed the trail of references from slip to slip and saw what you passed on the way.
Modern practice inverted this. We tag exhaustively, produce a tag list with 400 entries, and then never open it, because a taxonomy that describes everything distinguishes nothing. The paper version was lazier on purpose and worked better.
4. The box has to be able to surprise you
In 1981 Luhmann wrote a short report on working with his slip box, and it contains the sentence the whole tradition rests on:
It is an obligatory condition for communication that both partners can surprise each other.
He was making a strange claim seriously: that the box was a partner, not a container. He described it as a kind of second memory, an alter ego you could always talk to, with no pre-planned order and no hierarchy. What he wanted out of it were combinations that were never planned, never premeditated, never designed that way.
That's the success criterion. Not I can find my notes — everyone with a search bar can find their notes. The criterion is: the system said something back that I didn't put in.
And it isn't an antiquarian criterion. Andy Matuschak, working seventy years later in his own system, keeps a note whose title is the whole argument: Notes should surprise you.
One more thing about the paper era, because the rest of this piece depends on it. The effort was doing real work — but not all of the effort was equal. Copying a citation by hand was labour. Deciding which slip this one sits behind was judgment. Paper happened to bundle the two together, and that bundling was an accident of the medium, not a principle. What made the box work was the judgment. Any system that strips out the judgment in order to save you the labour has thrown away the part that was doing the work.
Then all of that became free.
What Roam, Obsidian and the rest got right — and the three things they dropped
Free is exactly the right word, and it was a long time coming. In 1945 Vannevar Bush described a machine for building "associative trails" between documents — the ancestor of both the hyperlink and everything discussed here. It took about seventy-five years for someone to put it into a note-taking app that ordinary people actually used.
When it finally happened, it was a genuine advance, and it's worth being precise about what improved.
Roam Research made the double bracket a primitive. Type [[attention residue]] and the reference exists; every note that mentions it gains a connection, both directions, for free. That one move turned linked notes from a niche discipline into something tens of thousands of people did daily. Obsidian took the same primitive and made it durable — plain Markdown files in a folder you own, no server, no lock-in, plus a plugin ecosystem that lets you bend it into almost anything. Logseq argued the unit should be smaller than a file and made the block addressable. Notion went the other way and made structure explicit: databases, properties, relations between rows. Tana pushed further, turning a node into a typed object with fields you can query. Heptabase and Scrintal put a canvas at the centre, on the theory that some thinking is spatial. DEVONthink, quietly, has since version one shipped a local similarity engine — its "See Also" panel points at documents you never linked, based on how they read.
All of this is good work. Some of it is excellent. And the mechanical costs Luhmann paid in longhand are now approximately zero: writing, addressing, linking, searching, backing up, syncing to your phone.
It's worth knowing what the machine underneath actually is, because it's simpler than the vocabulary suggests. You type [[X]]. The app keeps an index of which notes point at which. Backlinks are that index read backwards. The graph view is that index drawn with a physics simulation. That's the whole mechanism — a good mechanism, just a smaller one than "networked thought" implies.
[[meditation]] typed into a daily note, and the meditation page collecting every note that mentioned it — "linked references," which is the index read backwards. Worth noticing what the brackets are around here: a mood, a person, two errands. That will matter shortly.Three things went missing in the translation from paper.
Loss 1 — The link stopped being a claim
It is tempting to say the problem is that links got cheap. That isn't quite it. Cheapness is labour, and by the distinction drawn a moment ago, labour was never the point.
What went missing alongside the cost was the decision. Luhmann could not file a slip without answering a question: what does this respond to? A [[note title]] in a document graph answers no question at all. It records that you thought of another document while writing this one — a fact about your attention, not a claim about the material. Cheap and empty is the problem; cheap on its own was progress.
That is how you end a year with 12,000 links and no position on anything.
There's a sharper version of this problem. A link records that two notes touched. It never records how. "This supports it," "this contradicts it," "this is the special case that breaks it," "this was disproven in 2019" — all four collapse into one undifferentiated line on a graph. Your system knows a relationship exists and knows nothing about what kind. That distinction deserves an essay of its own, and it's the next one I'm writing.
Loss 2 — The graph draws your links, it doesn't read them
Be fair about what a graph view is. It's a picture of the link index, laid out by a physics simulation that pushes unconnected things apart. It is not an analysis of anything.
Under about two hundred notes, that picture is legible and occasionally useful. Past that, everyone arrives at the same place — the common verdict in the forums is that it's beautiful and almost completely useless. That's not a rendering bug. A hairball is the honest output of the algorithm, because a force-directed layout has no opinion about which of your two thousand links matters.
Look at what it can't tell you. Which connection here is surprising, given everything else you've written? Which concept is quietly load-bearing across otherwise unrelated parts of your work? Which two concepts have drifted so close together that they're probably one concept wearing two names? Which connection is conspicuously missing — the pair that everything around them says should meet, and hasn't?
Every one of those is a question about structure, and structure is exactly what the picture contains and refuses to compute. The paper tradition's product was surprise. The graph view's product is a screenshot.
Loss 3 — The unit slid back to the document
This is the quiet one, and it undoes the argument in the first half of this piece.
In most of these tools, the atom is a file. A concept exists only if you personally create a file for it; until then [[systems thinking]] is an unresolved link, a ghost that shows up grey and holds nothing. Tags don't rescue it either. A tag is a label stuck on documents, not an object with a life of its own — no content, no history, no neighbourhood, no way of being wrong. They're useful as filters. They just aren't concepts.
So concept-orientation survives only as a discipline you maintain by hand, note by note, forever. And disciplines decay. This is why so many carefully built vaults, opened two years later, turn out to be a folder of book summaries with links between them — which is to say, a well-organised set of containers. The tool never modelled the thing the method was about, so the moment the user got busy, the method quietly stopped happening.
Add it up. Capture, storage, retrieval, sync and rendering all improved by orders of magnitude. Making sense between notes did not improve at all. And the current AI layer, as most products ship it, is aimed squarely at the first list: summarise this, tidy that, extract action items. Faster summaries make the archive grow faster. They don't make you smarter, and they hand you the feeling of comprehension on the way past, which is the collector's fallacy with a subscription.
Newton left a door open at the end of his postmortem: "Before I totally resign myself to the idea that a note-taking app can't solve my problems, I will admit that on some fundamental level no one has really tried."
So it's worth asking, before looking at any product page: what would trying actually look like?
Five tests for a concept-centered note-taking tool
Everything above narrows to five requirements. They're deliberately phrased so you can apply them to any app, including the one you already use.
Test 1 — A concept has to be a real object
Not a string inside documents, not a label stuck on them. It needs its own identity, its own page, its own neighbourhood and its own history — so it can be renamed when your thinking sharpens, merged when you discover you had two names for one thing, and pointed at by things that don't exist yet.
Test 2 — Structure has to be a door, not a filing cabinet
You should be able to walk in from a project, a theme, a tag, a concept or a search, and never be required to decide the correct shape of your knowledge up front. Luhmann's objection stands: any system that makes you commit to one hierarchy makes you commit forever, and you know least about the right shape on day one.
Test 3 — The system has to compute on your links, not just draw them
Drawing is not analysis. A tool that meets this test can rank relationships by strength, tell you which of them are unexpected, tell you which concepts are doing structural work, and — the hard one — point at connections that aren't there yet but probably should be.
Test 4 — It has to let you think with your hands
Moving cards around on a surface is a different cognitive act from linking them, not a prettier version of the same one. The Japanese ethnographer Jiro Kawakita built a whole method on this in the 1960s: write observations on cards, spread them out, group them by feel before naming the groups, and let the categories come out of the material instead of being imposed on it. Every design team that has ever covered a wall in sticky notes is running his method. A tool that only supports linking has cut off half of how people actually find patterns.
Test 5 — AI has to stay on the noticing side of the line
There is a line between noticing and deciding what it means, and it is the whole game. Extracting the concepts in a piece of text is noticing. Proposing that two of them might be related is noticing. Telling you what the relationship means, or handing you a conclusion you did not reach, is crossing over — and the moment a tool crosses it, you're back to the collector's fallacy, now automated, now confident, and wrong in ways you can't see.
That's the scorecard. Here's how I built against it.
How Jotaid answers the five tests
I'm the independent developer of Jotaid. I built it because I wanted the five things above and couldn't assemble them out of anything on the market.
Test 1 — Nodes, not ghost links
When you write [[attention residue]] in a note, you don't create a grey placeholder. You create a node — a first-class thing with its own page, its own list of every note that mentions it, a role in your network and a set of neighbours. You can rename it everywhere at once when you find a better name. You can merge two of them when you realise "attention residue" and "task switching cost" were the same idea in two vocabularies.
Around that sits a three-layer structure — Project → Theme → Note — plus an Inbox for capture, so fast capture and slow structure don't fight. You write into the Inbox at speed. Concepts accumulate underneath, whether or not you've decided what the project is yet.
Test 2 — Doors, not a tree
A theme is a container you can create after the notes exist, by dragging them together. Filters stack across tags, concepts and themes. Nothing about your first week constrains your second year.
Tags exist here too, and they are kept deliberately narrow. When Jotaid suggests a tag for a note, the candidates can only be tags already sitting on the notes nearest it — it cannot invent a word, because no model is asked to; the suggestion is a local vote among similar notes and never leaves your device. That restraint is the point of Luhmann's register, restated: a tag list is worth having while it stays a handful of doors, and worth nothing the moment it grows a new entry every time you write.
Test 3 — The system reads your links
Jotaid ships a graph view, and everything said about graph views above applies to it — which is why it deliberately refuses to draw your whole project. It draws one concept's immediate neighbourhood, capped at a dozen neighbours, so it stays something you can read rather than something you can admire. The actual reading of the network happens somewhere else.
That part doesn't exist elsewhere, so it's worth explaining how it works.
The co-occurrence matrix. For every pair of concepts in a project, Jotaid counts how often they show up in the same note, then normalises it: shared notes divided by notes mentioning either one. That gives every pair a score between 0 and 1, and every pair a cell in a grid.
It isn't a novel idea. Bibliometricians have been mapping entire scientific fields this way since the early 1980s — the technique is called co-word analysis — on the premise that what a field is really about shows up in which terms keep appearing together, not in what anyone claims the field is about. Jotaid points the same instrument at your own writing. A clustering pass then groups concepts that keep co-occurring, which surfaces themes you never declared. And any pair scoring above 0.8 gets flagged, because a pair that appears together almost every time is usually not two concepts.
Roles: what each concept is doing. Every node is classified by its actual position in your network:
- Core — mentioned often, and its neighbours are also connected to each other. A developed centre of gravity.
- Bridge — its neighbours mostly don't know each other. This concept is the only thing joining otherwise separate regions of your thinking.
- Emerging — picking up new mentions recently. Something is happening here.
Bridges are the ones to watch. A well-known study of where good ideas come from (Burt, 2004) found that people positioned between otherwise unconnected groups get disproportionately more of them — not because they're smarter, but because they can see two things at once that nobody else can. A later analysis of 17.9 million scientific papers (Uzzi, 2013) found that the highest-impact work is overwhelmingly conventional with one unusual pairing in it. Bridges are where your unusual pairings are. Most tools have no way to tell you that you have any.
The connection that isn't there. Jotaid also runs link prediction: it looks for pairs of concepts that share a lot of neighbours — weighting rare shared neighbours more heavily, because sharing an unusual acquaintance means more than sharing a popular one — and yet have never once appeared in the same note. Those pairs get surfaced as candidates.
That's the direct descendant of what Luhmann was after. It's the box saying something you didn't put in.
A read on the shape of your thinking. If nearly everything in your network connects to everything else, that's not richness, it's an echo chamber, and Jotaid says so. It will also tell you when the network is too sparse to conclude anything, and when a cluster of new concepts is growing off to one side.
There is an objection to all of this, and it comes from the person who named the problem in the first place. Matuschak argues that evergreen notes should be densely linked, and that the value lies in adding those links yourself: doing it "creates pressure to think carefully about how ideas relate to each other," and it sends you back through old notes on the way. Compute the relationships for people, and you have automated away the work that was producing the thinking.
He's right, and it's why the line falls where it does. Jotaid does not infer your links. The [[ ]] is still typed by you, while you're writing, and it is still a claim about what this note is about — the judgment, in the distinction drawn earlier, not the labour. The analysis layer writes nothing at all: the matrix, the roles and the predictions are read-only reports on links you made yourself.
What they add is the one thing hand-linking cannot give you. You can hold the relationships among forty concepts in your head. At four hundred you cannot — and no amount of careful linking will reveal that one of them is quietly brokering between two halves of your work, because that fact isn't present in any single note. It exists only in the shape of the whole. The structure is a clue, not a conclusion. It tells you where to look. What you find when you look there is still yours.
Test 4 — Cards on a surface
The same notes open on an infinite canvas as cards you can drag, colour, group into themes and tidy. This is Kawakita's method with the manual labour removed: cluster first, name the cluster second, keep the arrangement. It's the same data as the list and the graph — not a separate whiteboard product holding a copy of your notes.
Test 5 — Which side of the line the AI sits on
Jotaid runs a semantic index locally by default. The model lives on your device, nothing leaves it, and it costs nothing to run — so it's on for everyone, including free users. That's what powers "notes similar to this one" and "concepts that read alike but have never met."
Two deliberate rules govern it. Structural relationships and semantic ones are never blended. A shared concept is a fact you created. A similarity score is a machine's guess. They appear in separate sections with different labels, because a tool that mixes them will eventually have you believing you made a connection you never made. And no similarity percentages are ever shown. "0.62" is not information; it invites you to argue with a number instead of looking at the note.
Everything above the semantic layer — concept extraction, link suggestions, drafting — is optional, off until you configure it, and runs on your own API key with whichever provider you choose. Suggestions arrive unticked: the model proposes a list of candidate concepts and none of them are selected, so nothing becomes real until you decide it should.
Nor is any of it pushed at you. Matuschak has tried the other version of this — having a system surface old notes algorithmically to manufacture serendipity — and found it mostly produced noise rather than insight, because a note arriving while you're thinking about something else doesn't land. That matches my experience, so Jotaid never notifies you about a connection and never opens a panel you didn't ask for. The matrix is a place you go, on purpose, when reviewing is the task. A suggestion delivered at the wrong moment isn't a discovery; it's an interruption dressed as one. When Jotaid tells you two concepts might be related, it never tells you how, because that's the part that's yours, and it's the only part that was ever worth your time.
The loop, in practice: a weekly workflow
That part — the part that's yours — has a routine. It's one rule and one weekly habit, and it doesn't require a new lifestyle.
Capture without organising. Everything goes into the Inbox: quotes, half-thoughts, meeting residue. Don't file it. Filing on the way in is guesswork, because you don't yet know what any of it is for.
Mark the concepts as you write. This is the only discipline the method actually needs. When you write a note and hit a phrase that names an idea rather than an event — [[meeting cost]], [[async writing]], [[onboarding]] — put brackets around it. Two keystrokes. You're not organising; you're telling the system what this note is about, in language you'll still recognise in a year.
Yes, that is a discipline, and I argued above that disciplines decay. The difference is that this is one rule rather than a system, and it pays out where you can see it: the concept becomes an object the same day, and by the third or fourth note it starts turning up in places you didn't put it.
Twenty minutes a week, open the matrix and look at exactly three things.
- The strongest pair you didn't expect. Two concepts that keep showing up together without you ever having decided they were related. That's a claim waiting to be written.
- Any pair scoring above 0.8. Almost always one concept with two names. Merge them and the network gets sharper immediately.
- The top predicted connection. The pair that shares a lot of company but has never met.
Move one of them to the canvas. Pull that pair and the notes behind it onto the surface, spread them out, group them by hand, and see what the arrangement says. Cluster first, name second.
Write the theme note. Whatever the arrangement resolved into, write it down as a claim in your own words. That note is the output — not the archive, not the graph, not the streak.
Here's what it looks like when it works. Say you've been reading about remote work for a few months. The matrix shows [[async writing]] and [[onboarding]] share five neighbours and have never once appeared in the same note. You put them on the canvas together, and the arrangement makes the reason obvious: every remote process you've read about got converted to writing except onboarding, which everybody still does by talking. That's a position. It came out of notes you had already taken, and you did not have it before you looked.
Change your measure accordingly. Not how many notes did I take this month. How many concepts did I develop?
What this doesn't fix
It doesn't think for you. Nothing does. Every mechanism here produces candidates; the judgment is still, in Newton's description, "long stretches of time staring into space, then writing a bit, and then staring into space a bit more." No feature replaces that, and none should try.
It needs material. A network with thirty notes in it has nothing interesting to say, and the matrix will look empty because it is empty. Give it a hundred notes with concepts marked before deciding whether any of this works.
It won't redeem a pile of unread clippings. If you never wrote anything in your own words, there are no concepts to find. The machine can only read what you actually thought.
And it isn't a task manager, a document store, or a place to keep every PDF you've ever downloaded. It's for the part of your work that turns inputs into a point of view.
If what you want is plain-text files, total ownership and a plugin for everything, Obsidian is genuinely excellent and I'd point you there without hesitation — concept-orientation is entirely practicable in it by hand. The bet Jotaid makes is simply that the tool should model the method rather than leave you to maintain it, because the discipline is the first thing to go when you get busy.
The point was never the notes
Luhmann's box didn't make him prolific because it stored things. Card catalogues store things. It made him prolific because it could hand back something he hadn't put in — and he treated that as the whole test of whether the thing was working.
That's still the test. Not how much you've captured, how tidy it is, or how impressive the graph looks. Whether your own material can tell you something you didn't already know.
If it can't, you don't have a thinking system. You have a very well-organised warehouse, and you're the only one working in it.
Jotaid is free to use for a single project with the whole method intact — concepts, backlinks, the matrix, the graph, the canvas and on-device semantic search. Pro adds multiple projects and optional AI on your own API key. You don't need to migrate anything to try the loop once: a week of notes and twenty minutes is enough to find out whether your own writing has anything to say back.
Stop managing notes. Start developing concepts.
Zettelkasten: a short glossary
| Term | What it means |
|---|---|
| Zettelkasten (pl. Zettelkästen) | German: Zettel = slip of paper, Kasten = box. English: slip box. Not "Zettlekasten," and not a brand of app. |
| Zettel | One slip. One idea. |
| Folgezettel | "Follow-on slip" — the 21 → 21a → 21a1 numbering. An address, not a category. |
| Schlagwortregister | Keyword register. A short list of entry points, not a complete index. |
Further reading
- Niklas Luhmann, Communicating with Slip Boxes (1981) — the six pages the whole method rests on
- Sönke Ahrens, How to Take Smart Notes (2017) — the book that brought it into English
- Andy Matuschak, Evergreen notes should be concept-oriented and Evergreen notes should be densely linked
- Christian Tietze, The Collector's Fallacy
- Markus Krajewski, Paper Machines: About Cards & Catalogs, 1548–1929
- Casey Newton, Why note-taking apps don't make us smarter
