My GTD System with orgmode

Olivier
Olivier

I use David Allens Getting Things Done System (GTD) for quite some time now. This post documents my journey to a functional Getting Things Done system and my earlier and current implementation.

Table of Contents

What is GTD?

Getting Things Done (GTD) is a personal productivity system designed by David Allen. If you have never heard of it I recommend reading David Allen's book or check out his GTD Website for a quick introduction.

The cornerstone of GTD is, among others, a trusted system where all tasks and appointments are stored. The idea is to get all tasks written down and out of the mind. This reduces the burden to track the tasks and remember them.

If multiple tasks belong together they are handled as a project. Each project has a clear vision and outcome. Projects are planned with David Allens natural project planning method where actions sorted as a series of small next action's. For example this blog post had the following next action structure at the beginning:

Vision: Publish blog post describing my GTD system.

  1. Create new nikola blog post for GTD.
  2. Write outline for GTD blog post.
  3. Write section "What is GTD?"
  4. ...

After that I added more and more tasks until the blog post was completed. It is important to define actionable next actions. If the project is structured this way, it can be opened and worked on straight away. It also reduces procrastination. Small actionable steps are less daunting than bigger tasks.

Tasks can have contexts such as @home, @work, or @computer. Contexts represent the circumstances that are necessary to complete the task. For example it is only possible to write the blog post when I am at the computer. The trusted system can then be filtered based on the context and hide tasks that are not relevant right now.

It requires some time to manage a trusted system. During peak times the system can get out of control and become cluttered. This is where the weekly review comes into play. During the weekly review, all projects are updated to the current state. Missing next actions are added and finished or discarded projects are archived.

Journey to GTD

I first heard of GTD in 2005 during my professional education as a computer technician. At the time I used a paper based system to track various work and school related tasks. The paper system worked quite well, but after going to the swiss military and rejoining the corporate world one year later I sort of forgot GTD.

In my new job I mainly relied on hand written notes, post-its, my e-mail inbox and my brain to remember tasks. After a couple of years I joined another company where we used a ticketing system to keep track of incidents changes and problems.

My reunion with GTD came two years later when I moved to the engineering team. My work was fragmented among different projects with different schedules and progress. Some times a project was on hold for weeks and then suddenly came back to life. This required me to switch back and forth between projects and keep track of the current state of each project, even if there was a huge time gap to the last time I worked on it. During that time, I reread David Allens Getting Things Done and used Onenote to track tasks. The OneNote system worked but I was never fully satisfied with it. After some time certain shortcomings became obvious and I started to work with my Emacs and Org Mode setup.

Paper based System (~2006 - ~2008)

I do not remember all details of my paper based system. Basically I used one sheet of paper for each project and kept all those sheets inside a folder. When a project used more than one page I simply added more. It was something like:

  • GTD Folder
    • Page for tasks without projects.
    • Page for project 1.
    • Page for project 2.
    • Page for project n.

To capture ideas on the go I used a small notebook in my back pocket. The Outlook Inbox was my second task list.

If I would start this today I would probably use something like the Bullet Journal.

OneNote and Outlook (2014-2016)

My first real GTD implementation was based on OneNote and Outlook. These are the tools that are available in nearly every corporate computer and work out of the box. OneNote is also a cloud based service, meaning that the GTD system can be synced between work and private devices such as smartphones. This is important to me. Most of the time I do have ideas at odd times and want to capture them immediately.

OneNote

My OneNote was structured the following way:

  • One OneNote notebook for GTD and one for Reference.
    • GTD for tasks and projects.
      • Tabs for Current Projects, Someday Maybe, Archive and Lists
        • Current Projects: lists projects I am working on right now.
          • One page @daily for small tasks I wanted to accomplish that day.
          • One page per context such as @teammeeting or @daily standup.
          • One page per project with the headings: Vision, Next Actions and Notes.
            • Vision: has the project vision.
            • Next Actions: has all next actions as checkbox items.
            • Notes: con tains notes as bullet point lists.
        • Someday Maybe: project ideas for the future that I might want to start on sometime.
        • Archive: for all archived projects that are finished or discarded.
        • Lists: for lists such as packing list, movies to watch, and so on.
    • Reference contains notes about all kind of work related stuff such as notes about technical systems, cheatsheets, documentations and so on.
      • Tabs for each knowledge domain such as Fortigate, Fortimail, Linux, Python usw.

