Easing into Emacs org-mode

Productivity gains compound. So, every year I experiment tweaking my GTD system to get better at goals, planning, and, well… Getting Things Done. This is how things have gone otg-more so far compared with the Taskpaper system I’ve been using for most of the previous five years.


Emacs (and by extension, org-mode) has a different philosophy than other tools. The idea is to do everything in emacs, which is a bit out of line with the unix philosophy I’m used to of one tool doing things well (eg. vim) and being able to string them together. It has taken a while to get used to, but after years of vim, I have to admit, I am kinda sold on the idea of an interpreter in your text editor (sorry, vim) though I am not completely sold on emacs itself (though worried I may not be able to move back from org-mode, org-habit, and org-journal anytime soon.). As an experiment, it’s been positive. Is it life-changing? Possibly. Am I sticking with emacs and org-mode? Let’s see.

Taskpaper limitations

I’ve been a huge fan of Taskpaper for some time and it’s been key in making me effective in running both a multimillion dollar business and my personal life. So, not something I’d normally mess with. It has its limitations, however, and has innovated slowly, meaning having to work around its shortcomings. There are five big complaints I have:

  1. It is not date aware
    While there is support for ISO dates in Taskpaper, the app itself is completely ignorant of dates. This means you are often doing things manually (like due tasks rolling over or ticklers) which could easily be done automatically if it had a bit more intelligence.
  2. Automation and integration is difficult
    I’d like to have things happen like inserting a note under an item and being able to alter the due date in the same keystroke (this is easy with org-mode) to support easier tracking. Integrating with other items even for things as simple as mobile or email intergration is problamatic or non-trivial. I wanted to also take a bullet journal approach to recording daily meeting notes and have Taskpaper magically pick them up from there.
  3. Repeating tasks
    Most todo managers recognize that tasks often repeat at regular intervals. Taskpaper, not being date aware, has very limited support for repeating tasks (or habits) which makes things very manual as you move through your days and weeks.
  4. Tracking
    While I think Taskpaper is fantastic for organizing work, it’s support for tracking what has happened on tasks (and notes on them) is secondary. It’s there, but it definitely requires work though this perhaps might be my fault for not sycning into its expdcted workflwo enough.
  5. OSX only
    While there are some text editor clones of the taskpaper format, they almost universally lack the querying capability of native Taskpaper which is its killer feature. I’ve been looking at moving back to Linux proper and this was the last app that I felt I could not emulate or do without.

Admittedly, some of these are unfair, as Taskpaper prides itself on simplicity and is not an agenda or daybook per se, but it still does not make my life any easier it does not handle these things. So, enter emacs and org-mode.

Why Emacs?

Besides productivity, the other reason I was looking seriously at emacs was actually accidental (and a bit embarassing). What I was actually hoping was that I could move back from OSX to Linux and, as it happened, there was an excellent Taskpaper clone in emacs which seemed to address my major issue with every other text editor that had tried to have support for Taskpaper: it implemented the query language that Taskpaper has built in and folds into a sparse tree of the precise things you want to see in your hierarchical planner. Heaven.

Quite honestly, I am super impressed with what’s been done here. I modified it a bit for my terminal (since it’s very much set up for gui clients) and started playing with it. I liked it, but have to admit, what I relly wanted was someplace I could write a daily markdown file (a la bullet journalling), have that picked up in Taskpaper as tasks somehow, and manage things that way. Sadly, this currently doesn’t work in Taskpaper though I am impressed by how much you can automate at the moment in the thing (much more so than in the actual Taskpaper OSX client.)

The Setup

In the end though, I bit the bullet (and after a failed attempt, bit the bullet again) and moved things over from Taskpaper to a group of org-mode files that I felt mirrored as closely what I felt I was doing in Taskpaper.

In actual fact, I use a simple combination of emacs utilities with some extra extensions for the GTD system. So far, it seems to be working but it does both have advantagaes and disadvantages. The magic trifecta is Deft , org-mode, and its extensions (of which I use org-journal , org-habits , and org-super-agenda with ).


