Introduction: Where Did the 1,000 Articles You Bookmarked Go?#

Every programmer has probably had this moment: you see a good article, casually toss it into “Read Later” or your bookmarks, and then… never open it again. Collecting never stops, learning never starts. When you actually need a certain piece of knowledge, you remember “I think I saw this somewhere,” but you search through browser bookmarks, WeChat favorites, Notion, and local Markdown files and still can’t find it.

The problem isn’t that you’re not trying hard enough — it’s that you’ve only been “collecting,” not “organizing” and “outputting.” This article shares a minimalist knowledge management method suited for programmers: no fancy note-taking apps, just Markdown + a Shell script, turning information hoarding into reusable knowledge assets.

1. Think First: Are We Managing “Knowledge” or “Information”?#

Information is raw material produced by others, undigested: an article, a tweet, a video. Knowledge is what you’ve internalized, can restate in your own words, and can use to guide action.

Many people’s “knowledge management” is really just information shuffling: clipping web pages into a note-taking app, assuming that saving equals learning. But in reality, saving something only changes where the information is stored — it doesn’t change the relationship between it and you.

So the first principle is: collect fast, organize ruthlessly, output often. During the collection phase, don’t judge, don’t organize — toss things into a unified inbox within seconds. Then use a fixed rhythm to digest them, processing the information worth keeping into your own notes.

2. A Three-Layer Structure That’s Good Enough#

You don’t need to jump straight into the complex linking system of Zettelkasten, nor treat PARA as gospel. For the vast majority of people, a three-layer structure is enough:

1
notes/
2
├── 0-inbox/     # Inbox: dump everything new here first, don't organize it
3
├── 1-archive/   # Archive: permanent notes that have been processed and categorized by topic
4
└── index.md     # Index: entry point for navigation, aggregated by topic

• 0-inbox: The single entry point. When you see something good, toss it in within 30 seconds, along with one sentence about “why I think it’s useful.” The faster this step, the better — the lower the friction, the more likely you’ll stick with it.
• 1-archive: At a fixed time each week, review the inbox, process what’s worth keeping into permanent notes, and categorize by topic.
• index.md: A manual directory of “topic → list of related notes.” It’s more important than search because it reflects your active organization of knowledge structure.

This structure corresponds to a streamlined version of Tiago Forte’s PARA method — “Projects → Areas → Resources → Archive”: first an entry point, then accumulation, and finally archiving.

3. Each Note Answers Only One Question#

The biggest mistake programmers make when writing notes is turning them into “comprehensive tutorials” or “meeting minutes.” Such notes are hard to reuse because their boundaries are vague.

A better approach: each note answers only one specific question. For example, don’t write “HTTP Protocol” — write “Why do browsers limit the number of concurrent connections.” Atomic notes are easier to link, reference, and reuse. When writing, ask yourself three questions:

1. What problem does this piece of information solve for me?
2. Can I explain it clearly in my own words?
3. In what scenario will I use this next time?

If you can’t answer these, the information probably isn’t worth keeping.

4. A Runnable Minimalist Workflow#

Below is a complete Bash script that implements the “collect → review → archive” loop. You can copy it directly into ~/.local/bin/pkm.sh and chmod +x.

1
#!/usr/bin/env bash
2
# Minimal note workflow: new (collect) → review (review) → archive (archive)
3
set -euo pipefail
4
shopt -s nullglob
5

6
NOTES_DIR="${NOTES_DIR:-$HOME/notes}"
7
INBOX="$NOTES_DIR/0-inbox"
8
ARCHIVE="$NOTES_DIR/1-archive"
9

10
new() {
11
  mkdir -p "$INBOX"
12
  local slug="${1:?Usage: pkm new <english-slug>}"
13
  local today
14
  today=$(date +%Y-%m-%d)
15
  local file="$INBOX/${today}-${slug}.md"
16
  cat > "$file" <<EOF
17
---
18
title: "${slug//-/ }"
19
created: $today
20
tags: []
21
status: inbox
22
---
23

24
## Background
25
Why do you find this information useful?
26

27
## Key points
28
Restate the core content in your own words.
29

30
## Next steps
31
In what scenario will you use it next time?
32
EOF
33
  echo "Created: $file"
34
}
35

36
review() {
37
  # List notes created or modified in the last 7 days, prioritize the inbox
38
  find "$NOTES_DIR" -name '*.md' -mtime -7 -print | sort
39
}
40

41
archive() {
42
  mkdir -p "$ARCHIVE"
43
  # Move notes in the inbox marked status: done to the archive
44
  for f in "$INBOX"/*.md; do
45
    if grep -q 'status: done' "$f"; then
46
      mv "$f" "$ARCHIVE/"
47
      echo "Archived: $(basename "$f")"
48
    fi
49
  done
50
}
51

52
"$@"

There are only three commands to use:

1
pkm new http-connection-limit    # 1. Collect: quickly jot down a note
2
pkm review                        # 2. Review: see what was noted in the last 7 days
3
pkm archive                       # 3. Archive: move the processed ones out

This script is deliberately “crude”: no database, no sync, no backlinks. But precisely because it’s simple, you’ll actually use it — and “sticking with it” is a hundred times more important than “powerful tools.”

5. More Important Than Tools: The “Review Rhythm”#

Any knowledge management system will ultimately fail to “input without output.” So review is the engine of the entire method, not an optional extra.

Two fixed rhythms are recommended:

• A weekly mini-review (about 30 minutes): Empty the inbox. Those that can answer the “three questions” get processed into permanent notes and tagged with status: done; those that can’t get deleted outright. Daring to delete is a core skill of knowledge management — the cost of retaining something is always higher than the cost of finding it again.
• A monthly major review (about 1 hour): Go through index.md and ask yourself, “Which of the notes added this month actually changed the way I do something?” Take the notes you use repeatedly and distill them into an article you can publish publicly.

You’ll find that the best knowledge management is “output” itself. Writing a blog post, building a demo, giving a talk to colleagues — any of these forces you to structure your knowledge better than any note-taking system.

Conclusion: The Compound Interest of Knowledge Management#

Knowledge management isn’t about being a neat freak — it’s about making “pitfalls you’ve stepped in before” and “insights you’ve figured out” automatically surface someday in the future. Its compound interest comes from two things: information that only goes in and never comes out is a liability; only what can be reused is an asset. And the value of an asset depends on whether you’ve built a “collect → review → output” loop.

Starting today, pick three genuinely useful items from your bookmarks, write them down with pkm new, and review them once next week. A month from now, you’ll have “collected” less than you did in the past year, but “mastered” more.

References#

• Tiago Forte — The PARA Method
• Zettelkasten — Official Site of the Slip-Box Note-Taking Method
• Andy Matuschak — Evergreen notes
• Building a Second Brain — Tiago Forte’s “Second Brain”