How I use Org Mode — Bill de hÓra

I’ve mentioned more than once how effective I find org-mode as a productivity tool and organiser, without really explaining why. This post describes how I use org mode and why it’s been such an important application for me for well over a decade.

The first thing I should say—my setup is lightly configured. As a tool built on emacs, org-mode is arbitrarily customisable and as a result extraordinarily powerful. And so by lightly configured, I mean to say, a set up barely scratching the surface of what it can do. But there is some reasoning behind why I’ve reduced and avoided customisation over time. First, emacs is not my primary environment: these days I use emacs exclusively for org-mode and am increasingly less fluent with its commands and concepts, never mind writing elisp snippets. Second, and related, a lot of customisation involves learning new key combinations or bindings. I want to use and remember the minimal amount of commands to get things done because I want the focus to be on getting through the work, and less on how the work is organised or tracked—add the thing, do the thing. Third, how I’ve come to organise things to be done over time requires less ‘set up’ and thus less customisation (while this may be self-fulfilling, it speaks to org-mode’s core design being a good one that supports my basic workflow). A more invested emacs user would come at things differently and get more benefit, but for me, the principle of least power has come to work well.

There are three elements to the approach: (i) minimising the number of conceptual buckets for tasks, (ii) organising tasks across time horizons, (iii) a focus on regular progress that also allows for killing work.

Minimising the number of conceptual buckets for tasks

I have two files. One for myself (dehora.org), one for work (work.org). Both files have an archive file, which I move tasks to at the end of each year. This took a while to reach, evolving between very granular (eg, subject and topic level files) to very coarse (eg, one file for everything) to this. Emacs is buffer rather than file driven—the cost of a lot of files isn’t that high, making it easy to have multiple files (and folders) to organise projects or topics, especially if you’re fluid with traversal. On the other hand, time has shown there are two stable things organise to things to do around: personal and work. And so, this has been the set up for some years. (the init file is for the Beorg mobile app, which we’ll get to.)

org-mode-files — org mode personal files

Until a couple of years ago, I also had a notes file for snippets and capture, but again since emacs is not a primary environment, this, fell out of use. Today I keep code notes in VSC (as a rolling scratch file), written notes in Ulysses (as sheets). For a read later stack, I Instapaper’s close to perfect capture integration, plus, there is no better online reading experience than Instapaper’s. I am also trying out some tools (like Obsidian) or interested in trying (like DEVONThink) for personal knowledge management, for which I have no good story. So arguably not simpler on the surface, but things are they are where they need to be, such that I can find them without really hunting for them. Again: org mode plus emacs can do most or all of this, but I prefer to keep it focused on the things to be done job.

I have the wonderful Beorg app installed on iPhone and it has more or less solved the problem of task capture and completion when on the go. It also works very well on iPad. Beorg is easy to setup and use once you move the org files to where it can easily find them (I sync the personal file in iCloud, and put the work file elsewhere to avoid sync). After any number of attempts to get a usable org mode workflow with a phone, away from its desktop single user paradigm, Beorg has more or less removed the conflict problem (I have developed a muscle memory to reload org files on the laptop akin to continually saving files in an editor). It also has a nice capture option for web pages, although I mostly send those to Instapaper to build up a reading stack.

Organising tasks and goals across time horizons

Within the files, there are three top level groups for goal setting. First, long term goals and ambitions that can have a horizon of years. Second, a yearly or so horizon, for what I call annual goals. Third near to mid-term goals that happen day to day and week to week. There top level groups for long and annual and each week gets a top level with the new week added to the top of the file. Now, work and personal both have long term and yearly goals, but are different at the third, near term grain. In work the grain I use is a six week cycle (two per quarter for those who work in shops organised around quarters). So work outcomes will mapped to be “Cycle 1”, “Cycle 2” and so on:

  * wk3...
  * wk2...
  * wk1...
  * Cycle 1...
  * 2022 Goals...
  * Long Term Goals...

For personal organisation, calendar months: so it’s “January”, “February”, etcetera:

  * wk3...
  * wk2...
  * wk1...
  * Jan Goals...
  * 2022 Goals...
  * Long Term Goals...

This keeps things nice and flat. You could nest the weeks inside the months to build a tree; I don’t to reduce the amount of folding, the intuition being, if the structure is getting nested I’m doing ‘something other’ than tracking things to do. I run an ongoing internal debate on whether to shift the personal bucket to six-week cycles and suspect that will happen at some point. In any case, all things are organised on three time horizons.

Associating along time horizons

Goals across the time horizons are loosely related using org-mode’s inbuilt internal links feature. For example the long term goal “proficient in math” will have a a “custom_id” field with the value “ltg_math” placed in the properties drawer for the goal, resulting in an entry like this:

  * Long Term Goals
  ** Be proficient at mathematics
    :PROPERTIES:
      :custom_id: ltg_math
    :END:

Your mileage may vary but some long term goals are very long term, or perhaps are evergreen. For example, a goal like one this might never be done for me.