Deft mode is an excellent implmentation of Notational Velocity/AltNV in emacs; a fast, auto-filtering and quick note-taking application. I have it hotkeyed to CTRL-d so I can quickly search information in all my org-mode, dailies, and note-taking files. Deft mode is easy to install and configure and ridiculously trouble free. I have to admit, it’s made emacs feel very useful and integrated almost out of the gate, and also allows me to keep larger variety lists which have very little to do with managing my todos.


org-mode is a huge kitchen sink of an organizer combingin and agenda and todo list as well as a powerful search function and is a bit of a kitchen sink of an organizer as well as a markup format for hierarchically organizing information. Yeah, it sounds complex, but it works if you’re willing to deal with the steep learning curve (me: about 5 days till I was comfy in it and with emacs shortcutrs vs. vim.).

Org-mode extensions

I enhance org-mode with the org-journal mode which I use to keep a daily file in a yyyy-mm-dd org format which I then apply a template split into various sections which are tagged to give them context when I am using the quite powerful org-agenda.

Also, for some personal tracking I use org-habit which gives me a super nice habit “Seinfeld” graph of how often my habits are recurring and how I’m tracking against some personal recurring habit goals I am trying to inculcate in my terribly hard-to-train, lazy, monkey-brain. It’s a very nice setup (though needs improvement) but does keep me from kidding myself on how I’m performing over the long-term on some of my goals.

For the agenda view, I’ve enhanced org-mode with the excellent org-super-agenda which is a super handy way to sift and sort org-mode items in the agenda view and display them. Mine is set up to set up things like Today, the Habit Graph, Due Soon, Ove rdue, to give me an overview on what is coming and past, which caused a quantum leap in usefulness in org-mode upon using it. I highly recommend it and find it makes org-mode agenda view ridiculously more useful and bendable to your configurable will.

The System

While I may not be using it optimally, my system in org-mode is a riff off the system that works for me in Taskpaper which centres around the fact I generally manage things in terms of weeks’ worth of work. I try and manage the amount of things I ned to get done in a week via tags in the form :w35: for week 35 and then filter on that in terms of what I need to be doing as well as allowing me to forward roll things to future weeks I can deal with things without necessarily putting a solid due date on things (the trouble is, you have to grrom things pretty religiously to avoid a “snowplow” effect where everything just moves frombad weeks into future weeks and you can’t get things done.). The irritating thing is that I still have to roll week tags forward automaticaly, though I could probably use some elisp to have those things roll forward automatically when they get behind the current week.

Tagging ends up being an important part of the system, with things tagged by their major context (:loka:, :perso: or what have you, and since I can now use those tags directly in standard mark up notes, I also have things tagged as :logs:, :books:, :movies: and :journal: for various types of headings in the text files I write.

Todos that need to be done or in a particular state will generally have combo tagging to give me context, place in time, and a person that it refers to (or a topic). So, a task may be tagged with something like :ea:perso:w26: for a task assigned to my executive assistant, is personal (not work), and that is set to do something about (or due) in week 26. Due Dates for critical tasks or things that are Scheduled for a specific time get set separately via the nice key-combo CTRL-c-d and CTRL-c-s respectively (which then show up in the agenda view).

I also tag things by the people who report to me or are stakeholders in the organization so that I can get a list of delegated or waiting on tasks for people that are not actual things in my TODO list that I actually need to action. This is ridiculously handy when following up on status reports with staff, needing to do performance reviews (historical reviews), or just my weekly 1:1s with direct reports. As you can probably guess, a lot of what I do is getting things out of my TODOs into a DONE state but often that needs to transition items through other folks if they need to contribute to getting it done somehow.

My current setup on TODO states which is tis great feature of org-mode where you can change the state of TODO items was minimizing it as much as possible and having it modelled after my email inbox system (where things are either tagged Action/Starred, Hold, or simply Archived to focus on action rther than filing. Besides, with GMail and amazing search tools these days, really, it’s about being able to arbitrarily query your mail.).

My TODO states have a simple flow and are but five: TODO, WAIT, GAVE (for delegated tasks), KILL (for cancelled tasks) and, of course, DONE. You’ll notice they’re carefully crafted to be 4 letters each (sometimes forcibly so =] ) in order to keep my terminal aligned nicely. I do think I may need to modify this slightly and have been pondering if three other states may be necessary, ones for WIP, Blocked, and Next tasks, but so far this seems to be a good starter pack for getting stuff done.

