Based on Joan Westenberg's Metabolic Workspace.
You've probably tried this before: Notion, Obsidian, Roam, whatever. You set up folders, tags, bidirectional links. You clip articles. You highlight passages. You build an elaborate archive.
And then you never look at any of it.
The system grows. Your thinking doesn't. Saving something feels like engaging with it, but it's not—it's just moving text from one place to another.
How often has your archive produced an insight you couldn't have gotten from a quick search at the moment you needed it? If the answer is "rarely," your note system is what Westenberg calls "furniture, not food."
Westenberg's core idea: treat information "like food, not possessions." Food has to be digested to provide value. If you don't process it, it rots. Same with ideas.
This system has one job: force you to think about what you encounter, not just collect it.
The core mechanism is simple: nothing enters the system unless you process it first. No clipping. No copy-paste. You read something, close it, and write down what you remember in your own words. If you can't remember enough to write something useful, the idea wasn't that valuable to you anyway—or you weren't ready for it yet.
What survives this filter is yours. You've done the cognitive work. The note is a record of thinking that happened, not a placeholder for thinking you'll never do.
Everything goes in one file per day. Thoughts, tasks, quotes, observations, questions—all of it. No categorization, no folders, no deciding where something belongs.
Seems chaotic, but it solves a real problem: when you have to choose where to put something, you often don't put it anywhere. One daily file removes that decision entirely.
It also keeps ideas in context. Tuesday's half-formed thought sits next to Tuesday's meeting notes and Tuesday's random observation. That proximity sometimes reveals connections you'd miss if everything was sorted into silos.
The rule: you cannot copy-paste anything into the system. To add an idea from something you read, you must close the source and write from memory.
Writing from memory forces you to identify what matters, put it in your own words, and connect it to what you already know. Copy-paste skips all of that.
If you can't remember enough to write something useful, that's information too. Either the idea wasn't that important, or you need to re-engage with it more deeply before it's ready to become part of your thinking.
One file sits at the center of the system with three sections:
- What I am becoming — the person you're trying to grow into
- What I am building — your current primary project or focus
- What I am learning — the skill or subject you're actively studying
Keep each answer to a single sentence. Update them when they change.
This file is the filter for everything else. When you're reviewing notes, ask: does this connect to any of my WHATs? If not, it might still be interesting, but it's probably not actionable for you right now.
The WHAT anchor prevents the system from becoming a junk drawer. It keeps you oriented toward output, not just input.
Every Sunday (or whatever works), review the week's daily notes. You're looking for the 1-2 sentences that actually shifted your thinking. Not the interesting stuff—the stuff that changed something.
Pull those sentences out. Add them to your WHAT file if they connect directly, or create a standalone note in the extracted folder if they deserve to persist on their own.
Everything else served its purpose. The daily notes were a processing space. The thoughts that mattered have been extracted. The rest can fade—they already did their job by giving you a place to think.
This weekly ritual prevents the system from becoming another archive. Regular pruning means what remains is worth keeping.
Most tagging systems use nouns: #philosophy, #marketing, #project-x. These categorize but don't prompt action.
Instead, Westenberg suggests verbs that demand something from you:
#To-Argue— a position you want to defend or attack#To-Test— a hypothesis to try#To-Teach— something you understand well enough to explain#To-Build— a concrete thing to create#To-Question— an assumption worth examining
When you review your tags, you're looking at a list of things to do, not a taxonomy of things you saved.
Add a brief note about when and how a thought arrived:
- "3am, couldn't sleep"
- "right after the frustrating client call"
- "walking the dog, finally clicked"
Memory is state-dependent. Capturing the context helps you recall not just the thought, but the conditions that produced it. Sometimes the context is the insight—you notice you always have your best ideas in specific circumstances.
Why CLI and Neovim? This approach needs to be fast. GUI apps add clicks, load times, and the temptation to fiddle with settings. A terminal command and a text editor get out of the way. You're writing in under a second.
What we're building: A note script that handles all the commands, shell aliases for quick access, and Neovim keybindings for when you're already in the editor. Everything stores as plain markdown—portable, searchable, works forever.
How it fits together:
nn/<leader>nn— daily capture (the single-in protocol)nw/<leader>nw— your WHAT anchornk/<leader>nk— weekly extraction view (week's notes + WHAT side by side)nx/<leader>ne— browse extracted notes that survivednt/<leader>nt— review action tagsnn add "thought"— quick capture without opening the editor
The shell script and nvim plugin do the same things—use whichever fits your current context.
~/Work/notes/
├── WHAT.md
├── daily/ # 2025-01-15.md, 2025-01-16.md, etc.
└── extracted/ # notes that survived weekly extraction
mkdir -p ~/Work/notes/{daily,extracted}#!/usr/bin/env bash
NOTES="$HOME/Work/notes"
TODAY="$NOTES/daily/$(date +%Y-%m-%d).md"
[[ ! -f "$TODAY" ]] && echo "# $(date +%Y-%m-%d)" > "$TODAY"
case "$1" in
"") $EDITOR "$TODAY" ;;
what) $EDITOR "$NOTES/WHAT.md" ;;
extract) cd "$NOTES/extracted" && $EDITOR . ;;
week)
tmpfile=$(mktemp /tmp/week-review.XXXXXX.md)
for i in 6 5 4 3 2 1 0; do
dayfile="$NOTES/daily/$(date -d "$i days ago" +%Y-%m-%d).md"
[[ -f "$dayfile" ]] && cat "$dayfile" >> "$tmpfile" && echo -e "\n---\n" >> "$tmpfile"
done
$EDITOR -O "$NOTES/WHAT.md" "$tmpfile"
;;
tags) grep -rh "#To-" "$NOTES" | sort | uniq -c | sort -rn ;;
add)
shift
echo -e "\n---\n$(date +%H:%M) | $*" >> "$TODAY"
;;
*) echo "usage: note [what|extract|week|tags|add <text>]" ;;
esacchmod +x ~/.local/bin/notealias nn='note'
alias nw='note what'
alias nx='note extract'
alias nk='note week'
alias nt='note tags'For lazy.nvim:
local notes_dir = os.getenv("HOME") .. "/Work/notes"
return {
{
"nvim-telescope/telescope.nvim",
keys = {
{
"<leader>nn",
function()
local path = notes_dir .. "/daily/" .. os.date("%Y-%m-%d") .. ".md"
if vim.fn.filereadable(path) == 0 then
vim.fn.writefile({ "# " .. os.date("%Y-%m-%d") }, path)
end
vim.cmd("e " .. path)
end,
desc = "Daily note",
},
{ "<leader>nw", "<cmd>e ~/Work/notes/WHAT.md<CR>", desc = "WHAT anchor" },
{ "<leader>ne", "<cmd>Telescope find_files cwd=~/Work/notes/extracted<CR>", desc = "Extracted notes" },
{ "<leader>nb", "<cmd>Telescope find_files cwd=~/Work/notes/daily<CR>", desc = "Browse daily notes" },
{ "<leader>ng", "<cmd>Telescope live_grep cwd=~/Work/notes<CR>", desc = "Grep all notes" },
{
"<leader>nt",
function()
require("telescope.builtin").live_grep({
cwd = notes_dir,
default_text = "#To-",
})
end,
desc = "Agency tags",
},
{
"<leader>nx",
function()
vim.cmd("vsplit ~/Work/notes/WHAT.md")
end,
desc = "Split WHAT (for extraction)",
},
{
"<leader>nk",
function()
local tmp = vim.fn.tempname() .. ".md"
local f = io.open(tmp, "w")
for i = 6, 0, -1 do
local day = os.date("%Y-%m-%d", os.time() - i * 86400)
local path = notes_dir .. "/daily/" .. day .. ".md"
local file = io.open(path, "r")
if file then
f:write(file:read("*a") .. "\n---\n\n")
file:close()
end
end
f:close()
vim.cmd("e " .. tmp)
vim.cmd("vsplit ~/Work/notes/WHAT.md")
end,
desc = "Weekly extraction",
},
},
},
{
"folke/which-key.nvim",
opts = {
spec = {
{ "<leader>n", group = "notes" },
},
},
},
}# WHAT
## What I am becoming
## What I am building
## What I am learning
# [Title]
#To-Argue
[The sentence or paragraph that survived extraction]
Context: [when/where/feeling when this thought emerged]nnor<leader>nn— open today's note- Dump everything there: thoughts, tasks, observations, questions
- When you read something interesting, close it and write what stuck (echo-only)
- Add context when relevant: "after the board call, finally saw the problem"
- Tag actionable thoughts:
#To-Test,#To-Argue, etc.
nkor<leader>nk— opens the week's notes alongside WHAT.md- Scan each day looking for sentences that shifted your thinking
- Ask: does this connect to what I'm becoming/building/learning?
- Yank what survives → paste into WHAT.md or create an extracted note
nt— review your action tags, decide what to act on this week
| Command | Action |
|---|---|
nn |
Open today's daily note |
nw |
Open WHAT anchor |
nx |
Open extracted directory |
nk |
Weekly extraction view |
nt |
List agency tags with counts |
nn add <text> |
Quick append to today |
| Key | Action |
|---|---|
<leader>nn |
Daily note |
<leader>nw |
WHAT anchor |
<leader>ne |
Browse extracted (Telescope) |
<leader>nb |
Browse daily notes (Telescope) |
<leader>ng |
Grep all notes |
<leader>nt |
Search agency tags |
<leader>nx |
Split WHAT for extraction |
<leader>nk |
Weekly extraction view |
Concept: Joan Westenberg
Implementation: Shawn Yeager