That “ltg_math” goal can be associated with an annual goal to read a particular book, and in turn that annual goal be linked to multiple other goals. In this example, “Read Strang Linear Algebra for Everyone“ is associated with the long term math goal, and also, another 2022 annual goal to read 24 books:

  * 2022 Goals

  ** Read Strang Linear Algebra for Everyone 
    :PROPERTIES:
      :custom_id: ag_strang_book
      :goal_link: [[#ltg_math]]
      :goal_link: [[#ag_books]]
    :END:

  ** Read 24 Books
    :PROPERTIES:
      :custom_id: ag_books
    :END:

Finally, the book goal can be associated with a near term goal to read a chapter:

  * wk4

  ** Read Strang Chap2
    :PROPERTIES:
      :custom_id: g_strang_book_c2
      :goal_link: [[#ag_strang_book]]
    :END:

There’s no rigid hierarchy or set grain here, so you can avoid deeply nested org files and agonise less over where to ‘put’ things—it’s largely in time order. You could just as easily connect “Be proficient at mathematics” to “Read Strang Chap2” directly. The aim, really, is to get a general sense that what you’re doing in the short term is paying into the longer term objectives you have. This approach also works well enough for the concept of a project if you prefer to have a direct representation for those.

The approach has been robust enough to not need a lot of bookkeeping or precision. although you can of course build rolled up views to track things, and see how much you’re paying into various goals, depending on how much you want to leverage org-mode. The ability to have many to one or many to many relationships over time provides what is perhaps the deeper thing—making progress can be optimised by finding tasks that have leverage or covering power over multiple goals.

The Weekly

Weekly is the bread and butter thing I do with org mode. Each week of the year has a top level group “wk1”, “wk2” as mentioned above. Inside the week is a flat list of to do items to get through.

I’m aware the calendar week thing drives some people nuts (‘what the hell _date_ are we talking about’). But over time I have come to orient around weeks rather than dates (for example I can tell you Cyber Week 2022 is 45 weeks away, on week 47, from the time of writing, week 2).

Sometimes a task needs a breakdown. This mostly happens in the work file (for example needing to follow up with n people or teams) or something was a bit more involved than anticipated. For that I’ll just put subtasks under a task: org mode is an amazing outliner and works at arbitrary depth. If I want to track the task completion I’ll add “[/]” to it: org mode will track the ratio of tasks done to not done as they are completed (and like everything else discussed here, you can do a lot more with this):

org-mode-subtask-tracking — subtask tracking

A focus on progress that allows for killing work

I have five states for tasks and goals: todo, doing, done, later, and nope.

I’m very willing to sacrifice one task to finish out another task, rather than, making incremental yet incomplete progress across all things. I find it helpful to agree with myself that something isn’t going to get done, either now, or maybe ever. It’s been better than having a scroll of ‘doing’ or ‘todo’ items clogging up my attention. And if I see a long list of deferred or cancelled items at the end of a week, that’s a signal to maybe next week focus a bit better next, or curb my enthusiasm to a realistic level. So, the later (defer) and nope (cancel) states are probably the most important customisations I’ve learned to make over the last decade.

The week’s todo items can be scheduled, and deadlined: org-mode has those two built into an extremely powerful calendaring and time management capability, which also allows for things like clocking in/out. Some get deadlines or scheduled to a particular day, some don’t. Scheduling helps a lot with one of the the agenda views default views, “agenda for current week or day” (`ctrl-c a a`):

In the spirit of least power. I use pretty much default agenda setup. If you look online, you’ll see people have done incredible things with the agenda, such that they can effectively work in the agenda rather than treat it as a view as I do. it’s basically an app of itself inside org mode and probably the one part I wish I had a bit more gumption to dive into and invest in.

I don’t religiously schedule every task into a day or half day, but generally I find it helps with focus and personal discipline to do so. The way I do this is Franklin style—at the end of day reviewing what got done and what can go into tomorrow, as well as shuffling around subsequent days; in morning reviewing what needs to get done and sequencing for that day. I neither am as thorough as Franklin or as early a riser, so the what good will I do today part regularly gets dropped, but it works by virtue of simplicity to have become a habit. At the end of the week, there’ll be a weekly version, reviewing what got done this week and what needs to get done next week, usually on Friday.

Getting There

This setup took some years to get to. I’ve been using org mode for well over a decade and the approach has been more or less like this for nudging into five years. One upside to this relatively dumb approach is having the same overall model for both personal and work tasks. The major improvement in recent years has been Beorg for iOS. Without Beorg I believe I would have moved off org mode by now—mobile has become too central to how we live and work to be an afterthought.

Finally, to reiterate, this is barely scratching the surface of what org mode can do. For example, I didn’t use the agenda for years, preferring to work almost exclusively in the file directly and prioritise/order the items, but agenda mode is extremely useful. You can with some investment get a hell of a lot out of org mode—every feature it has is effectively a programmable capability, build on the power of emacs, and in turn the power of lisp, both from the get go designed to enable improvement in place, the way a painter is enabled by oil. I think especially if you use emacs for anything else, or have a very specific setup in mind that’s going to be good for you, it’s worth going a bit deeper than I have. So to be clear; the fact that I assiduously minimise customisation is no badge of honor or indication of efficacy—far from it. Even then, org mode has brilliant defaults and for me has been a great way to keep on top of tasks out of the box.

The best thing I can say about org mode is this—when you need a task manager to really work is when you are at your busiest, and org mode has never failed that test.