My settings.org setup is like this:

; needed for =org-roam-deadgrep=
(use-package deadgrep)

; These are outside use-package so they can be overridden
(setopt org-roam-directory (expand-file-name "FIXME-PATH-TO-ORG-ROAM"))
(setopt org-roam-capture-templates
          '(("d" "default" plain "%?" :target
	    (file+head "%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}

- tags :: ")
	    :unnarrowed t)))

 (use-package org-roam
    :after org
    :commands org-roam-db-query
    :custom
    (org-roam-mode-sections
	  (list #'org-roam-backlinks-section
		#'org-roam-reflinks-section
		;; #'org-roam-unlinked-references-section
		))

    (org-roam-node-display-template
        (concat "${title:*} "
                (propertize "${tags:10}" 'face 'org-tag)))
    :config
    (org-roam-setup)
    (defun org-roam-node-insert-immediate (arg &rest args)
      (interactive "P")
      (let ((args (cons arg args))
            (org-roam-capture-templates (list (append (car org-roam-capture-templates)
                '(:immediate-finish t)))))
    (apply #'org-roam-node-insert args)))

    (defun org-roam-deadgrep (arg)
      (interactive "MSearch term: ")
      (deadgrep arg org-roam-directory))

    ; see https://gist.github.com/borwickatuw/098b0d3a3b599f3f00c069309e8fd462
    (require 'org-roam-copy)
    ; https://github.com/org-roam/org-roam/issues/991#issuecomment-882010053
    (add-to-list 'magit-section-initial-visibility-alist (cons 'org-roam-node-section 'hide))

    :bind (("C-c n f" . org-roam-node-find)
           ("C-c n r" . org-roam-node-random)		    
           ("C-c n c" . org-roam-capture)
           ("C-c n g" . org-roam-graph)
	   ("C-c n s" . org-roam-deadgrep)
	   ("C-c n y" . org-roam-copy-node)
           (:map org-mode-map
                 (

		  ("C-c n i" . org-roam-node-insert)
		  ("C-c n I" . org-roam-node-insert-immediate)
                  ("C-c n o" . org-id-get-create)
                  ("C-c n t" . org-roam-tag-add)
                  ("C-c n a" . org-roam-alias-add)
		  ("C-c n l" . org-roam-buffer-toggle)	   
		  ))))

In practice, here's what all that does:

• C-c n is the org-roam prefix
• C-c n f finds a node
• When in org-roam, C-c n i inserts a reference
• Searching will show the tags for the node
• John B. addition: C-c n s does a "deadgrep" search through org-roam content
• John B. addition: C-c n y will call org-roam-copy. This will find the node and then go to the :COPY: property and copy its content. For example, if you have a node My work phone number and you put your number in the :COPY: property then when you use C-c n y and find the node, your clipboard will get the phone number. Basically this is a quick copy&paste for non-sensitive content

Recently, I've been adding more data into org-roam:

Turn out that org-roam content can really go stale/bad, especially when you're dumping a ton of content into it! I have several jobs to help with this:

• audit.py: Fixes structural issues such as sub-headings without parent headings
• broken_refs.py: Finds references to files or org-roam IDs where the target doesn't exist. Also looks for stray [[ characters
• orphan_media.py: Finds media that isn't linked anywhere
• web_content.py: Finds org-roam content that's really copied from a web site. (My Notion import, especially, had a lot of copied HTML content from web sites.) I can then interactively remove this content & add it to pinboard.

So, org-roam doesn't work great on the phone. There are org-mode readers but they don't respect the org-roam id: links. So, last year I built a basic exporter. It collates the org-roam files into one gigantic org file, converts the ID links into anchors, and then runs pandoc on them. I then put the file in Dropbox.

Unfortunately, I now have an iPhone and the iPhone doesn't want Safari to open a local file. So, I have recently switched to generating an .epub file. I can then open this on the phone.

Additionally, I added a git post-commit hook to my org-roam directory, so that this epub file gets regenerated. Here's the hook:

#!/bin/bash
set -e

PLIST=~/Library/LaunchAgents/com.johnborwick.org-roam-export.plist
PLIST_SOURCE=FIXME-PATH-TO/com.johnborwick.org-roam-export.plist
LABEL=com.johnborwick.org-roam-export

if ! launchctl list "$LABEL" >/dev/null 2>&1; then
    if [ ! -f "$PLIST" ]; then
        test -f "$PLIST_SOURCE" || { echo "ERROR: $PLIST_SOURCE not found" >&2; exit 1; }
        cp "$PLIST_SOURCE" "$PLIST"
    fi
    launchctl load "$PLIST"
fi

touch ~/.local/share/org-roam-export-trigger

This bootstraps a launchctl job that watches that org-roam-export-trigger file. When that file changes, it kicks off the job. This is necessary because I have a hook in Emacs to commit to git when I save an org-roam file. Emacs will wait on the hook to finish running, even if you use nohup and stuff.

Here's the plist file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.johnborwick.org-roam-export</string>
    <key>ProgramArguments</key>
    <array>
        <string>FIXME-PATH-TO/run_org_roam_export.sh</string>
    </array>
    <key>WatchPaths</key>
    <array>
        <string>/Users/john/.local/share/org-roam-export-trigger</string>
    </array>
    <key>StandardOutPath</key>
    <string>/tmp/org-roam-export.log</string>
    <key>StandardErrorPath</key>
    <string>/tmp/org-roam-export.log</string>
</dict>
</plist>

In turn, the run_org_roam_export.sh script runs my org_roam_export.hy script.

With all of this, I feel like I really have a clear, connected system now:

• Readwise Reader is for reading non-books (I have separate jobs that will synchronize Readwise Reader with pinboard unread bookmarks)
• A book tool (currently Hardcover) tracks the books I want to read
• org-roam has all my reference content
• I can link to org-roam from elsewhere in Emacs
• I can access the org-roam content via iOS's Books app (sort of)

Tools can provide their own MCP servers, but it's also possible to create your own. I currently have these:

1. fclibrary-mcp: This lets me search the Forsyth County public library's collections.
2. hardcover-mcp: This lets me search my book lists on Hardcover, add books, and update book status. I can't say much about Hardcover except that I switched from Goodreads to it to get API access¹.
3. notmuch-mcp: This lets me search my notmuch email.
4. org-mcp: This lets me search and edit my org-mode content, including my tasks and projects.
5. orgroam-mcp: This lets me search and edit my org-roam content, which is basically my personal Zettelkasten
6. pinboard-mcp: This lets me search and edit my saved bookmarks
7. readwise-mcp: This lets me search, add tags, and otherwise edit my Readwise Reader content

I didn't write the code for any of these; I worked with Claude Code to create the MCP servers themselves. I did set standards, e.g. they're all Python-based.

I then added all of these to Claude Desktop so I could use them. Claude Desktop runs these as binaries when it starts, after you update its .json config file, which is a little weird? It's a pipe-based connection not a network connection.

Here are some specific examples of things I've done with these:

• Claude Desktop has added tags to my Readwise Reader untagged, unread content, and moved less-relevant/timely content from my "Inbox" to "Later". (I am slowly working through a backlog of years of unread content that I pulled from my pinboard.in unread bookmarks last year.)
• Claude Desktop can look at my unread books from Hardcover and search for whether they are available at the library. It can also recommend new books and add them to my unread list.
• Claude Desktop can add tasks to org projects.

Here's roughly how one MCP server is laid out:

$ find .
orgroam-mcp/
   CONTEXT.md
   pyproject.toml
   orgroam_mcp/
      orgroam_mcp/__init__.py
      orgroam_mcp/server.py

The CONTEXT.md file is literally passed to Claude Desktop. It uses natural language to describe the "tools" along with examples.

The pyproject.toml is because I want to have separate Python uv environments per server. Here's the dependencies for this project:

dependencies = [
    "mcp[cli]>=1.25,<2",
    "orgparse>=0.4",
    "mcp-shared",
]

(mcp-shared is another library within the repo for things like logging.)

The server.py uses FastMCP:

mcp = FastMCP("orgroam-mcp", instructions=_load_instructions())

Then there's a function for each MCP tool:

@mcp.tool()
def search_notes(query: str, limit: int = 20) -> str:

So for some of these (notably the library-querying MCP server), the Python functions are in turn calling other APIs. In this particular case, orgroam-mcp is reading files on the filesystem in my org-roam directory.

I'm generally looking for runs that:

• have few stoplights!
• let me see interesting things
• don't overlap much
• are up to 10 miles in length
• are roads or "solid green line" trails, vs. dotted green line trails
• are not overly muddy
• look OK on Strava and/or Garmin Connect heatmaps

I typically am using trail running shoes, but I do try to notice what might be paved.

I've found greatruns.com to have a good list of runs, e.g. their DC page lists several runs.

I also Google the city, e.g. running washington dc, best runs washington dc, or running washington dc site:reddit.com to look for runs.

I want to put the trail into my Garmin watch. To do this, I start with onthegomap.com and enter in a trail.

If I can't make a path connect, that could indicate that there are bridges or other issues. I use Google street maps to look at key parts of a potential trail, especially if there are complicated-looking turns.

I try to build in some wiggle room in the distance, especially if I don't totally understand the route.

I'll use the onthegomap.com elevation display to see what I'm signing up for. For example, in my Rock Creek trail run, there was one big climb to get from the valley to DC's streets.

Sometimes I'll plan to take a taxi/Lyft to the start point. If so, I look for places that are easier for a drop-off. I might pull up Lyft to confirm I can select the start point OK.

After I have the route, I export the map "as GPX" from onthegomap.com and import that into Garmin connect (either on my phone or via a computer).

Quick double-checks when building the run:

• Ensure that the route is the correct orientation! Both onthegomap.com and Garmin Connect have "reverse route" options.
• Ensure turn-by-turn directions are on, which is my default
• I look at Strava's global heatmaps and sometimes Garmin connect's heatmaps to get a sense of whether the trail I've built is weird. If few people are taking the trail, there's probably a reason (e.g. it's very hilly or not well marked).

I check the Google weather and precipitation hour-by-hour report, looking for:

• What's the temperature?
• Am I going to be in the sun?
• How much precipitation will there be?

If it's more than 0.01" precipitation per hour, then I'll wear a rain jacket.

When I'm starting the run, I pull the map up on my Garmin watch using the "navigate" option. During the run I'll be checking:

• When is the next turn?
• What is the remaining distance?

I am using Jekyll for my site but don't understand it very well. I like that it generates a static site and that I don't need to know much about how that happens! :-)

Probably the fanciest thing I've done, basically copying from others, is on the wiki index page:

<ul>
{% assign sorted_pages = site.pages | sort: 'title' %}
{% for site_page in sorted_pages %}
  {% if site_page.layout == 'wiki' and site_page.name != 'index.html' %}
  <li><a href="{{ site_page.url }}">{{ site_page.title }}</a></li>
  {% endif %}
{% endfor %}
</ul>

(This lists all the wiki pages in alphabetical order by title.)

With the minima theme, I had started to investigate pagination but needed to figure it out myself.

Additionally, I installed minima many years ago and figured I'd need to upgrade the whole stack, including Jekyll. It seemed like a good time to try a new theme that might have more "batteries included."

My workflow continues to be:

1. Write a post in org-mode
2. Compile the post into HTML via org-mode exporting. The destination directory is Jekyll
3. Run jekyll to build the HTML for the site
4. rsync that site to my hosting provider

This workflow works pretty OK, except that relative linking between pages is a bit weird. (Ideally links would be org-mode links that get converted appropriately into jekyll relative links.)

The structure is:

• jb.com folder
  • .git: version control for site
  • _site: target HTML site
  • jekyll: Jekyll version of site
  • org: org-mode version of site (the directory where I add content)
  • Makefile

The Makefile has:

site:
	JEKYLL_ENV=production cd jekyll && bundle exec jekyll build -d ../_site

clean:
	find org/wiki -name '*.html' -exec rm "{}" \;

upload: site
	rsync -avz --delete _site/ FIXME/

My experience is that the watch and associated programs are not necessarily intuitive. You have to adapt to Garmin, to a large extent. However, once you start to figure out how Garmin has designed things, the interface starts to make more sense.

For example, this watch does not have a touchscreen. You hit buttons. This can really help when you're running and need to do something and don't want to slow down to touch the screen. However, it does mean you have to learn what the buttons do.

The watch has five buttons:

Upper-left button

short-press for backlight; longer-press for controls; really long press for emergency notifications.

Middle-left button

short-press for widget scrolling; longer-press for watch configuration.

Lower-left button

short-press for widget scrolling; longer-press for music menu.

Upper-right button

activities. (If in an activity, this stops the activity.)

Lower-right button

go back home. (If in an activity, this becomes the lap button.)

The watch has a couple of "modes," from my perspective:

Home

this is the "not in an activity" mode, where you see your watch faces.

Activity

if you were home and pressed the upper-right button, you can now select a type of activity (e.g. "run"). Each activity then has its own configuration and watch faces.

Controls

you see this only when long-pressing the upper-left button. This is a wheel of controls, e.g. a stopwatch, that you can access from any mode.

Music

you get to this from long-pressing the lower-left button. This lets you select music. You can exit with the lower-right button.

Settings

you see this when long-pressing the middle-left button. This lets you control various settings depending on the mode you were in when you pressed it

Widgets

this is when you were home and then hit the middle-left button or lower-left button. You're now scrolling through widgets. You can select the widget to see more via the upper-right button.

The watch comes with a USB charger that's 2-3 feet long. For how I use it, the watch needs to be charged once a week. Charging takes me an hour.

The watch is designed to pair with a phone via Bluetooth. The phone needs the "Garmin Connect" app on it. I'll talk more about Garmin Connect in a minute.

The phone can also have the "Connect IQ" app on it. This is totally separate from "Garmin Connect." Connect IQ lets you add third-party tools to your watch, such as additional watch faces.

The watch can also connect to a computer via the USB charger. The computer needs to run the "Garmin Express" program. Garmin Express is a bit of a clunky program; it reminds me of much older synchronization programs (like Palm Pilot level synchronization programs). To the best of my knowledge, everything that the Garmin Express program does can be done via the Garmin website + the phone's "Garmin Connect" app.

If you have a Music version of the device, you can also pair Bluetooth headphones with the watch. Music is stored on the watch.

You can access Garmin Connect via your phone, or via connect.garmin.com. Garmin Connect has a slight logical separation between your information and your device's information. I assume this is because you might have several Garmin devices that you want to have roll up into one interface.

Here are a few of my key watch settings.

From Garmin Connect > Device settings:

• Activity Tracking > Goals > Daily Steps > "Use Auto Goal"

  This will calculate how many steps needed to reach my daily goal based on what I've been doing recently.

• User Settings > Personal Information

  I set my "normal sleep time"

On the watch itself, I set my heart rate zones by going to settings > User Profile > Heart Rate and then

• Setting max heart rate
• Setting resting heart rate (based on "use average")

• Zones: setting "Based On %HRR"

  This way the zones are set dynamically.

Several types of things can be configured on your watch:

Activities

the types of sporting activities you can select

Activity-specific configuration

the watch face(s) and other settings available when you select a certain activity

Controls

what shows up if you long-press the upper left button, e.g. "stopwatch."

Music

If you have a Music version of the device then there's a set of menus for selecting your music

Watch face(s)

what you see when you look at your watch

Widgets

what you see when you hit the middle left and lower left buttons

You can control your "favorite" activities plus a list of activities. Activities are either delivered out of the box or can be downloaded/installed via Garmin Connect IQ. Here's what I have:

Favorites

• Row Indoor
• Run
• Walk

All

• Calisthenics: I made this by copying the "strength" activity. I use this for tracking when I follow along with YouTube bodyweight strength training videos.
• Cardio
• Hike 2+: I installed this app per recommendations online about good hiking apps. The Forerunner 245 does not have a built-in hiking activity.
• Strength
• Treadmill

My row indoor data screens (in order) are

• Heart rate / Strokes / Stroke rate / Timer
• Heart rate
• Clock

I put everything I want to see on the first screen and I only use that screen, because there's not a good way to change screens when rowing.

My running data screens (in order) are

• Heart rate
• Distance / Timer / Pace
• Lap distance / Lap time / Lap pace
• Clock
• Map

When I use a special feature (e.g. a workout or PacePro), that then adds additional screens.

This third-party app works differently than the built-in apps. It is designed for long battery life. When you push the "lap" button, you add a waypoint. The app will show you how far away you are from the waypoints. It will also track your elevation, where you are on a map, your heart rate, and other data.

Please note that on the Forerunner 245 the maps are blank: you can see your path but there's no topographical map or roads or anything. Other activities (not Hike 2+) do have an option to retrace your steps, where the watch will tell you how to follow your path back to the start.

I use the "strength" activity for weightlifting. However, I don't actually put my sets or other data into the watch; I use FitNotes, which is an excellent Android weightlifting app.

The treadmill activity has an option when you save the activity, "Save and calibrate." This lets you key in what the treadmill said your distance was. The watch will then correct its distance according to what the treadmill said.

Here are my controls, in order:

• Assistance
• Phone
• Sync
• Do Not Disturb
• Lock/Unlock Keys
• Stopwatch
• Timers
• Find My Phone
• Power Off
• Save Location
• Alarm Clock

I like having the stopwatch and timers next to one another.

I removed the controls I that I don't use much.

I generally run without listening to anything. However, for a longer treadmill run, I loaded one episode of The Runcast by KEXP on my watch. It seemed like the watch did remember where I paused so I didn't have to seek when I listened to it again.

That said, I don't have much experience with the music part of my watch. At the time I purchased it, for some reason the music version was slightly cheaper than the non-music version.

The watch face I use is close to the standard one. It displays:

• Icons (e.g. battery level, is phone connected)
• Time
• 3 data points:
  • # of steps
  • Calendar day and day of week
  • Heart rate

I display my heart rate mainly to see whether the heart rate sensor is working.

I did download two watch faces:

OCD D Void

This just says "Garmin"

Void

This shows an analog clock

I use these if I don't want people to see my regular watch face data (e.g. I don't want them to see my current heart rate).

Activities and widgets are the two easiest-to-use watch features, so I've put some time into how I want the widgets configured. I have the below widgets set up, in this order:

• Health Stats
• Performance
• My Day
• Pulse Ox
• History
• Air Quality
• Weather
• Notifications

You can access widgets using the left middle button or the right middle button, going in a circle. So, whatever's at the top of the list or the bottom of the list is easiest to access. My thinking is that the top part of the list is "my health stuff" and the bottom part of the list is "my environment stuff."

I use Health Stats often to see my heart rate, body battery, and stress level information.

I use Performance way more than I thought I would. I check on all data here. I also look at this pretty frequently via the Garmin Connect app.

My Day is a shortcut to access your current day's activities as well as to see your goals e.g. number of steps.

I turned off Pulse Ox monitoring (to conserve battery) but I can check it manually with this widget.

History is a way to see previous activities via the watch. (My Day only shows the current day's activities.)

Air Quality was very helpful when Seattle's air quality was really bad.

Weather shows the weather today and for the next few days.

I really don't use Notifications and should probably remove it; if I want to see notifications I use my phone.

I hope this extremely detailed write-up was helpful, either as someone who has a Garmin watch or as someone who's trying to understand how Garmin thinks about smart watches!

I think the precipitating event this time was watching the documentary The Alpinist. Marc-André Leclerc, the free solo climber in that documentary, lived his life around climbing. He lived in a van in the woods near where he climbed. He climbed constantly. The filmmakers even get stood up for an interview because Marc-André decided to go climbing. I saw that he didn't "make time" to climb; he tried to "make time" to do anything else besides climb. Climbing was his default.

That changed my perception of exercise. I usually have thought of exercise as a habit or a chore that I want to try and make time for. However, like many people, I'm pretty busy; when I think about exercise as another to-do item, I start to assess it vs. other to-do items and I tend to drop off.

In my previous exercise post I also talk about "The Lefkoe Method," which is a good technique for questioning your fundamental assumptions and beliefs so that you can change them. I've been doing this on and off for a while as well. So between my questioning of beliefs and seeing The Alpinist, maybe something clicked.

Every few months I'd tried different "interventions," or changes to try and disrupt a system, to see if they'd help me exercise. I observed that I thought of myself as a "fit" person, but that my belief about myself was from my level of physical activity many years ago. I was not objective in assessing my fitness. That led me to purchasing a fitness watch: the Garmin Forerunner 245.

I've never had a smart watch before, although I did own a Forerunner 305 back in the late 2000s. I wasn't sure what Garmin's niche was vs., say, Samsung's smart watches. I didn't totally understand that the Forerunner was a running-centric watch—"for runner," get it?

Once the watch arrived, I started to get data about myself. This objective data has helped me counter my narrative for myself by showing me exactly how in shape I am. The measurements I've found useful include

"Body battery"

This is a proxy for how worn out you are. It has been helpful for me.

"Stress" level

I have no idea how scientific this is, but the watch will show me how stressed I am (physiologically). I can see that hours after a run my levels are still high, for example.

Current heart rate

I didn't know the effect on me of going up four flights of stairs quickly, besides knowing I was out of breath. This helped me observe how activities became easier as I got more in shape.

Heart rate zones

The Garmin/watch ecosystem can calculate these zones, which helps with understanding how intense my current activity is

Intensity minutes

How many minutes you've worked out, but anything in a heart rate zone counts double.

Recovery time

This shows how much time the watch thinks you need before you recover.

Resting heart rate

I didn't know what my resting heart rate was, although I'd taken it with a pulse oximeter occasionally.

Training load

This shows how much activity you've done over the past 7 days.

VO2 max

I had no idea what VO2 max was when I got this watch. However, now I understand that it's a core cardio fitness indicator especially for running.

I set a goal for myself to get at least 210 "intensity minutes" a week. I then found times to exercise, which at the beginning included

• gym workouts
• rowing machine (at home)
• running, especially on the weekend
• walking over lunch

I re-joined the local gym so that I could have another workout option. This was also helpful when Seattle was filled with smoke back in September; I could run on the treadmill at the gym.

I got to where I would walk about 3.5 miles at lunch to a vegan burger place (Next Level Burger) and back. I started to find more opportunities to run as well.

I'm very fortunate to have some good exercise knowledge from past experience, such as

• Run three times a week: once at a tempo run, once with intervals, and once on an easy long run
• Don't push it on the running and try not to run too many miles a week
• Cross-train with weights, e.g. using Starting Strength
• Follow along with Youtube exercise videos to get core/upper body training, especially if the gym's too difficult
• Walking can be done anytime

I'm very happy to say that my running progress has paid off!

My first run with the watch was September 13, where I ran at an average pace of 14:46/mile: I walked a lot. I can see the data: I ran for 19 minutes at an 11 minute pace, my heart rate got up to ~170, and then I walked.

I kept at it. By late October I went to a conference and I made running after the end of each day a focus and reward. I really enjoyed it! I wanted to run farther so I could explore the city more, and did several long runs.

The next weekend I ran my first 5K in a couple of years in 30 minutes. Then for Thanksgiving I ran a 60 minute 10K! I have also accomplished some of my big running goals, including running on the I-90 floating bridge to Mercer Island, and taking the light rail to work and then running back home.

I have faster and more confident in my running. My heart rate no longer spikes after a couple of miles; I can keep a consistent pace. I'm even doing actual intervals running at an 8 minute pace!

It is extremely helpful to me that the watch recommends exercises. These are a great default for when I'm not sure what I do. For the model of watch that I have, it gives a suggested running workout each day, e.g. "run at a 10:30 pace for 55 minutes."

I've also gotten to where running is its own reward. It makes me feel good, and I like seeing what I can accomplish.

It's also very validating to have data showing my progress! My past times exercising, my only real data came from running a 5K race and getting a time. Now I can see on my watch exactly what my current pace is; even if it feels like I'm running a 10 minute pace, if the watch says 11 minute pace then I get feedback that maybe my body is telling me what I want to hear so that I slow down.

First, I identified a replacement tool: Notion. The key things that I liked about Notion were:

• ability to collaborate with other Notion users
• ability to export usable content
• ability to synchronize
• features that I had never been able to consider with Evernote, such as arbitrary levels of nesting
• seemed to be some traction/other users

Since using it, I've already learned about other features such as the ability to create "databases" e.g. of places I want to hike.

Here's how I switched.

I'm in a very different place with respect to information management vs. where I was in 2009 when I was starting to use Evernote. As I've gone through all my imported Evernote notes in Notion, I handle them differently based on the type of content:

Contact data

these can go into Google contacts, or they can go into a Notion "contacts" database I created.

Life archive related

for example, family history information. These go into my life archive instead.

Links

these go into pinboard (the web site) instead

Receipts

these can often be destroyed.

Recipes

these go into Paprika (the app) instead

Within Notion, I have several top-level pages:

Inbox

just like for Evernote, this is where new content goes when I'm not sure where to put it yet. (Or, maybe it can be deleted after I act on it!)

active task reference

content related to current active tasks, e.g. information about an appointment I need to schedule.

ideation

ideas about stuff.

reference

information I may need to reference, e.g. facts about cars.

archive

historic content that still needs to be in Notion vs. another system, e.g. a copy of my Hallmark movie reviews.

It can also be helpful to have a page keep until 2025, keep until 2026 etc where you put notes that you might want to keep for a while but then will destroy. That way you don't have to go through all your content looking for old stuff.