I am an extremely lazy and messy person. As such, in order to survive, I need a system to find my way out of bed in the morning, have something to eat in the fridge, don't forget to pick my children at school, feed the cat and things like that.

More than 15 years ago, when I already was an Emacs user, I heard about Getting Things Done (GTD for short), a book and a personal productivity system that promised to save my life. I bought the book and started implementing the system right away. If you don't know anything about GTD, reading the Wikipedia entry will give you a good overview. In short, the action management part of the system relies on the following steps:

1. Capture everything you have to remember or solve.
2. Periodically empty your inboxes (what you have captured, and any other input you get as e-mail, physical stuff, etc.).
3. Transform every input into either actionable things, reference material or trash. Actionable things can be projects (need more than one action), next actions (everything is ready to do what you need to do) or things to delegate.
4. Maintain lists for actions and projects.
5. Periodically review your lists.
6. Don't forget to do some of your actions from time to time!

This is a crude description of the system, but it will be enough for the rest of this article.

The funny thing is that one could imagine that, as an avid Emacs user, I looked for ways to implement GTD with it. But the real story is that I discovered GTD because, when I was looking for ways to manage actions with Emacs I found what I think is the absolute reference on the use of Org Mode to get organized, and GTD is cited there.

My implementation is much inspired by Bernt Hansen's suggestions in the above-mentioned site. For actions, I use the following states:

(setq org-todo-keywords 
      (quote ((sequence "TODO(t!/!)" "NEXT(n!/!)" 
                        "STARTED(s!)" "|" "DONE(d!/!)")
              (type "PROJECT(p!/!)" "|" "DONE_PROJECT(D!/!)")
              (sequence "WAITING(w@/!)" "SOMEDAY(S!)"  "|"
                        "CANCELLED(c@/!)"))))

The meaning of these states is:

NEXT

an action that I need to do, for which I have estimated the effort, and for which I have everything to start acting.

TODO

an action that I need to do but that I don't want to see in my next actions list.

STARTED

a next action for which some progress has been made.

DONE

a finished action.

WAITING

an action to be done, but for which I am waiting for some input or some action from somebody else.

SOMEDAY

an action that could be interesting to do, but on which I don't want to commit yet.

CANCELLED

an action that I decided that I finally don't need to do.

The projects are just containers for related actions.

Next actions are very important. They are what allows to achieve progress even in periods of crisis or low energy. All my actions have tags for contexts. These can be general (work, admin, errands) or specific (the name of a particular project or person, a type of activity (reading, programming, writing). This allows to easily generate lists of actions which match a set of tags. The final thing that makes a next action special is the effort estimation. Using Org Mode properties, I assign an effort estimation to each next action, so that I can also filter by estimated duration when I have limited time available.

Since I spend most of my time in Emacs, using the Org Agenda makes being organised an easy and pleasant experience. The Org Agenda is my main dashboard that I trigger with C-c a. I think this is the default key binding, but I have this in my Emacs config:

(define-key global-map "\C-ca" 'org-agenda)

My Org Agenda is built from more than 60 Org Mode files.

One key part of maintaining a clean GTD system is the weekly review. Once a week, I sit down for 90 minutes to 2 hours and I go through this checklist:

• [ ] Re-schedule / re-deadline today's tasks
• [ ] Collect loose papers and materials
• [ ] Mental collection
• [ ] Get ins to zero
  • Questions :
    • What is it?
      • Actionable?
        • Yes
          • Next action?
            • 2minutes? (do it)
            • delegate? (waiting for)
            • defer it to a specific date?
            • or next action to do it ASAP (tag next)
          • Is it multiple actions?
            • Project
        • No
          • Reference material (tag reference)
          • Incubate (remind me later) (tag incubate)
          • Trash it
        • No
• [ ] Get current
  • [ ] Review next actions list
    • [ ] what might have been important may not be it anymore
    • [ ] check that we have effort for all
  • [ ] Go back to previous calendar data
    • [ ] things which got rescheduled or should
    • [ ] actions which were not done
  • [ ] Review upcoming calendar
  • [ ] Review waiting for list
  • [ ] Stuck projects
  • [ ] Look at project list
  • [ ] Review relevant checklists
• [ ] Get creative
  • [ ] review someday/maybe
  • [ ] generate new ideas

For some of these steps, I have Org Agenda custom commands or specific agenda views which are very useful. I am sharing them below.

(setq org-agenda-custom-commands
      (quote
       (
        ;; [....]
        ("n" . "Next Actions List")
        ("nn" tags "+TODO=\"NEXT\"|+TODO=\"STARTED\"")
        ("na" tags "+home+admin+TODO=\"NEXT\"|+home+admin+TODO=\"STARTED\"")
        ("nh" tags "+home+TODO=\"NEXT\"|+home+TODO=\"STARTED\"")
        ;; [....]
        )))

I can see all my next actions (with TODO state being NEXT or STARTED) by typing C-c a n n.

As I said above, I want to have an effort estimate for all my next actions. I use org-ql to generate an agenda view with all next actions that don't have Effort property. I display that with the following interactive command:

(defun my/show-next-without-effort ()
  (interactive)
  (org-ql-search (org-agenda-files)
    '(and (todo "NEXT")
          (not (property "Effort")))))