Outlook

Besides OneNote I used Microsoft Outlook to track appointments and to reserve big chunks of time for project work in the calendar. I also use Outlook as a reference system for mail with the following folder structure:

  • @Action
    • E-Mails that still need an action. Usually these e-mails are tasks in itself.
    • I try to follow the two minute rule. If I can respond to an e-mail in two minutes I do it. Otherwise the mail is moved to the @Action folder and processed later.
  • @Waiting For
    • Contains mails I am waiting for a response from the recipient.
    • Usually I BCC mails to myself and move them to the @Waiting For folder until I receive a response.
    • During the weekly review I delete all the mails in the @Waiting For folder I received a response for and send a follow-up for all others.
  • @Archive
    • E-Mails that need no immediate action are stored in the Archive for reference. It was not practical for me to structure the archive solely based on projects. Instead I have one folder for each customer and one folder for each internal projects.
    • Internal Project 1
    • Internal Project 2
    • Internal Project n
    • Customer 1
    • Customer 2
    • Customer n

Using both OneNote and the Outlook @Action folder as my trusted system is a feasible workaround for my workflow. On one hand it is cumbersome to use two programs on the other hand it makes no sense to copy tasks between programs.

Problems / Shortcomings

Using this systems for over two years I discovered some shortcomings that led me to research other options. These are the shortcomings in no particular order:

  • No central overview of tasks

    • Using OneNote means I do not have a global overview of all tasks in all projects I am currently working on. To find a next action item I need to decide on a project and open its project page. If this project contains no next actions because I wait for input from someone or are blocked due to another reason I open the next one and so on.
  • Completed tasks clutter the view

    • OneNote has no way to hide completed tasks (1 and 2). In bigger projects completed todo items clutter the view.
  • Context are in separate pages and not inside projects

    • Usually questions arise in projects and are discussed in context such as @teammeeting. I have to copy questions over to another context by hand and then copy the answer back to the original project.
  • Tracking of items and dates

    • Creation and completion dates are not added to OneNote tasks.

Spacemacs Org Mode and Outlook (2016 and on)

Org Mode is an Emacs mode for note taking, todo lists and projects management. Furthermore it can be used as an outline or an authoring and publishing system. In fact I have written this blog post with Org mode. Org Mode files are plain text files with a .org extension.

Spacemacs simplifies my Emacs configuration. It is a community-driven Emacs distribution that bundles useful Emacs packages together. Emacs is an extensible editor. In fact the Emacs slogan is: "The Extensible, Customizable Self-Documenting Display Editor". But with great power comes great responsibility. Spacemacs has useful defaults and greatly reduces the initial time to set up the environment.

If this sounds quite technical that's because it is. Although Emacs and Org mode can be used by non-technical people, I would not recommend it. Instead go the OneNote and Outlook route if you are not interested in spending quite some time learning configuring your setup.

I use one main Org mode file, GTD.org and one archive file, GTD~archive~.org. The GTD.org file has this structure:

  • work
    • tasks
      • small tasks that are not assigned to a project
    • project 1
      • project vision
      • all tasks assigned to that project
      • project notes
    • project 2
    • project x
  • private
    • tasks
    • project 1
    • project 2
    • project x
  • notes
  • lists

work contains all work related tasks. However, most of my tasks are grouped as projects. private has the same structure as work. I am not quite satisfied with notes and lists. These sections are probably extracted to their own files in the near future but for now I look how it works.

For tasks I use the states TODO, NEXT and DONE. All tasks are either in the TODO or DONE state if they are finished. One task in each project has the state NEXT. This is the task I should work on next when I open the project. This allows me to generate a filtered view of my GTD.org file with SPC m / NEXT to see tasks I can work on next.