Deft and org-journal ends up being a key part of this work flow (along with org-caputure to get stuff into an Inbox quickly for processing, refiling, and actioning later.). Effectively, I usually create the daily file, named and titled by date which then has headings for my daily log, personal notes/tasks, and work notes and tasks. I generally try and have a heading for meeting for the work seection and then TODOs for the meeting get filed for that meeting so there is context. I experimented with refiling these in a particular file for folks or what have you but that ended up being a lot of refiling fiddling that didn’t really add any value, mostly because of the powerful search and sorting features available in the agenda mode (in fact, I’m not so sure you ever need to have anything but a whack load of dailies at this point, though it does make organizing projects, since org-mode lacks an inherent construct for that idea, harder.). Rather nicely, because the dailies also have the date in YYYY-MM-DD format, this also gives me an idea from when the task was started to how long it’s duration directly in my agenda and todo list which is helpful in indicating how long a task has been outstanding.

I also keep a file for each of my direct reports and key stakholders where I’ll generally move 1:1 and other key recurring meetings under them but, to be honest, see note above about whether it makes more sense to keep those daily and just tag them. I do like the dedicated buffer idea but then I lose the transparency in the agenda file about how long something has been outstanding (though all TODO items I create have a :CREATED: date in their Properties drawer. It may just be I need to figure out how to make emacs display that instea dof the file name in the Agenda view (which is most likely possible, but digging through documentation in emacs is definitely one of the Bads, see below.

So, the daily workflow is bring up the Daily view, process any items in the Inbox to move them to where they should be, take a look at things Due, Overdue and Due Soon, try to make progress on those and update them with their hotkeyed logging and notes and then tackle the ToDos view where I take a look at the items of the week that were not necessarily time dependent. And yes, scarily I inbox zero every day by processing and get things into Action items which them make it into the Inbox (usually with a link to the mail if I’m clever) to be done in org-mode.

That’s it. Sounds complex (and frankly, was to set up initially), but it is actually quite fluid once you get down to it and get muscle memory in your finvgers for those emacs shortcuts (or do as I do and hotkey the suckers.). As mentioned, it is all text files in particular directories that emacs org-mode knows to look into (as well as Deft) and the search capabilities of both Agenda and the quick search on Deft make it possible. I do not use clocking in org-mode (which is crazy overkill to my mind as I’m trying to be productive, not justify every minute of my day ,though there may be a case to be made for finding out where I actually use my time rather than think my time goes.).

Most poeple will probably realize this is somewhat a simple digitization of my Taskpaper workflow, where I take notes in my paper notebook in a pseudo-bulletjournal format, get those things into an inbox in Taskpaper, and then file them accordinly. You would not be far wrong.

So, what works and what doesn’t? Should you try to emulate this setup?

The Good

Date support is most, most welcome. Having an agenda view which I’ve limited to scheduled, or due things (the terrifying realization being how much of my work is chasers and followups) is very liberating in terms of knowing what needs done, when. It’s good knowing what I am supposed to get done in a particular day and week as well as what habits I need to get sorted or items that I forward rolled as ticklers a few weeks back and I would have totally forgotten otherwise (nb: the last is something you can do with taskpaper thouigh as well.).

Tracking is excellent in org-mode and I love the fact I can have a :LOGBOOK: drawer for almost anything and link to that throughout docs. It does make discussions of what I did when very precise and it has given me much more time awareness of how long things actually take in my organization and personal life. Technically, I think you could do this in Taskpaper, but it’s not really setup for it, and feels like it would be messy. So, I feel org-mode shines in this respect as I feel I am a master of capture (as long as I get things typed into the damn thing) but see below in the Bad on my thoughts to how it might be trade-off. I definitely feel that nothing is falling through the cracks these days (as log as I manage to get it into emacs), though on the other hand the ease of capture makes the sense of overload and an even greater need for clear prioritization keen.

The markup format that underlies org-mode is suprisingly useful once you get used to it though I wish it’s support for clean exports was stronger (though it often touts that as a strength, in reality, I’ve found it a bit troublesome). I love the table editor you get with emacs though. While I can also use that in markdown it makes using org-mode and emacs as a general all-purpose, do-anything console for getting things done pretty amazing.

I also love the Habits support. I have to admit, while I’m dying to have it support skips and better repeats (eg. repeat this on the 3rd Tuesday of the month or other weekday-ish tasking.), it is great at keeping me honest (see comment above about tracking). I actually tried using a separate app previous to this for forming better habits which failed (interestingly enough because you only ever see a week while org-mode gives you a nice long configurable (I use a 7 week view) “heat map” of how you’re doing. Seeing that staring you in the face each day and where you are getting warnings on falling off the wagon is pure win. Scarily, if Taskpaper could support Habits in some way (I’ve been trying to think of that), that would probably do me.

Kind of a minor thing as well, I’ve set up the Contacts module to support friends’ birthdays and anniversaries and really like it when that pops up in my daily agenda. Perhaps if I was using Taskpaper and my calendar more effectively this wouldn’t be an issue, but it’s saved my butt with friend’s birthdays twice now which makes me feel good since I get so work-busy, it ends up being super handy and making me feel like I"m not failing at life.

The Bad

Quite frankly, what people have managed to do in org-mode contributed packages is pretty astounding and humbling. I seriously wish I was a better elisp programmer as there are a slew of improvements I would like to see in things like org-habit (or making the Taskpaper package more date friendly. As it is, I think it is actually more configurable and useful than the actual Taskpaper app in some respects.).

And therein lies one of the rubs: bending org-mode to your will means you need some pretty serious programming and/or configuration chops. In fact, I’d say you don’t really bend org-mode to your will as it forces you to bend to its will. Besides the amount of time it takes you to find the magic incantations to tailor it to your needs, it also kinda means you start doing everything in emacs. Suddenly things like doing all your email in emacs or using it as your irc client seem like good ideas (despite the shortcomings), like you’ve been suddenly brain-washed by some weird cult where everything revolves around a central obsession (much like yoga, diving, or MLM people).

That said, what it does it does very well. While I resisted moving to org-mode as a markup format, it was a surprisingly easy transition from markdown (though markdown more readble abnd I still don’t understand why you can’t put TODOs in markdown and have org-mode pick them up. :-/

Having a separate todo list from the agenda is interesting, but I have to admit, I spend all my time in the agenda view which means I have a tendency to overschedule, and looser items without deadline get shifted from week to week, which makes me worry I am focusing on the urgent rather than the important sometime. This actually is one of my very big concerns. That the focus on the minutiae of day to day tasks and ease of tracking obscures me not focusing on the big picture projects and strategic items.

And that is one of my big issues, actually. Even though org-mode has a hierarchical format built in, it has no real concept of a top level project, or anything other than a Todo/Heading. While you can fake hierarchical planning, once you get things into the Agenda or Todo view, organizing structure appears to be lost, which is very unfortunate since it destroys much of the metadata you have to contextualize a task.

And while this may not be a fair critique, one of the things that I find compelling (of not downright comforting) about Taskpaper is my ablity to have everything collected in one place (this, of course, means I am constantly filgering things to put into Taskpaper through the inbox, however.). I have one long file that I then filter on the fly for the things I find important or view that are key. For some reason, that gives me at least the illusion of being highly organized. Also, seeing some things constantly, in the same file, sometimes make it feel much more organized. With org-mode, files scattered across many multiple files and only coherent through the agenda search disptacher or agenda/todo view feels, messier. And again, I do worry that I’m not ofcusing ont he right things, but just on everything (which org-mode does allow you to do.). I can’t tell if this is a side effect of how I am using it or some sort of slight OCD-ness in myself.

I also worry that I’ve spent way, way too much time bending org-mode to my will. I sometimes feel I spent a lot more time configuring or maniuplating org-mode and emacs than getting things done. While an argument could be made that once learned, benefits accrue, I’m not entirely sure that the fiddling outweighs the productivity gain (which as pointed out above, I’m not entirely sure are apparent).

While it allows you to jump to information directly from the agenda interfaces (which is damn handy for giving context on dailies from my notes) as a bonus, I do wonder of I’m getting into the weeds too much and losing the forest for the trees. As mentioned, I also happened to spend a ridonkulous amount of time finidng a terminal colour scheme which didn’t burn my eyballs out of my head (I’ve ended up using afternoon or a modified zenburn if you’re curious and the doom-modeline info bar as a plugin to give me a minimal, somewhat, sublime text like info bar.).

The Conclusion

Ultimately, org-mode feels like it is much, much stronger at tracking things than it is at organizing though that may be now appropriate for my use cases at the moment. For some reason, I felt more in control and having a sense of a comprehensive overview with Taskpaper than I do with org-mode. This may be because I run a 90+ person team and have a position which needs to track and followup on a wide ranging number of groups, both under me, and those having entire other reporting lines. So, while I feel like I do have everything in org-mode “somewhere” it feels like it needs much stronger organization in order to have a better overview. It feels very bottom up, rather than top down as a planning tool (though people could argue this is simply the way I’m using it poorly.).

I"m going to stick with org-mode a while to see how running things goes with it. I’ll followup with a post in a few months on whether I’m sticking or running (back to my old Taskpaper system.).

The Config

If you’re interested in the setup of how I put everything together and what the curent setup is, I’ve given the relevant parts of my config here to hopefully save some people some pain in getting things setup. I’m using the excellent use-package package manaer to handle install and updates in my emacs, so configuration is handled that way in the below config code.


Coming from vim, I’m fully aware of the vagaries of theming but was quite surpised at the additional issues surrounding emacs. Due to the proliferation of modes in emacs, it is very difficult to find a theme which works well, has broad support for virtually all modes and works in terminal despite 24bit fullcolour support anything comparable to what you see in editors such as Sublime, Atom, or VS Code (I have to admit to being very impressed with VS Code of late.).

For example, my go-to in vim, solarized, You simply cannot get a modern solarized working in terminal emacs without jumping through hoops that would make a neckbeard cry. Even if you do terminalize the colours, there are still issues, and this is despite the fact you can get some really great vim support doe solarized. In the end, I settled on two themes, Afternoon, which is very nice and colourful, but for the sake of my eyes and long terminal session I settled on a zenburn theme with a darker background colour modification and in a Tango Dark iTerm terminal to keep myself sane. It was one of the few themes that supported org-mode’s agenda in a nice, sane colour scheme and also org-habits’ graph well. Snippet for use with use-package below in case you want to emulate it and save a lot of theme experimenting time. As with all things taste and preference based, YMMV.

(use-package zenburn-theme
  :ensure t
  (setq zenburn-override-colors-alist
    '(("zenburn-bg" . "#111111")))
  (load-theme 'zenburn t)

(use-package doom-modeline
  :ensure t
  :defer t
  :hook (after-init . doom-modeline-init))

Org-mode (and Friends)

This is the meat of my config, which was fairly hard won, so please use it as a guide for kickstarting your own. I like to think I made some good choices in terms of the system above, but YMMV.

(use-package org
  :ensure org-plus-contrib
  :defer t
  (add-to-list 'auto-mode-alist '("\\.org$" . org-mode))

  ;; General org-mode agenda eneration speedups
  (setq org-agenda-dim-blocked-tasks nil)

  (define-key global-map "\C-cl" 'org-store-link)
  (define-key global-map "\C-t" 'org-agenda)
  (define-key global-map "\C-ci" 'org-capture)

  (setq org-agenda-files (list "~/path/to/deft"))
  (add-to-list 'org-agenda-files (expand-file-name "~/path/to/deft/dailies"))
  (setq org-deadline-string "DUE:")
  (setq org-scheduled-string "DO:")
  (setq org-ellipsis "  ▼")

  (setq org-agenda-skip-deadline-if-done t)
  (setq org-deadline-warning-days 4)
  (setq org-agenda-skip-deadline-prewarning-if-scheduled t)

  (setq org-agenda-todo-list-sublevels t)

  (setq org-agenda-todo-ignore-scheduled 'all)
  (setq org-agenda-todo-ignore-deadlines 'all)
  (setq org-agenda-todo-ignore-with-date 'all)
  (setq org-agenda-tags-todo-honor-ignore-options t)

  (setq org-todo-keywords '((type "TODO(t@/!)" "WAIT(w@/!)" "GAVE(g@/!)" "|" "DONE(d@/!)" "KILL(k@/!)")))
  (setq org-log-into-drawer t)
  (setq org-log-done t)
  (setq org-log-reschedule t)
  (setq org-log-redeadline t)
  (setq org-enable-priority-commands nil)

  (setq org-agenda-deadline-leaders '("Due:  " "In %3d d.: " "%2d d. ago: "))
  (setq org-agenda-scheduled-leaders '("Do: " "Sched.%2dx: "))

  ;; prevent demoting heading also shifting text inside sections
  (setq org-adapt-indentation nil)

  ;; Org Capture Inbox and refiling to Deft files
  (setq org-directory (expand-file-name "~/path/to/deft"))
  (setq org-default-notes-file (concat org-directory "/inbox.org"))
  (setq org-outline-path-complete-in-steps nil)         ; Refile in a single go
  (setq org-refile-use-outline-path t)                  ; Show full paths for refiling
  (setq org-refile-targets
      '((nil :maxlevel . 3)
        (org-agenda-files :maxlevel . 3)))
(use-package org-capture
  :ensure nil
  :after org
  	'(("t" "Todo" entry (file+headline "~/path/to/deft/inbox.org" "Inbox")
  	   "* TODO %?\n:PROPERTIES:\n:CREATED: %U\n:END:\n" :prepend t :kill-buffer t)
	  ("m" "Meeting" entry (file  "~/parh/to/deft/calw.org" )
	 "* %?\n\n%^T\n\n:PROPERTIES:\n\n:END:\n\n")
	  ("j" "Journal entry" entry (function org-journal-find-location)
           "* %(format-time-string org-journal-time-format)%^{Title}\n%i%?")

  ; Org contacts config
  (use-package org-contacts
   :ensure nil
   :after org
   (org-contacts-files '("~/path/to/deft/contacts.org")))

  (use-package org-bullets
  :after (org)
  (add-hook 'org-mode-hook (lambda() (org-bullets-mode 1))))
  (require 'org-habit)
  (setq org-habit-following-days 7)
  (setq org-habit-preceding-days 35)
  (setq org-habit-show-habits t)
  ) ; End of org-mode use-package block

(use-package org-super-agenda
  :ensure t
  :defer t
  (org-super-agenda-mode t)
  (setq org-super-agenda-groups
  	  (:name "Today\n"
  		 :tag ("bday" "anns" "hols")
  		 :time-grid t
  		 :tag ("today")
  		 :deadline today
  	  (:name "Habits\n"
  		 :habit t)
  	  (:name "Perso\n"
  		 :tag "perso")
          (:name "Overdue\n"
                 :deadline past)
  	  (:name "Reschedule/Do\n"
                 :scheduled past)
  	  (:name "Due soon\n"
                 :deadline future)
  	  (:name "Waiting\n"
                 :todo "WAIT")
          (:name "Delegated\n"
                 :todo "GAVE")
	)  ;; end setq superagenda block
  ) ;; end whole super agenda block

Turning my back on years of vim and Taskpaper to try something a bit new-old with Emacs and org-mode to enhance my GTD-fu

Daryl Manning


4673 Words

2018-02-17 21:54 +0700