Generally, there was some friction to capturing tasks on the go. Typing on a phone is tedious, and by the time I’m back at my computer, I’ve often forgotten half of what I needed to capture. Capturing all tasks that came up is probably the most important aspect of task management.

Enter voice notes. They’re fast, natural, and perfect for brain dumps. But then you’re stuck with a pile of audio files that need to be transcribed and processed. This was what the Todoist ramble feature offered to solve, and I wanted a rudimentary replica of this. Ultimately, what I made works really well and allows me to even record audio from my smart watch to be processed into my inbox file. It is available here.

The Problem

I wanted to:

• Speak naturally: “Call the dentist next Wednesday, finish the quarterly report by Friday, and study pharmacology tomorrow”
• Have it automatically become properly formatted org-mode tasks with deadlines, scheduled dates, tags, and priorities
• Do it all locally (no sending my voice to cloud APIs)

The Solution

I built a Python script that:

1. Watches a folder for new audio recordings (synced via Syncthing from my phone)
2. Transcribes them locally using OpenAI’s Whisper
3. Parses natural language to extract:
   • Individual tasks from rambling speech
   • Dates (“next Wednesday”, “by February 26th”, “tomorrow”)
   • Context tags (@home, @computer, @phone)
   • Priorities (“urgent”, “important”)
   • Whether something is a deadline vs. scheduled date
4. Generates org-mode entries with proper formatting and properties
5. Archives the audio for reference

Example

I record on my phone:

Call the dentist next Wednesday, finish quarterly report by Friday tag that as important, and study cardiovascular pharmacology on Tuesday

The python script automatically creates in my inbox.org file:

* TODO Call the dentist
SCHEDULED: <2026-02-12 Wed>
:PROPERTIES:
:RECORDED: [2026-02-08 15:30]
:RECORDING_FILE: Voice_001.m4a
:TRANSCRIPT: Call the dentist next Wednesday...
:END:

* TODO Finish quarterly report
DEADLINE: <2026-02-14 Fri>
[#A]
:PROPERTIES:
:RECORDED: [2026-02-08 15:30]
:RECORDING_FILE: Voice_001.m4a
:TRANSCRIPT: Call the dentist next Wednesday...
:END:

* TODO Study cardiovascular pharmacology :@notetaking:
SCHEDULED: <2026-02-11 Tue>
:PROPERTIES:
:RECORDED: [2026-02-08 15:30]
:RECORDING_FILE: Voice_001.m4a
:TRANSCRIPT: Call the dentist next Wednesday...
:END:

How It Works

The script uses:

• faster-whisper for local transcription (no API calls, fully private)
• watchdog for monitoring file system changes
• Regular expressions for parsing natural language dates and keywords
• Pattern matching to split rambles into discrete tasks

It handles edge cases like:

• Files syncing via Syncthing (which don’t always trigger normal file creation events)
• Multiple date formats (“tomorrow”, “next Friday”, “February 26th”)
• Distinguishing deadlines from scheduled dates based on context (“by Friday” vs “on Friday”)
• Automatic tagging based on keywords

Running It

The script runs as a background service on my Mac (via launchd), constantly watching the sync folder. When a new voice memo appears, it’s processed within seconds.

The Workflow

The friction of capture is real. Every extra step between “having a thought” and “having it in your system” is a chance for that thought to be lost. Voice notes remove that friction, but only if they’re automatically processed into your actual workflow.

Now my capture flow is:

1. Pull out phone or tap record on my watch
2. Record voice note
3. Done

The tasks appear in my org-mode inbox, properly formatted, with the right dates and contexts. No typing, no manual processing, no friction. I do need to later process my inbox to ensure it gets refiled to the correct spot, but that’s part of my daily review workflow.

Here are all the addons I find useful although noting that I have more addons as well.

• A New Card Counter Speed vs Retention Forecast Graphs
• Add Hyperlink
• Add Table
• Advanced Browser
• Advanced Review Bottom Bar
• AnkiConnect
• AnkiHub
• Ankimote - remote to control Anki from your phone
• Batch Editing
• BetterSearch
• Clickable Tags v20
• Colorful Tags Hierarchical Tags
• Contanki - Controller Support for Anki beta
• Fastbar- with nightmode support
• FSRS Helper Postpone Advance Load Balance Easy Days Disperse Siblings
• Image Occlusion Enhanced
• Malleus Anki Helper Addon
• Mini Format Pack
• More Decks Stats and Time Left
• NoteSync
• Onigiri Beta - A more modern Anki for your studies by Peace
• Progress Graphs and Stats for Learned and Matured Cards
• rebuildempty some or all filtered decks
• ReColor
• Speed Focus Mode auto-alert auto-reveal auto-answer
• Study Time Stats
• Symbols As You Type
• TabOut of Cloze
• Top toolbar icons by Shige
• UpToDate Addon

Obsidian

Obsidian is an okay electron based markdown editor for note taking. My primary reason for using it over other text editors such as Emacs is its mobile and cross platform support. Mobile support remains crucial for me because, the main time I reference my notes is while at work so I wanted a more fully featured application to view my notes on mobile as opposed to using Emacs within Termux on Android. I do occasionally use Emacs to edit my markdown files in my obsidian vault using obsidian.el.

My notes are hosted onto a website using netlify (https://junior-doctor-notes.netlify.app/) which makes it easy to access my notes for reference on any computer while at work. In addition, if I ever want to edit my notes while at work, I could do so by logging into github and editing the repository to which they are hosted with github’s native markdown editor. Although it lacks all the features, it gets the job done.

Here are all the obsidian extensions I use:

• Advanced Tables
• Auto Link Title
• Code Editor Shortcuts
• Dataview
• Dataview serializer
• Excalidraw
• File Hider
• Footnote Shortcut
• Git
• Notebook Navigator
• Obsidian_to_Anki
• Omnisearch
• Past URL into selection
• Recent Files
• Smart Typography
• Text Extractor
• Update modified date
• Vim Yank Highlight
• Vimium
• Vimrc Support
• Zotero Integration

Zotero

Zotero is a reference manager. I mainly use it to store my textbooks and read from. I use the better bibtex extension to ensure I always have an updated .bib file to use across my applications. I also use the zotmove extension to move selected entries to my google drive or a directory with syncthing to ensure my textbooks and papers are readable on different platforms.

Calibre

I use Calibre on my macos computer to manage my books (e.g. fiction and non-fiction books). I don’t use it for textbooks and research papers (this goes to zotero; see above).

KOreader

KOreader is probably the best way to read epubs on my phone. I also use KOreader (and pretty much only KOreader) on my jailbroken kindle with great success.

Medicine Resources

Applications

A list of android applications, I find useful to study with or are useful references at work:

• MDCalc
• Eye manual
• APLS
• Nerve Block
• Emergency Procedures
• PalliMEDS
• Opioid Calculator
• Thinksulin

Websites

• Therapeutic guidelines
• UpToDate
• AMHonline
• LITFL & Part One
• Derranged Physiology
• IBCC
• ACI guidelines
• Local hospital policies, procedures and guidelines

I had a few “difficult” cannulas I had been putting off—mostly because the patients were asleep, and I am a merciful coward—but I realised there was no better use of the morning than converting these students into free labour.

Introduction

There is something deeply unsettling about the phrase, “Is it okay if the medical student has a go?” It is usually whispered while a 20-year-old is advancing a needle toward your forearm with the intensity of someone defusing a bomb, despite having only learned bomb disposal from a WikiHow article.

What we are really saying is: “Would you be willing to let this terrified youth, who has hitherto only practiced on plastic arms, pierce your tender flesh with a sharp object while I watch and silently pray I don’t have to intervene?”

And yet, this remains the core paradox of our profession. At some point, every doctor—from your friendly local GP to the “giga chads” of cardiology who “wear the hides of vanquished foes” —had to perform a procedure for the very first time on a real, living, and hopefully consenting human. Medicine has a nasty habit of requiring experience for competence, meaning the only way to become safe is to start off distinctly unsafe.

We are left with the paradox of the healing apprentice: How do we teach medicine without betraying it?

Patients as a Means and an End

Philosophy 101 tells us we shouldn’t treat people merely as a means to an end. This becomes awkward when you realise medical education essentially views patients as very complex, breathing textbooks.

There is a tension here. When a patient agrees to be a guinea pig, I feel a genuine enjoyment in my role as a bedside teacher. But is that enjoyment selfish? Doctors are often criticised for finding pathology “cool”. We might call a rare disease “exciting” or “crazy”, while to the patient it is “life altering”.

But here is the counterargument: Is it ethical to shield patients from learners if the alternative is a future filled with incompetent doctors? If we refuse to treat today’s patients as a teaching opportunity, we ensure that tomorrow’s patients suffer from our short-sighted strive for virtue.

The reality is simple. You need practice. You need the “black humour and insensitive language” that helps you cope. And unfortunately, you need to sometimes be rubbish at something, ideally while someone more experienced—like a taciturn and serene senior—is watching, ready to step in before you accidentally puncture an artery.

This doesn’t mean the patient disappears as a moral subject. It means we have to care for them differently: not as passive recipients of perfect care, but as co-participants in medicine’s grand, messy apprenticeship. As I’ve seen, some patients actually “revel in being ‘rare cases’” and join in on grilling the candidates.

And sometimes, the greatest act of moral courage in healthcare isn’t what the doctor does — it’s what the patient lets them do.

Embracing the Chaos

Medicine loves certainty in the same way that cleaning product advertisements love “before-and-after” photos. Neat, definitive, and sparkling. What we omit is that reality is the “during” photo: a blurry, chaotic mess.

We compare patients post-admission to their state pre-admission and see a definitive change. But the decisions that led there are often plagued by uncertainty. No amount of simulation or exams can eliminate the fact that medicine is often a carefully weighed coin toss taking inputs from experience, improvisation, and gut feeling. Both Daniel Kahneman (2011) and Groopman (2007) speak to terrifying complexities of thinking that makes up this job.

Added to this is the pressure of time. There is a brilliant analogy in How Doctors Think (Groopman 2007) that captures the cognitive load perfectly

Imagine watching a train go by. You are looking for one face in the window. Car after car passes. If you become distracted or inattentive, you risk missing the person. Or, if the train picks up too much speed, the faces begin to blur and you can’t see the one you are seeking. “That’s what primary care medicine is like”

I find this extends to medical practice as a whole, not just primary care. When you are an intern, the train is always moving at Mach 10. Part of what separates the experienced from the inexperienced isn’t just knowing the face you are looking for, but having the ability to decide which carriages require extended deliberation and which ones can just blur on by.

The Ontology of Expertise

But when does the inexperienced become the experienced? When does a medical student actually become a doctor? When does an intern go from incompetent floundering intern to competent resident?

Legally, it’s what the pay cheque says. But spiritually? Is it the first time you prescribe paracetamol without asking an adult? Is it the first time you get an intra-osseous access in an arrest?

The uncomfortable truth is that competency isn’t binary. You don’t go to sleep a danger to society and wake up a healer.

To explain this, I’m going to borrow from Lev Vygotsky’s “Zone of Proximal Development,” but because I’m a child, I will explain it using Pokémon.

Think of a medical student as a Charmander. Cute, full of potential, but if left alone to battle high level trainers on victory road (the Emergency Department), they will faint immediately. The Zone of Proximal Development is the battle they can win if they have a trainer using potions on them (a Consultant listening to their incomplete histories) and substituting them out for more experienced pokemon (a Registrar) when necessary.

True expertise is evolving into Charizard. You no longer need the trainer. You can handle the battle alone, but you know when to turn to your trainer if need be (i.e. true expertise is being able to handle the cases and just as important, knowing when you can’t). However, expertise isn’t just about Flamethrowing the correct diagnosis. A massive chunk of the job is untestable. It is the soft skills. It is knowing how to de-escalate an angry relative, or perhaps the most valuable skill in the hospital: knowing exactly when to shut your mouth during the morning handover so you don’t extend the meeting by twenty minutes.

Medicine is simply the long, slow grind of XP farming.

Learning as a Ritual

Medicine survives by teaching. The only thing more dangerous than a trainee… is a doctor who forgot they once were one. Every competent doctor is standing on a pile of someone else’s patience. Those students who I supervised that morning got the cannula. The student moved on. And medicine, quietly and unceremoniously, began again.

References

This table can be used to generate graphs using something like gnuplot. For example:

reset
set title "Duration over time"
unset key
set xdata time
set timefmt "%Y-%m-%d %a"
set format x "%d/%m"

set xtics "2023-05-13 Sat 00:00", 86400*1

set ydata time
set format y "%H:%M"
set yrange [0:7200]

set boxwidth 86400*0.8 absolute
set style fill solid 0.1 border -1
plot data using 1:((timecolumn(3,"%H:%M"))*1) smooth frequency with boxes

This produces the image above. You can change it up to graph different data together to find new relationships. For example time of day against focus to figure out which time of the day you tend to be more focused.

How its done

A function is defined to grab last clocked duration of the item at point

(defun my/last-duration ()
  (let* ((e (org-element-at-point))
         (type (org-element-type e)))
    (when (and (eq type 'drawer) (string= (org-element-property :drawer-name e) "LOGBOOK"))
      (let ((contents-beg (org-element-property :contents-begin e)))
        (save-excursion
          (goto-char contents-beg)
          (let* ((e (org-element-at-point))
                 (type (org-element-type e)))
            (when (eq type 'clock)
              (org-element-property :duration e))))))))

Another function is used to grab the name of the last clocked task

(defun my/get-last-clocked-task ()
  "Get the name of the last clocked task."
  (save-excursion
    (goto-char (car org-clock-history))
    (nth 4 (org-heading-components))))

The following function is used to prompt the user for data (to be run when clocking out from a task)

(defun my/org-clock-out-hook ()
  "Run after clocking out of a task to display time clocked in."
  (when (yes-or-no-p "Was that a deep work session?")
    (save-excursion
      (org-back-to-heading)
      (search-forward ":LOGBOOK:" nil t)
      (let* ((org-clocked-duration (my/last-duration))
             (org-last-clocked-task (my/get-last-clocked-task))
             (org-capture-templates
              `(("d" "Deep Work Task" table-line
                 (file ,(concat org-roam-directory "deep_work.org"))
                 "| %u | %(format-time-string \"%H:%M\" (float-time)) | %(with-current-buffer (org-capture-get :original-buffer) org-clocked-duration) | %(identity org-last-clocked-task) | %(prin1-to-string (yes-or-no-p \"Did you complete the task\")) | %^{Activty Type|Flashcards|Notetaking|Questions|Work|Planning|Writing|Coding} | %(string (read-char-from-minibuffer \"[1-5..]:How focused were you? \" '(?1 ?2 ?3 ?4 ?5))) | %^{Location|Home|Coffee|Library} | %^{Techniques|nil|Timer|Recording} | %? "
                 :unnarrowed t))))
        (org-capture nil "d")))))

In detail (when (yes-or-no-p "Was that a deep work session?")... Prompts the user “Was that a deep work session?”, where if the user responds with true, then the rest executes. This way, more trivial non-deep work sesssions can be opted out from being tracked.

...
(save-excursion
      (org-back-to-heading)
      (search-forward ":LOGBOOK:" nil t)
...

Saves the point in the buffer, goes to the heading and puts the cursor at the first instance of “:LOGBOOK:”. Hence I don’t anticipate this to work if there is text in the properties drawer that has “:LOGBOOK:¹”.

...
(let* ((org-clocked-duration (my/last-duration))
             (org-last-clocked-task (my/get-last-clocked-task))
             (org-capture-templates
              `(("d" "Deep Work Task" table-line
                 (file ,(concat org-roam-directory "deep_work.org"))
                 "| %u | %(format-time-string \"%H:%M\" (float-time)) | %(with-current-buffer (org-capture-get :original-buffer) org-clocked-duration) | %(identity org-last-clocked-task) | %(prin1-to-string (yes-or-no-p \"Did you complete the task\")) | %^{Activty Type|Flashcards|Notetaking|Questions|Work|Planning|Writing|Coding} | %(string (read-char-from-minibuffer \"[1-5..]:How focused were you? \" '(?1 ?2 ?3 ?4 ?5))) | %^{Location|Home|Coffee|Library} | %^{Techniques|nil|Timer|Recording} | %? "
                 :unnarrowed t))))
        (org-capture nil "d"))
...

Uses a table-line org-capture template to fill the last clocked duration, task name to parts of the template and clock out date and time, and prompt the user for additional information such as:

• Whether the task was completed
• The type of activity being completed
• Focus level (quantitatively from 1 to 5)
• Location
• Any productivity techniques that were used
• Leaves the cursor at the additional notes part of the table

Finally, (add-hook 'org-clock-out-hook 'my/org-clock-out-hook) adds the function as a hook to org-clock-out-hook so when clocking out of a task, it is run.

Final Configuration

In total this should be able to be incorporated into your cofig with reasonable success:

(defun my/last-duration ()
  (let* ((e (org-element-at-point))
         (type (org-element-type e)))
    (when (and (eq type 'drawer) (string= (org-element-property :drawer-name e) "LOGBOOK"))
      (let ((contents-beg (org-element-property :contents-begin e)))
        (save-excursion
          (goto-char contents-beg)
          (let* ((e (org-element-at-point))
                 (type (org-element-type e)))
            (when (eq type 'clock)
              (org-element-property :duration e))))))))

(defun my/get-last-clocked-task ()
  "Get the name of the last clocked task."
  (save-excursion
    (goto-char (car org-clock-history))
    (nth 4 (org-heading-components))))

(defun my/org-clock-out-hook ()
  "Run after clocking out of a task to display time clocked in."
  (when (yes-or-no-p "Was that a deep work session?")
    (save-excursion
      (org-back-to-heading)
      (search-forward ":LOGBOOK:" nil t)
      (let* ((org-clocked-duration (my/last-duration))
             (org-last-clocked-task (my/get-last-clocked-task))
             (org-capture-templates
              `(("d" "Deep Work Task" table-line
                 (file ,(concat org-roam-directory "deep_work.org"))
                 "| %u | %(format-time-string \"%H:%M\" (float-time)) | %(with-current-buffer (org-capture-get :original-buffer) org-clocked-duration) | %(identity org-last-clocked-task) | %(prin1-to-string (yes-or-no-p \"Did you complete the task\")) | %^{Activty Type|Flashcards|Notetaking|Questions|Work|Planning|Writing|Coding} | %(string (read-char-from-minibuffer \"[1-5..]:How focused were you? \" '(?1 ?2 ?3 ?4 ?5))) | %(my/fast-org-selection '(\"Home\" \"Coffee\" \"Library\") \"Where were you? \") | %^{Techniques|nil|Timer|Recording} | %? "
                 :unnarrowed t))))
        (org-capture nil "d")))))

(add-hook 'org-clock-out-hook 'my/org-clock-out-hook)

Improvements

I quite like the dialogue when entering TODO keywords (i.e. using org-fast-todo-selection). I took inspiration from this answer on stackexchange regarding fast effort selection and wrote this function

(defun my/fast-selection (values prompt)
  "Modification of `org-fast-todo-selection' for general use.
'VALUES' is a list of accepted entries for user input and 'PROMPT' is a string.

Inspired from https://emacs.stackexchange.com/questions/59424/org-set-effort-fast-effort-selection"
  ;; Format effort values into an alist keyed by index
  (let* ((fulltable (seq-map-indexed (lambda (e i) (cons (car e) (string-to-char (int-to-string i))))
                                     (mapcar 'list values)))
         (maxlen (apply 'max (mapcar
                              (lambda (x)
                                (if (stringp (car x)) (string-width (car x)) 0))
                              fulltable)))
         (expert t)
         (fwidth (+ maxlen 3 1 3))
         (ncol (/ (- (window-width) 4) fwidth))
         tg cnt e c tbl subtable)
    (save-excursion
      (save-window-excursion
        (if expert
            (set-buffer (get-buffer-create " *Fast Selection"))
          (delete-other-windows)
          (set-window-buffer (split-window-vertically) (get-buffer-create " *Fast Selection*"))
          (org-switch-to-buffer-other-window " *Fast Selection*"))
        (erase-buffer)
        (setq tbl fulltable cnt 0)
        (while (setq e (pop tbl))
          (setq tg (car e)
                c (cdr e))
          (print (char-to-string c))
          (when (and (= cnt 0))
            (insert "  "))
          (setq prompt (concat prompt "[" (char-to-string c) "] " tg " "))
          (insert "[" c "] " tg (make-string
                                 (- fwidth 4 (length tg)) ?\ ))
          (when (and (= (setq cnt (1+ cnt)) ncol)
                     ;; Avoid lines with just a closing delimiter.
                     (not (equal (car tbl) '(:endgroup))))
            (insert "\n")
            (setq cnt 0)))
        (insert "\n")
        (goto-char (point-min))
        (unless expert (org-fit-window-to-buffer))
        (message (concat "[1-9..]:Set [SPC]:clear"
                         (if expert (concat "\n" prompt) "")))
        (setq c (let ((inhibit-quit t)) (read-char-exclusive)))
        (setq subtable (nreverse subtable))
        (cond
         ((or (= c ?\C-g)
              (and (= c ?q) (not (rassoc c fulltable))))
          (setq quit-flag t))
         ((= c ?\ ) nil)
         ((setq e (or (rassoc c subtable) (rassoc c fulltable))
                tg (car e))
          tg)
         (t (setq quit-flag t)))))))

So that something like (my/fast-org-selection '("Home" "Coffee" "Library") "Where were you? ") can be used to request user input. So you can achieve a somewhat more streamlined data entry with:

(defun my/org-clock-out-hook ()
  "Run after clocking out of a task to display time clocked in."
  (when (yes-or-no-p "Was that a deep work session?")
    (save-excursion
      (org-back-to-heading)
      (search-forward ":LOGBOOK:" nil t)
      (let* ((org-clocked-duration (my/last-duration))
             (org-last-clocked-task (my/get-last-clocked-task))
             (org-capture-templates
              `(("d" "Deep Work Task" table-line
                 (file ,(concat org-roam-directory "deep_work.org"))
                 "| %u | %(format-time-string \"%H:%M\" (float-time)) | %(with-current-buffer (org-capture-get :original-buffer) org-clocked-duration) | %(identity org-last-clocked-task) | %(prin1-to-string (yes-or-no-p \"Did you complete the task\")) | %^{Activty Type|Flashcards|Notetaking|Questions|Work|Planning|Writing|Coding} | %(string (read-char-from-minibuffer \"[1-5..]:How focused were you? \" '(?1 ?2 ?3 ?4 ?5))) | %(my/fast-org-selection '(\"Home\" \"Coffee\" \"Library\") \"Where were you? \") | %^{Techniques|nil|Timer|Recording} | %? "
                 :unnarrowed t))))
        (org-capture nil "d")))))

Though in hindsight, I much prefer the fast tag selection menu where one can tab out for free user output.

My main goal out of doing a dopamine detox was to increase my productivity by improving my attention span. It seems that removing distractions was essential to a dopamine detox (Meurisse 2021; Knapp and Zeratsky 2018) and reaching deep work (Newport 2016) and no better way to start that than with open systems.

Open Systems

The idea of an open system is a source of enjoyment which is effectively endless (e.g. Facebook feeds but even things like messages¹). This ultimately revolves around short form videos and memes. I figured there was effectively two ways to “close” an open system:

1. Not engage in the open system at all, by going pretty much cold turkey or making it so annoying to use that you only use it productively
2. Setting a limit (such as time or frequency) on an open system so you’re unable to access it after you reach the limit

I used approach 1 for facebook, instagram and reddit. I uninstalled the applications from my iPad and phone. If I have to use instagram and facebook I use them inside the browser but also set a time limit as well. Viewing reels inside of the browser is such an unpleasant experience that I don’t do it for very long if I ever do it. If I did ever really need to use the app version, I would install it but then quickly uninstall it after completeing whatever required me to use the app².

I used approach 2 for youtube mainly. I uninstalled/disabled the Youtube app from my phone and iPad. This worked quite well provided that I had the self control to not use the application. On my laptop I used the addon LeechBlock which limits the time I can access open systems to a certain duration³.

On Social Media

You’ll also find a propensity of videos describing experiences and advice regarding quitting social media and it is almost always mentioned in passing when discussing a dopamine detox

• Quit social media | Dr. Cal Newport | TEDxTysons
• i quit social media, and it was the best decision of my life
• The Actual Benefits of Quitting Social Media (Dopamine Detox)

Some people suggest the benefit of quitting social media on their mental health. Quotes such as the following come to mind when discussing such things:

“If you try to be someone else, you’ll become nobody at all. The only great person you have the possibility of becoming is the greatest version of yourself, and that is a pretty great person.

I never really found myself to be using social media for posting and improving my self image to begin with, so my main benefit from detoxing derrived from not engaging in unproductive behaviours.

The Daily Highlight

This is the idea that you set one task that should be done for that day as the highlight of the day. I realised the importance of setting a daily highlight on reflecting halfway into my 8 week placement realising that medical school thus far this year has felt like a blur loosely consisting of:

1. Waking up
2. Going to placement
3. Going home tired
4. Studying for a bit
5. Go to sleep

Importantly, I was letting placement be the dominant thing in the day. Instead, the purpose of a highlight is essentially what accomplishment or moment you want to savour for that day. I began by picking highlights based on urgency (i.e. What’s the most pressing thing I have to do today), but it felt like I was reacting to my circumstances and my highlights were mainly studying or medicine related tasks.

Part of the process of a dopamine detox is to substitute hyperstimulatory activities with less stimulating activities (i.e. instead of watching Netflix, going gym or reading). To do this, I made my highlights more related to satisfaction and joy.

Importantly, do not choose a highlight that cannot be completed in that day. I found that this was bad because:

1. I didn’t finish it
2. Once I realised it was too long and didn’t complete it, I’d become unmotivated

Knapp and Zeratsky 2018 recommends choosing a highlight that takes sixty to ninety minutes.

Reflect

I will also try to reflect on the day to see if I managed to complete my daily highlight, how I feel about detoxing, where I wasted time and in general. I currently just use an org-roam dailies capture template for this:

("r" "reflection" plain
             (file "~/reflection.org")
             :target
             (file+head "%<%Y>/%<%B>/%<%Y-%m-%d>.org" "
:PROPERTIES:
:ENERGY: %^{Energy|~|1|2|3|4|5|6|7|8|9|10}
:FOCUS: %^{Focus|~|1|2|3|4|5|6|7|8|9|10}
:HIGHLIGHT: %^{Highlight achieved|yes|no}
:END:
#+title: %<%A, %d %B %Y>
#+filetags :Dailies: "))

Where ~/reflection.org is:

* Reflection
- Today's Highlight :: %(mapconcat 'identity (org-ql-select (org-agenda-files) '(and (ts :on today) (tags "highlight")) :action '(org-get-heading t t)) " ")
- Tactics tried today :: %^{Tactics tried}

** How it went
%^{How it went}%?

** Moment I'm grateful for tomorrow
%^{Moment I'm grateful for}

** What to try for tomorrow
%^{What to try (again) for tomorrow}

This is the function to pull today’s highlight. It uses org-ql.

(mapconcat 'identity
           (org-ql-select
             (org-agenda-files)
             '(and (ts :on today)
                   (tags "highlight"))
             :action '(org-get-heading t t))
           " ")

I generally try to link the tactics using org-roam to nodes specific for that tactic. This way I’m able to show backlinks (using org-roam-dblocks from nursery) and lookup properties for days where I used this tactic such as whether the highlight was completed that day, what my focus and energy levels for that day was. For example I have a node specific for the tactic of writing down your highlight on a sticky note and putting it in front of you.

** Write it Down
Here are all the days on which I used this technique and managed to accomplish my highlight:
#+BEGIN: backlinks :filter (my/roam-db-filter "HIGHLIGHT" "yes" it)
- [[id:some ID][Friday, 10 February 2023]]
- [[id:some ID][Tuesday, 14 February 2023]]
#+END:

Here are all the days on which I used this technique and managed to accomplish my highlight:
#+BEGIN: backlinks :filter (my/roam-db-filter "HIGHLIGHT" "no" it)
- [[id:some ID][Tuesday, 28 February 2023]]
#+END:

Where my/roam-db-filter is:

(defun my/roam-db-filter (property value node)
    (equal value (cdr (assoc property (org-roam-node-properties node)))))

My Lessons

I found myself to still be as easily as distractible as before, the main change being that by limiting my access to distractions I am more likely to make progress on meaningful work. I’ve found some tactics that help me engage in deep work more readily, and while dopamine detoxing helped I found that it helps more in sustaining deep work rather than initiating it. In essence, I still need to plan out my day otherwise I’ll find some way to engage in a dopamine binge. In summary:

• I’m still distractible but have put up barriers to getting distracted
• Its still hard to initiate work unless you do other things (e.g. setting up a schedule)
• I’ll occassionally engage in a dopamine binge, but importantly I try not to get upset about it

References