One of the disadvantages of my earlier OneNote setup was the lack of task creation and closing dates. Some Elisp snippets handle this automatically now.

Org Mode Capture is a handy tool to create a new TODO item from any open Emacs buffer. I use two shortcuts. C-c c w adds new work tasks. C-c c p adds new personal tasks. Here is my configuration for it.

One of the main benefits of Org Mode is the Agenda view. In its basic configuration, the Agenda shows tasks that are scheduled for today or have a deadline set for the near future. In addition, the agenda view allows you to configure your own view based on filters.

I use the following keyboard shortcuts to interact with the Agenda:

Keyboard Shortcut Description
SPC m a a Open Agenda for today
SPC m a n Open Agenda and show all TODO items in state NEXT
SPC m a w Open Agenda and show all TODO items in state WAITING
C-v l Shows all logged entries I worked on today. This works only inside the Agenda.

The Org Mode Manual provides great documentation on how to configure your own Agenda views.

My day in Emacs

When I arrive at the office I open up Emacs and use SPC m a a to open the Agenda view and see what items are scheduled for today and what deadlines are coming up. I usually schedule some more tasks for today with s on a task. These are the tasks I would like to complete today. After that I work on the tasks until I finish them or leave the office. If I do not finish all tasks they will show up on the agenda the following day. On some days I run out of scheduled tasks and open the agenda view for Next actions with SPC m a n.

Of course I relied on a variety of online sources when creating this setup. This is a collection of those.

spacemacs Configuration Snippets

Task States Configuration

(setq org-todo-keywords
      (quote ((sequence "TODO(t)" "NEXT(n)" "|" "DONE(d)")
      (sequence "WAITING(w)" "HOLD(h)" "|" "CANCELLED(c)" "PHONE" "MEETING"))))

Date insertion Configuration

;; Allow automatically handing of created/expired meta data.
(require 'org-expiry)
;; Configure it a bit to my liking
(setq
     ; Name of property when an item is created
     org-expiry-created-property-name "CREATED" 
     ; Don't show everything in the agenda view
     org-expiry-inactive-timestamps   t
)

(defun mrb/insert-created-timestamp()
     "Insert a CREATED property using org-expiry.el for TODO entries"
     (org-expiry-insert-created)
     (org-back-to-heading)
     (org-end-of-line)
     (insert " ")
)

;; Automatically add tags when state changes occur
(setq org-todo-state-tags-triggers
     (quote (("CANCELLED" ("CANCELLED" . t))
           ("WAITING" ("WAITING" . t))
           ("HOLD" ("WAITING") ("HOLD" . t))
           (done ("WAITING") ("HOLD"))
           ("TODO" ("WAITING") ("CANCELLED") ("HOLD"))
           ("NEXT" ("WAITING") ("CANCELLED") ("HOLD"))
           ("DONE" ("WAITING") ("CANCELLED") ("HOLD")))))

Agenda Configuration

(setq org-agenda-custom-commands
     '(
       ("n" todo "NEXT")
       ("w" todo "WAITING")
       ("d" "Agenda + Next Actions" ((agenda) (todo "NEXT")))
      )
)

Org Mode Capture

;; Source: https://www.suenkler.info/docs/emacs-orgmode/
(setq org-capture-templates
     '(
       ;; Create Todo under GTD.org -> Work -> Tasks
       ;; file+olp specifies to full path to fill the Template
       ("w" "Work TODO" entry (file+olp "~/Dropbox/orgmode/GTD.org" "Work" "Tasks")
       "* TODO %? \n:PROPERTIES:\n:CREATED: %U\n:END:")
       ;; Create Todo under GTD.org -> Private -> Tasks
       ;; file+olp specifies to full path to fill the Template
       ("p" "Private TODO" entry (file+olp "~/Dropbox/orgmode/GTD.org" "Private" "Tasks")
         "* TODO %? \n:PROPERTIES:\n:CREATED: %U\n:END:")
))