I have been implementing Getting Things Done in Things for a long time. Occasionally, I like to try out other apps just to see what’s available and if there would be a big benefit to switching to something else. This time, I have been looking at Reminders, the built-in tool that Apple provides on its devices.

The first step is to set up the basic GTD lists, and for this, I am going back to basics with Contexts being normal lists and not implemented using tags. Everything to reduce drag and create an efficient and simple system.

Pros and cons

Compared to Things, there are several benefits and downsides to Reminders.

No dependency on an external cloud

Being already heavily invested in iCloud, having one more thing there is not a problem. Syncing has been rock solid for all devices, including iPhone, iPad Pro, Mac and even the Apple Watch. Not having to rely on a third-party cloud without end-to-end encryption is a big benefit for me.

The Apple Watch app

The app on the Apple Watch is surprisingly useful. It allows full access to all lists in Reminders, with the possibility to add or change any field. This is a stark difference from Things, where only the Inbox and Today view are easily available on the watch. The downside seems to be that there is no built-in widget to quickly add a task to the inbox; however, that could be easily handled with a Shortcut.

Sortable lists

The lists in Reminders can be automatically sorted based on a few criteria. The best use of this feature for me has been the possibility to sort the context lists by due date. This means that if the list contains an action with a due date, it will be floated to the top. It makes it easy to quickly get an idea of which action to tackle first in a specific context.

Geofenced errand lists

Actions can have a geofence attached to them, which means getting reminders of errands to pick up at certain stores is a breeze. In this example, I will get a notification when arriving at Westfield, and clicking it will show everything I need to pick up.

List sharing

Sharing lists is simple and powerful, and Reminders makes that super easy. My use case is to share home tasks and errands with my spouse so that we both have access to the same information.

The lists outlined in green in the screenshots are the ones shared. This provides shared contexts, project lists and someday/maybe for those areas of focus.

No start dates

This one is a tougher pill to swallow, at least initially. Coming from the world of Things and OmniFocus, I am used to being able to set start dates for actions and projects. Without this ability in Reminders, as it only has due dates, I have to implement a tickler system. Fortunately, my implementation is simple to set up and works quite well.

First, create a list called Tickler, and pin it to the top for easy access. Sort it by due date and start adding the things you want to be reminded of and set the due date to the specific date.

When a tickler is due, it will be displayed in the Today view, where you can evaluate it. If it is day-specific information, you can keep it for as long as needed and then just check it off. If, however, it is an action that you want to defer for another day, you can just remove the due date and drag it to the appropriate context list. If this is a repeating tickler, however, you will have to create a new next action and add it to a next-actions list, and finally tick the Ticker off as done.

No single view of the hard landscape

There is no way of seeing action deadlines together with calendar events. This means that I have to look at two different places to get the full view of the hard landscape.

Selecting and moving actions

Selecting and moving actions and projects in Things is a breeze. It supports multi-select, but in Reminders, you have to first click the three dot menu — Select Reminders to be able to select more than one. This feels very clunky and not thought through properly.

Once you have selected actions to move, dropping them in the right place in a list is another nuisance. It’s easy to get it wrong, and then the actions seemingly just disappear (they go back to the source list, but it is very unclear.

Another gripe I have with moving actions is if there is something in my Inbox that I want to save to a Reference list, there is no way of moving it to the list by searching for it. I, instead, have to manually click and find the right list.

Finicky notes filed

I use the notes field of an action to add information all the time, and it works great in Things. In Reminders, however, the notes field will always be visible, but truncated if the note is long. This can make one single action take up a lot of space.

If there are URLs in the notes field, it looks like they are clickable, but clicking them does nothing. To open a URL, you have to right-click and then select Open.

Setting up the GTD lists

Most of the lists are self-explanatory if you have an understanding of how GTD works. What I tweaked is the sorting in the context lists. Normally, the lists are sorted manually, e.g., the newest items appear at the bottom. The context lists are better sorted by due date, which provides the benefit of showing all actions that have a due date at the top.

Another special list I have created is the Today view. While there is a built-in today view, this smart list, includes flagged items as well.

Conclusion

The big question is, will this replace the setup I have in Things? For now, probably not. It comes with numerous benefits over Things, but most things are just a bit more difficult to do in Reminders compared to Things, like moving actions, no start dates and inflexible note fields.

If you are starting from scratch, however, Reminders is a great alternative, especially if you are already in the Apple echo system. Having full access to the lists on the Apple Watch, for instance, is surprisingly useful.

Getting Things Done is a methodology for managing life’s many inputs and to provide clear mental space to focus. To get started, there is no better way than reading the actual book. I have been using this framework close to 15 years, and many of them were spent in OmniFocus, and in later years, Things  has been my companion. To be completely fair, I was using Things before OmniFocus, and scrolling all the way back in the archive reveals that the first completed action was on August 30, 2008.

Fast-forward into 2023, and I have been looking into using Obsidian for meeting notes among other things. Being able to move my GTD system into the same app could provide some great benefits, such as automatically populating agendas in the meeting notes for a specific meeting. I am currently on parental leave, which means having less active projects, makes for a great time to experiment with something like this.

The system itself is essentially a bunch of notes, bound together using Dataview, an excellent plugin that provides a query language for notes and tasks within Obisidian. The GTD pages have a common menu for easy navigation and look something like this.

The way this is set up is very close to how I have been managing my lists in Things, and the views we are about to create will reflect that. The sections below describe each view in more detail and the queries used.

Creating a project

What makes a project a project is the metadata contained within the frontmatter of the note, as well as the location. These fields are what is later queried for in the different views.

state: active, someday, done, dropped (the different project states)
org: different organization of life, eg. personal, work, side business etc.
area: general areas of responsibility for the project, like personal, family, health
start: an optional field if the project has a specific start date
due: an optional field if the project has a specific deadline
reviewed: set to the current date when the project is created. Currently unused, but I have been experimenting with having a view for seeing what to review like in OmniFocus.
period: If the review period is something other than 7 days, this can be set here.
category: Project (this is the field that I have configured the metadata menu plugin to use for different types.)
prio: set to 1 by default and currently unused. This may be used to sort the project list if necessary.

Metadata menu plugin

The metadata menu plugin is used to create structure to metadata, eg. frontmatter fields. You can install and configure a project template using the frontmatter fields above. Another benefit this brings is autocomplete for the various fields, such as the org and area.

Templater plugin

The templater plugin is a great helper in automating project creation. Install it, and configure a template to look like this:

---
state: active
org: personal
area: personal
start: 
due: 
reviewed: <% tp.date.now("YYYY-MM-DD") %>
period: 
category: Project
prio: 1
---
![[Filters#Menu]]
<% await tp.file.move("GTD/Projects/" + tp.file.title) %>

When this template is applied to a note, it will automatically add all metadata, set the reviewed date, as well as move the project to the correct folder, which in my case is GTD/Projects.

The way I usually create new projects is by clicking the new note button in Obsidian and give it a name. Then I press cmd + p (or drag down from the top on the iPhone) and type “Tem”, at which point the “Templater: Open insert template modal” should be at the top. Choosing it should reveal the template above, and selecting it will make it a project by assigning the metadata and move the note to the right folder. You can then adjust the metadata as needed and add actions below.

I haven’t mentioned the ![[Filters#Menu]] line yet, but that is how I navigate between the different views. More on that in the Navigation section below.

Project overview

Once you have a few projects in the project folder, the next step is to create a view that automatically shows the projects you have, in order to get a nice overview. The view relies on the dataview plugin, so the first step is to get that installed.

Next, create a file called Projects In your GTD/ folder and add a section for showing active projects:

dataview
TABLE
    length(filter(file.tasks, (t) => !t.completed)) AS ☑️,
    area
FROM "GTD/Projects"
WHERE category = "Project"
AND state = "active"
AND start <= date(today)
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
SORT org, area, file.name

Next, do the same thing for scheduled projects, e.g. projects with a start date that is in the future:

dataview
TABLE
    length(filter(file.tasks, (t) => !t.completed)) AS ☑️,
    start
FROM "GTD/Projects"
WHERE category = "Project"
AND state = "active"
AND start > date(today)
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
SORT org, area, file.name

Finally, do a section for Someday projects. This can of course be moved into its own page if needed:

dataview
TABLE
    area
FROM "GTD/Projects"
WHERE category = "Project"
AND state = "someday"
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
SORT org, file.name

Now you should have a page similar to the screenshot below. It shows you all projects that you have created, together with the number of next actions and area.

Recurring projects

A limitation to this setup compared to Things and other “real” task managers, is that it doesn’t support recurring actions. The way I have been handling this so far is to create a special single action project for this, one for each org, called  + Personal recurring.

I have put actions under a heading for each cadence, and if I see a completed action during the weekly review, I copy/paste it and change the start date to what the heading states. The finished action can be moved into a separate section at the bottom.

This works as long as you do your Weekly Review weekly, and also don’t have anything that needs to repeat more than once a week. A workaround could be to use the calendar for keeping track of this, if you have recurring deadlines.

Single actions

As mentioned in the introduction, the foundational element is a project, meaning there can be no standalone actions. To solve this, similar to the recurring tasks, I have a single actions project for each org called + Personal SAL. The reason for choosing “SAL” over “actions” or similar is just because I want to quickly be able to search for it when adding an action.

Contexts

Now we are getting to a place where the rubber hits the road — contexts. This is where the project lists and actions created previously actually come into practice. A context shows all available actions which mentions that specific context.

The query for a @mac context looks like this, and is added to GTD/Contexts/@mac:

dataview
TASK from "GTD/Projects"
WHERE category = "Project"
AND state = "active"
AND start <= date(today)
AND contains(text, "[["+this.file.name+"]]")
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
AND !completed
SORT due desc, text asc
GROUP BY file.link

This means that if I have an action in one of my projects that looks like this, it will show up in the list.

- [ ] An action that needs to be completed on the [[@mac]]

A pro-tip is to use the shortcut ribbon at the bottom to quickly have the link created, as you can just click the button and start typing the name of the context you want to apply. You can also assign multiple contexts if there is something that can be done both on the Mac and on an iPad for instance.

The most used contexts are linked directly in the menu, but for the rest, I have a simple page that links all notes within the context folder. The query looks like this:

dataview
list
from "GTD/Contexts"
sort file.name

Today

The Today view shows any action that has a [[Today]] link assigned, as well as any actions that are due or overdue. It behaves similar to the Today view of Things, but I have chosen not to include tasks that have just become available for now.

We have reviewed how to set a due date for projects, but to set a due date for an action, just include [due:: 2023-02-14] in the text. Similarity for start dates, just add [start:: 2023-02-10]. If you have future actions that you don’t want showing up anywhere, you can add [start:: someday] and they will only be visible in the project list.

This view can be achieved using this query:

dataview
TASK from "GTD/Projects"
WHERE category = "Project"
AND state = "active"
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
AND !completed
AND start <= date(today)
AND (
  (due != null and due <= date(today))
  OR contains(text, "[[Today]]")
  )
GROUP BY file.link
SORT name

Upcoming

The upcoming view shows future deadlines for actions and projects, currently grouped per day, looks like this:

dataview
TASK from "GTD/Projects"
WHERE category = "Project"
AND state = "active"
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
AND !completed
AND due != null
GROUP BY due
SORT file.link

Under this, I have a project deadlines section that lists all project deadlines. Normally, actions for due projects are visible in the query above, however, this provides a good high-level view. It’s also valuable if the project doesn’t have any actions, but is still due.

dataview
list due
FROM "GTD/Projects"
WHERE category = "Project"
AND state = "active"
AND start <= date(today)
AND due != null
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
SORT due

The page will look something like this:

Inbox

I have set a default folder for all new notes in the Obsidian settings, which is +Inbox in the root folder. I don’t want random files in the root, so this makes it a lot tidier. I also have an inbox view to show everything listed there, as well as any unprocessed stuff from my daily and meeting notes. It also includes a link to the inbox in the Drafts app, that I’m currently evaluating.

The inbox section query looks like this:

dataview
list
from "+Inbox"
sort file.mtime desc

The daily notes and meeting notes section looks like this:

dataview
TASK from "Notes/Meetings" OR "Notes/Dailies"
WHERE !completed
GROUP BY file.link

Archive

The Archive view shows all completed tasks. There are two sections in this view, where the first shows the past four days grouped by day, and the second shows everything after, grouped by month. This makes it easy to go back a day or two to see what has been completed, while still seeing the bigger picture. It can of course be expanded to show finished projects only or other things.

dataview
TASK from "GTD/Projects"
WHERE category = "Project"
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
AND done > (date(now) - dur(4 days))
AND completed
SORT done desc
GROUP BY dateformat(date(done), "yyyy-MM-dd") AS fulldate
SORT fulldate desc

dataview
TASK from "GTD/Projects"
WHERE category = "Project"
AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)
AND done <= (date(now) - dur(4 days))
AND completed
SORT done desc
GROUP BY dateformat(date(done), "yyyy-MM")

Filtering on organization

One thing I like about Things is the way tagging and tag inheritance works. It allows me to filter on, for example, only personal areas and projects, which can be great on the weekend and in the evening. In order to do something similar in Obsidian, I have created a Filters file, which contains this:

## Filters
%% personal work %%
filter-org:: 

If I set filter-org to personal for instance, all GTD views will be updated to only show projects and actions from the personal org. If left empty, it will show everything.

If you want to add another org, or change the name of the ones I have defined, you need to update this line in the view queries above:

AND contains(default([[Filters]].filter-org, ["personal", "work"]), org)

Navigation

In order to easily navigate between views, projects, and everything else, I have created a menu. It’s part of the Filters note, but could of course have been created somewhere else. All views contain the following line just after the frontmatter:

![[Filters#Menu]]

This allows me to update the menu as needed, and easily add it to new places, such as new projects. It currently looks like this:

###### Menu
[[Inbox]] • [[Today]] • [[Upcoming]] • [[Archive]] • [[Filters]]
[[Contexts]] • [[Projects]] • [[Horizons]] • `="[[" + dateformat(date(today), "yyyy-MM-dd") + "|Daily note]]"`
[[@mac]] | [[@iPad]] | [[@tablet]] | [[@iPhone]] | [[@home]]

---

Improvements

While implementing this, the first goal is to have something that works up to horizon 1 level, e.g., projects. There are plenty of improvements I have noticed as I’m setting this up, and I have been keeping track of them. Some of them are:

• Add a place for checklists
• Add a place for templates – Use Templater for this, since you can automate setting dates and other things.
• Consider handling single actions like projects, e.g., in separate files
• Automatically show relevant contexts in the menu depending on external factors, such as time, day, or location
• Find some way of automating recurring actions
• Move finished items in single action lists to another file or sub-heading automatically
• Move Someday out of the project overview
• Worried about database size. May move archived projects per year outside the system. In Things, I have tasks dating back from 2008. Can this setup handle that?

Conclusion

In conclusion, I think I’m starting to get to a point where I have a workable system. There is still some minutia that needs to be sorted around quickly adding something to a list. I’m currently testing text transporter, which can be used to move a task from the inbox to a project list, and it is working quite well so far.

My main worry about this setup, is the potential for friction and drag in the system. It’s easy to manage a GTD setup with plenty of bells and whistles when you are on top of your game, but it needs to be as workable on a Thursday afternoon after a three-hour workshop when your mind has checked out as well. Time will tell if I continue on this path or revert to Things.

Kudos

A big thank you to mostlymaths.net  | Project and task management with Obsidian and Dataview for the inspiration to set this up, and of course to the plugin developers for dataview, templater and the others mentioned.

Join the conversation on Twitter and Mastodon/Fediverse.

This post a stab at implementing meeting notes in Obsidian. The purpose is to be able to see all notes taken during the day in once place, while also being able to review previous notes for recurring meetings. Also, being able to mark notes as processed to make handling meeting notes quicker, as there is no need to process a note twice.

Background

Ever since Things added support for Markdown, I have been using it for meeting notes. I have a Shortcut that creates a meeting note in the inbox for every meeting in the calendar for the day. It has been working above all expectations, and with the tags, I can easily pull up agendas and meeting notes for a specific meeting.

I am a big user of outlines, which means that I use bullet lists a lot. Indenting bullets in Things is very finicky, as it doesn’t use the standard tab and shift-tab for changing the indentation, and changing the order to bullets require copy/pasting. When taking quick notes in meetings, this becomes a cognitive burden, as I have to fidget with the notes instead of paying attention in the meeting.

I have been wanting to dip my toes in Obsidian for a while now, so this use-case could be a great first workflow to solve.

Periodic notes plugin

The first step is to use the Periodic Notes plugin to handle daily notes. Together with the Calendar plugin, navigating between different days is very fast.

The folder structure for my periodic notes are separated by type and for the daily notes, they have yearly sub folders to limit the number of notes in the same folder.

Daily note

The base for the meeting notes is the daily note. It contains all notes taken for a specific day. This simply means that going back to a specific day in time reveals everything that was handled during that day. The following sections describe what the different sections of the note structure mean.

Open actions

The first section contains all open actions, which in this context is mainly used to determine which meeting notes have been processed and not. The search covers all daily notes, which means that if there are unprocessed notes from a previous day, they will show up in the current note as well.

The search uses the tasks plugin and looks like this:

(path includes Notes/Meetings) OR (path includes Notes/Dailies)
not done

Daily retrospective

The retrospective section is mostly an experiment for now, and include a few sections on achievements and learnings for the day, what has gone well and what could have been done better.

Log

The purpose is to have a specific place for thoughts, decisions and small notes during the day. The inspiration comes from:

Along with her ever expanding to-do list, Maxine has kept a daily work diary on her personal laptop for the last decade. In it, she tracks everything she’s worked on, how much time she spent on it, any interesting lessons she learned from it, and a list of things to never do again (most recently, “Don’t waste time trying to escape spaces in file names in Makefiles—it’s too difficult. Use anything else instead.”).

— The Unicorn Project: A Novel about Developers, Digital Disruption, and Thriving in the Age of Data by Gene Kim*

To simplify and remove any barrier to adding a log, I’m using the Obsidian Memos plugin. It provides a UI that makes it easy to add a log, and also has the ability to list logs across daily notes and create saved searches.

Notes

The notes section is used for non-meeting notes for the day. Adding a todo will make it appear at the top in open actions, so you don’t forget to process the note. Since I like using outlines, each section In this category starts as a top-level node, and sub-nodes are the notes for the topic itself.

Meetings

The meetings section is the meat of the daily note, and contains a list of all meetings with links to specific date based heading in separate notes. The benefit of this is that it’s possible to both see all notes for a specific day in the daily note, but also seeing all previous notes for a specific meeting when clicking on a specific meeting. For recurring meetings, this is a great way of seeing everything that has been discussed in the past.

Meeting notes

The structure of the note for a specific meeting looks like this:

Things agenda: [Firstname](things:///show?id=anytime&filter=Firstname%20Lastname)
- Goals doc: [Firstname’s Goals](https://docs.google.com/document/d/xxxx)

# [[2023-01-25]]
- [ ] Process notes

- Meeting notes here
- And here

---

Having a heading for each date is the magic key to automatically linking these notes to the daily note. I am using Things as a task manager, so for recurring meetings, I keep a link to open the agendas for that specific meeting automatically.

The top of the document also contain links to related document or pages, as well as any relevant reference material.

Meeting note template

The main template used in this setup is to create a section in the meeting note for the entry for the day. To use this, activate the Templates core plugin, and add a template with the following content.

# [[{{date}}]]
- [ ] Process notes

- tba

---

When you navigate to the note for a specific meeting, just press cmd+p and type “Templates: Insert template” and it will be inserted by the cursor. If you have multiple templates, then you will be asked to choose which template to insert.

The task in the template will be picked up by the daily note task search and added to the list of unprocessed notes. Once the meeting notes have been processed, just check it off to have it hidden.

Tracking unprocessed notes

Any todos in the meeting note docs will appear in the open actions list in the daily note. This makes it simple to keep track of meeting notes that need to be processed or handled in any way.

Automation

Next, I want to get my meetings into the daily note automatically, so I can focus on the meetings instead of managing Obsidian. While there are calendar plugins for Obsidian that integrate with Google Calendar and others, I need something that can connect with the local calendar database of my iPhone or iPad Pro.

My solution is to create an Apple Shortcut that pulls the calendar data and generates a daily note out of that. Since I am using iCloud to synchronize my vault, Shortcuts has direct access to its folders for creating files.

Copy and customize the Shortcut: Meeting Notes (Obsidian)

The magical part of this is the personal automation section of Shortcuts, as it lets me schedule running this automation, so I always have a fresh note ready to go in the morning. To set this up, in Shortcuts, go to Personal Automation and create a new one that triggers this Shortcut in the morning. I set mine to 07:00, so the note is ready to go as I wake up.

Example daily note

To make this setup easier to visualize, here is an example of a daily note, complete with sections filled in, linked meetings and incomplete processed notes. Some things have been redacted, as this is an actual note that I used for the day.

The daily note:

One of the meeting notes:

Outliner plugin

A great way of taking notes is by using outlines. While Obisidan renders bullet lists well enough, the Outliner plugin adds keyboard shortcuts that make editing the outline a breeze. There are shortcuts for moving a bullet up or down for instance, which makes note-taking a lot quicker, which is crucial in meetings.

Conclusion

This has been a great first dip into the power of what Obsidian can do. From what I set out to do: being able to see all notes for the day, and at the same time being able to easily refer to previous notes for recurring meetings, this has worked quite well. There are certainly things that can be improved, but this has been a decent start.

I have always looked for ways of working more efficiently, and being able to get the most out of every day by spending time on what is important and not necessary just the loud and urgent. What now seems like ages ago, I read a book called Getting Things Done by David Allen, and was intrigued by his approach to handling commitments, projects, deadlines — essentially anything that life hits you with.

Most people are accustomed to the idea of a calendar, a trusted place for keeping time based commitments. GTD is about having that for all your commitments and not just the hard landscape of a calendar. It provides a way of getting things out of your head into concrete actions, which means that you don't have to lay awake at night with thoughts swirling around. It also means that you can capture anything that is on your mind and be sure that it will be taken care of effectively, and in a timely manner. This provides the foundation for being able to engage with what you are currently doing with full confidence knowing that everything else is taken care of in an appropriate way.

Your head is for having ideas, not for holding them
— David Allen

There are essentially five steps to the basic GTD process:

1. Capture: Use an in-basket or app to capture everything that has your attention. Little, big, personal and professional.
2. Clarify: Take everything that you captured and ask: Is it actionable? If not, trash it, incubate it, or file it as reference. If yes, decide on the very next action required. If it takes less than 2 minutes, do it right away, if not, delegate where appropriate, or put it on a list to do when you can.
3. Organize: Put action reminders on the right lists. For example, create lists for the appropriate context — calls to make, errands, computer related etc.
4. Reflect: Look over your lists as often as necessary to determine what to do next. Do a weekly review to clean up, update your lists and clean your mind.
5. Engage: Use your system to take appropriate actions with confidence.

For a deep dive into actually implementing GTD, make sure to read the book, since it will guide you through the entire process. There is also a GTD workbook being released later in 2019, which aims to act as a simple and practical guide for getting started with your own system.

OmniFocus

For the past decade, I have been using OmniFocus to implement my GTD system. I have seen it as a trusted companion, an external brain, that handles anything I throw at it. I have even written a setup guide, which guides you through the process of creating the views and workflows needed.

While it has been a battle tested companion for many years, I feel like I constantly have to fight the system, trying to mend it into doing what I want it to do. That coupled with the endless tweaking of perspectives made it hard to consider when asked to recommend a GTD tool to a colleague.

I did a quick review of current tools, trying out what seemed to be the most common ones. Part of this, I also ended up revisiting Things, which I used prior to moving to OmniFocus a long time ago. It has for the past 10 years become something of a powerhouse bundled into a beautiful and innocent looking package. This made the choice clear on what to recommend, but also got me thinking of trying it out for the duration of the trial period.

Things 3

The initial reaction when starting Things 3 is how clean and minimalistic the user interface is. Even though it has plenty of white space, it still manages to provide everything needed for a professional task manager, such as start and due dates for projects and actions, flagging (or starring in this case), tags and a hierarchical way of sorting projects.

While Cultured Code has written an introduction on how to become productive using Things, this is a walkthrough of my interpretation and implementation.

On the top level of the hierarchy are areas, which translate directly to areas of responsibility in GTD. This is where you define the areas of your life where you are responsible for the outcomes, and can include things like Family, Finance, Home, Client Projects, Company Strategy, but there's no one-size-fits-all here so defining these areas is an important step of setting up the GTD system.

In Things, areas can have tags, and I use that to group the areas into different categories, like Personal and Work. This lets me, for instance, easily filter out work related actions when I know I just want to focus on the personal areas, such as on the weekend.

Areas can contain projects as well as actions, which means that even though an action is not tied to a project, it can still fall underneath an area. This is one of the places where Things really shines, as it provides a holistic view of an entire area, independent of the technical details of a specific action.

Projects and actions in an area can have different statuses, where the normal is that they are active and can be worked on. Another status is Upcoming, which means that the project or action has a future start date, and this means that they won't be visible in the tags view so they can not actively be worked on until the start date and translates well to the tickler part of GTD. They can also be set to Someday, meaning that they will be inactive until a decision has been made to move them into active. This maps well to the Someday/Maybe lists in GTD.

The main “take action” view is Anytime, where all actions that don't have a start date in the future or set to Someday are listed. There's a tag filter part of this view, where you can choose which actions should be displayed based on the tags they have. This also maps well to the GTD mindset where tags can represent contexts, energy levels and time available. The tags can be applied on the fly, so there's no need to create predefined views for the filtering you are currently looking for. It also means that it’s currently not possible to create a predefined view, but that hasn't bothered me so far.

The coolest feature of this view is the ability to directly go to the project of an action in the list. This lets you easily access project level notes, see all next actions and other types of project related information. On iOS, there's a back button that returns you to the previous view once you're done in the project as well.

Actions can contain different types of information, such as a title and a note, as well as a start and due date, a project and any tags that you want. What differentiates an action in Things is the ability to create checklists within an action. This enables you to not only break down an action into smaller chunks of work, it also allows you to easily keep a log when working on an action that requires more than one session.

Being able to quickly jump to projects, or any type of list, makes working with Things very efficient. While most task managers allow searching for projects, actions and other information, no one does it as seamlessly as Things 3. The only thing you need is to just start typing. A search window will automatically pop up, providing you with relevant suggestions and allows you to refine your search and choose between potential matches.

Another very powerful feature is the way Things handles repeating actions. In OmniFocus, the next iteration of the action will be created from the one that was just completed. This means that if you need to, for instance, push the start date for a repeating action, all future versions of the action will have the pushed start date instead of the original. The same goes for other changes, such as flagging or modifying the due date. Things is different in that you create a repeating action, and every time a new version of that action becomes available, a separate instance of the action is spawned, which can be modified freely without affecting the repeating action itself. For me, this makes a lot more sense and provides the flexibility required when working with repeating actions.

Finally, Things 3 is visually pretty amazing. So much so, that I had to tweet about it.

https://twitter.com/johnnychadda/status/1102683954019270657

Organization

What makes Things so simple yet powerful comes from its simplicity and structure in how it allows you to organize all information. Areas and projects provides a distinctive structure, which at first may seem limiting, but that is also what sets it free from being something to tinker with.

I have a number of areas of responsibility for work and personal projects. Each area is tagged with an area group tag, meaning that all areas related to work are tagged work. Similarly, all areas belonging to my personal life are tagged accordingly. This allows me to later filter out actions and projects that I'm currently not interested to look at.

There's no way of visually distinguishing areas in the sidebar, which is why I have created two fake areas which are just dividers. This is just to visually separate the areas into groups, and serve no real purpose other than that.

Projects are contained within the area they belong to, meaning I have no “loose” projects outside of an area. The only time that happens is if I have created a project on the fly from the Inbox and haven't filed it properly yet.

Areas can, in addition to projects, also contain actions. This is a change from OmniFocus where I needed to have single action lists for all actions not belonging to a project. Now I can just stick them in the relevant area, which makes getting an overview over everything in an area so easy, because everything from projects, single actions, future projects and someday lists are in the same place.

When first moving over to Things 3, I retained the tags from OmniFocus verbatim. The @computer context was for instance split up into three categories:

• dashes: short time, high focus
• focus: long time, high focus
• lounging: long time, low focus

That setup has been working great, and was necessary because of the way OmniFocus didn't allow one to easily choose which tags to show on the fly without creating a custom perspective. When moving to Things however, choosing a combination of tags is easy, which means that I don't have to limit myself to the three categories above. What I instead did was to separate the time and energy available tags from the actual context, which is the way it is recommended in the GTD book¹. That also means that those constraints can be applied to which ever context I'm working from, be it @computer², @home or @office.

I structure the time available tags hierarchically. Using the effect of inheritance, it allows me to for instance choose the “30m” tag, and have Things show me everything that takes 30 minutes or less. If the tags were ordered next to each other, I would only see the actions tagged specifically with “30m”.

The Today and Upcoming views are built into Things, and I use those as part of my Daily Review to get a quick glance of the day ahead. It neatly highlights the starred actions which I have marked as something I need to keep a special lookout for.

The Someday view is mostly used when doing the Weekly Review, and provides easy access to all the projects marked Someday. The inactive projects are spred out in their respective areas, and this view allows me to quickly see if any projects need to be activated.

Part of the Someday view is also the Guidance area, which contain lists for the higher horizons in GTD³. Another section is Reference, which contain lists that are not necessarily actionable, such as “Next time in…”, which is a place to keep recommendations for different parts of the world and is a great place to look when going to a new destination.

Finally, there are areas that contain Checklists and Templates. The checklists are what they sound like, a list of checklists for recurring procedures and is a great way to learn from past experience when dealing with certain things, such as packing for a trip or performing an interview. The templates are for recurring projects, such as when doing a new release or hiring a new person. The difference compared to Checklists is that Templates are copied for every instance they are used, and there can be multiple copies running at the same time (such as when hiring two people at the same time).

The Logbook is the last builtin view, and contains everything that has been checked off, either as completed but also dropped actions and projects. Reviewing the Logbook as part of the Weekly Review is something that I’m trying out now that I have moved to Things

Daily Workflow

The first thing I usually do when starting up for the day is to perform a daily review. This is not mandated by GTD, but I find it useful to know that my inboxes will be emptied at least once a day. This adds assurance in that I can add anything to my Things inbox and I know I will get to it the morning after at the latest.

When engaging with the lists to actually get some things done, the main view I use is Anytime. The sidebar is usually hidden, which limit distractions and serves as a visual distinction in that I’m in “engage mode” and not something else. In that view, I use the standard GTD criteria to figure out what to do given my current constrains. The first thing I filter on is context, and depending on the amount of actions in that list, I continue filtering on time available and energy. Finally, I may filter on showing only work or personal related actions depending on the situation.

Integrations

I have integrated Things as much as possible with the tools I use on a daily basis. First, email integration is done using the Things Cloud service, where one can send email which then pop up in the Things Inbox, together with a link to the original email. This means that I can click that link and the corresponding email will be opened in Mail. I use this mainly for emails that I want to keep track of replies for. When sending the email, I just BCC my personal Things Cloud email address.

When processing the email inbox however, I mostly rely on drag-and-drop on the Mac and the iPad, or use the clipping shortcut. This workflow allows me to quickly handle the less-than-two-minute emails, and defer the rest to a list in Things with the appropriate tags attached, which are usually “do” and “high focus”, together with “5m” or “15m” depending on the estimated time needed. Once the email is added as an action in Things, I archive the email since I can simply get back to it using the link in the notes section of the action.

Slack is a big thing at work, and I have created an automation in Zapier where if I star a message in Slack, it will end up in my Things inbox for me to process at a later time. This makes handling Slack a lot easier, since I don’t have to rely on marking conversations as unread just to remember to handle them at a later time.

Weekly Review

The weekly review is one of the core parts of GTD, since it keeps everything up to date and relevant. It is essential for making sure that the trusted system remains trusted going forward. I found that the best way to get the weekly review done is to have it scheduled in the calendar, at the same time every week⁴.

OmniFocus has a built-in review perspective, but I found that not to be all that useful. The idea is great, in that you can have different review periods for different projects, but in practice there are shortcoming with that approach, since if you were to do the review on another day for some reason, the schedule quickly gets out of sync. I also found it easier and more approachable to just review the projects in the normal projects view.

In Things, there is no built in support for doing reviews. What you instead have to do is to just go through each active project and make sure that it's up to date — it's just as simple as that. As I go through area by area and reviewing the projects, I also take a look at all the projects and actions that are scheduled for the near future, so I know what's ahead and if I have missed anything.

Someday projects may not need the same review period as active projects however, but they can be displayed in a separate view, which makes it easy to get an overview and focus on the projects that make sense at the time.

iOS

The first thing I noticed when using Things for iOS, and the iPad Pro in particular, is that the app and how you use it is almost the same as on the the desktop. This is huge, since it has been a major pain point in the past with OmniFocus, where I have refrained from doing certain things on iOS and deferring them to when I'm on the Mac. Things removes the entire discussion of a discrepancy, since the iOS app is fully featured and can do everything that the Mac app can do.

Since I use the third gen iPad Pro 12.9” as my main “computer”, it has been absolutely amazing to be able to use it without limitations, meaning that I can use keyboard shortcuts for everything in Things and now worry about being able to only do certain things on certain platforms. It just removes that discussion altogether.

There are a few things that work a bit different, and the way you choose which tags to focus on is probably the main one. On the Mac, there's a ribbon on top of every view where you can choose which tags to show. On iOS on the other hand, there is a menu option to open the tag selector where tags can be chosen. Once a tag has been activated, adding additional tags is easy, since there's a tag bar presented after choosing the first one, and tapping it will directly open the tag selector window.

When first starting out, I preferred the way choosing multiple tags on the Mac works, but have switched to preferring the way it's done on iOS. What's missing is a quicker way to get to the tag selection window though. Having to first tap the menu button and then choose the tag selector is one tap too many for something this essential.

Another thing differentiating iOS from the Mac version is the difference in how deleted tasks are handled. On the Mac, there's a Trash which shows everything that has been deleted. On iOS however, this doesn't exist, and you are limited to the built in “shake to undo” function to restore any accidentally deleted actions.

Things that bother me

While I am quite impressed by the power of Things, bundled in such a simplistic and appealing package, there are some things that bother me and would definitely make my life easier if they were addressed in some way.

First, one of the core features of OmniFocus is the ability to set projects and sub-projects as sequential, meaning that the second action will become available only after the first one has been completed. I never used sequential projects, since it's way too easy for actions to become invisible if you forget that the project is in fact sequential. What I often used though is sequential sub-projects, which makes it easy to map out a sequence of events and how to handle them. What I would like to see in Things is a way to set actions under a specific project heading as sequential. This provides the best of both worlds, in that the simplicity of Things is intact, while still allowing for power features to be exposed in a simple way. My current workaround is to use a “pending” tag and the remaining actions set as Someday, but that is not really ideal. This is also the thing that could be a dealbreaker sticking with Things for the long haul.

Speaking of project headings, I would also like to see them for areas. This would allow grouping related projects in a simple way. I would like them to also be present in the left menu bar, which would allow me to group my areas into different parts of my life. The workaround for this is to have empty areas with a line for a name to create a divider.

Like I mentioned earlier, choosing tags on iOS is pretty straight forward, however getting to the tag selector the first time is not. I have to first tap the menu button and then the tag selector. For something part of a core workflow, this should be exposed on the main view, like the current behavior when having chosen one tag already.

Another thing related to tags is that when selecting a tag, I would like to only see the remaining tags that provide a result and remove the other ones. This would help a lot when filtering the list to find the appropriate action to work on.

In the Anytime view, you can follow an action to its project, which enables you to quickly access project related information. Going back to the previous view on iOS is easy, just tap the back button and you're back to the Anytime view with all tags applied. On the Mac however, there's no back button, which makes it impossible going back to the previous view once a project link has been clicked.

Summary

I am amazed how well Things 3 works, being such a simple app at first glance. It supports the GTD workflow while still being opinionated in how it wants you to organize everything. I look forward to battle test it for a year and hope it will bring more clarity and help with focusing on the right things.

The only issue I had with the app itself was that an action didn't sync properly from one device to the other. This was fixed by their support, which was quick and friendly.

Now that you have read this entire article, it would help me a lot if you could spend a minute to fill out this feedback form, which will help me better work on similar things in the future.

1. The Getting Things Done book recommends first using context to filter the available actions, then time available and energy. Finally using a subjective priority when looking at the remaining actions. The reason priority isn't a tag is simply because it can change too often depending on outside factors. ?
2. The context normally called @computer, is called @do in my system, because I can do most things on that list both from an iPad, as well as using my Mac, and some of them even using my iPhone. ?
3. The higher horizons are split up into three different areas. Horizon 3 is about short-term (1-2 year goals), Horizon 4 is about a long-term vision on your outlook. Finally, Horizon 5 is about your purpose. ?
4. There are of course exceptions to this, since other meetings may have to take precedent. It is the exception, and if that happens, I make sure to schedule it for another time during the day. ?

One of the cornerstones of Getting Things Done is getting anything on your mind down to a trusted system. While this may sound simple in theory, how to actually handle different scenarios can be quite tricky.

Following the post on The 2016 OmniFocus Setup and Workflow, where I wrote about my GTD setup in OmniFocus as it looked roughly a year ago, I received some questions on how to take advantage of the workflow for certain scenarios. A Reddit user summed up these questions well in a comment, where the person was unsure how to handle the specific scenarios. I would like to answer a couple of them here.

I want to check out that CLI tool fzf and possibly include it in my workflow if I like it

When I stumble on things to research, the first step is usually that a link or similar would end up in my OmniFocus inbox when I first hear of it. In this case, I would use the share sheet in Safari or maybe the clippings shortcut to quickly get a link into my inbox, and then just continue going about my business.

I empty my inbox as part of my daily review, which I do in the morning when I arrive at the office, and sometimes after lunch and it’s finally emptied as my shutdown ritual before I leave the office. For this inbox item, I would name the action “Research fzf dev tool” and keep the link in the notes, and then just add it to my single-actions list¹, since I would think that researching the tool would likely mean actually installing and testing it. I would have assigned the context “Hanging Around”, since this is something I want to do when I have some time to spare and my focus isn’t at its peak, such as some time in the afternoon.

I have a new idea to build an app to do X (as in an hobby/idea/"someday", not a work assignment)

If this is something that I want to move on right now or within the current week or so, I would simply add it to my current projects and add the first² next action with the relevant context.

If this is something that I will move on in the future, it will instead end up in my Someday/Maybe list. These lists also reside in OmniFocus, but are paused projects and assigned to a context that is on hold. If the project is something I want to move on in the coming weeks or month or two, I will add it as a project under "Someday - Upcoming Projects" folder, which I review as part of my Weekly Review, so I can just activate anything there as appropriate. If the project is something for the distant future, I will add it as an action to the "Someday - Creative - Tech Projects" list. This list will usually also be reviewed weekly, but if I am short on time, I will just focus on the "Upcoming Projects" folder.

I want actually start building that app idea I had the other day (still not "work", no "due" date)

In this case, I would add the project to OmniFocus under the "Personal" folder. The next step is to add enough information to the project so you get everything out of your head. This can be next actions and support material. I usually try to keep support material in the notes field of the project, but if the project requires a lot of external information, I will instead keep it in Evernote and link back to OmniFocus.

I've been needing to backup and reinstall home media server this week (multi-step project, not truly "due" in the "work" sense, since no harm if it never gets done, breaking down into individual steps itself takes at least some effort)

I would handle this in a similar fashion as the previous question, e.g. create the project under the "Personal" folder and create at least one next action. If there's information that I have already gathered, I would add that to the project support information.

Now, if I want to work on this during the weekend, I would either just book some time in the calendar³, or maybe flag the next action so it would be on top⁴ of my "home" context. This way I know that I will be reminded of it every time I look at this list.

add a new feature/improvement/bug-fix to some application for work (a task with no defined due date, but not "someday"... project already exists)... details of "feature" yet to be worked out and I'm busy now

This is something that varies depending on how you work and if you work alone or with others, but say I would work for myself and my application needed a new feature, I would create a new project for it. The next action could be as simple as "Research / Look into how to do x for 'feature'". When working through my contexts⁵, I would just treat that action as any other and work on it as I get to it.

buy plane tickets for Christmas (when's it due? what's the context? How do I stop it from "slipping through"?)

The project in this case could be "Christmas trip prepared", and if you already know where to go, a next action could simply be "Book 4 plane tickets on thewebsite.com to visit family for Christmas" and the note field can contain related information if that helps you get it out of your head. The context if using the classic contexts would probably be "mac" or similar. In my setup, I would just set the context to "Short dashes", since this is something that's fast to do. Maybe even just skip this altogether and just go ahead and book the tickets.

Another scenario could be to find a vacation destination to take your family for Christmas and in that case, the next action could instead be "Research Christmas holiday destinations", with the context "mac" or "Hanging around" if using my setup.

I would set the due date for the project to the date you want to leave for your trip, but again, if you want to be sure to get something done at a particular time, just schedule some time in the calendar where you will look into this. I usually look at my "Hanging around" list when I'm on my iPad or iPhone⁶ and have a decent amount of time.

a bill that's due next week (so important), but there was an error in the bill, so you are "waiting" to hear back from them before you pay... how do I stop this from "slipping through", or how do I escalate to "time to stop waiting"?

In this case, I would create a project called "Xyz bill paid" with a next action of "Waiting for response from xyz re: bill". The action would have a due date well in time before the bill is due where I still can do something about it if I don't hear back, together with the "Waiting for" context. I will set the due date for the project itself to the date the bill must be paid at the latest.

As part of my daily review, which I do every weekday in the morning, is to look at my Waiting For perspective⁷ in OmniFocus, which is sorted by due date. This means that if I haven't heard back from the bill collector by the due date set, I can take action.

If they do get back to me before the waiting for is due, I will either just pay the bill directly if I can, or add a new action called "Pay xyz bill" to the project. If I remember that there is a "waiting for" action created, I check that off. Otherwise, it will surface as the due date approaches, and then I can cross it off my list.

1. I have a single-actions list for “Personal” and for “Work”, where I gather small actions which are not part of a project. ↩
2. Not necessarily only the first next action, but as many as I need to get the project out of my head. ↩
3. The calendar is a trusted system, meaning that I trust it to notify my of upcoming scheduled time. That means that it's important to keep the calendar honest and not save things there that don't belong there. ↩
4. I sort my context list by flagged and due, so they will be higher up in the list than the rest of the actions. ↩
5. When working on a context, I usually just start at the top and continue down. During my Daily Review, I flag actions that I want to get done before others, and I have sorted the context view in OmniFocus to show me flagged and due actions above everything else. This provides me with the confidence and trust that I will see and get to the most important actions first. ↩
6. My larger iPhone 6s Plus really helps here, since it lets me work almost in the same way as if I would be using an iPad. ↩
7. Read more about how my perspectives are setup in my 2016 OmniFocus Setup guide. ↩

I recently did a walkthrough of my OmniFocus setup on Learn OmniFocus. The webinar was recorded and is available right here. Be sure to check out the show notes for the apps and other links that I talked about during the webinar.

I have written countless posts on OmniFocus and the Getting Things Done methodology, but this is the very first time I have gathered my entire workflow and setup into a single piece. Since my GTD setup is an ever evolving organism, this can only be seen as snapshot in time for when this article is written, and the real changes will be visible when I write the 2017 edition of this very post and highlight the differences.

If you are not already familiar with the Getting Things Done methodology, I strongly suggest that you to read the book before implementing the things I mention here. The book is fairly short and is divided up into three parts, where the first is mostly about the underlying theory and why it works. The second part is the implementation step where the author David Allen guides you through the big task of setting up your own GTD system from scratch. The last part is about looking upwards and onwards to the bigger things than the daily grind of going from task to task. This is where you start to define goals and pave a path ahead. Instead of letting work be defined by others, you are defining your work to be aligned with your goals.

You’ve got to think about the big things while you’re doing the small things, so that all the small things go in the right direction.‌‌— Alvin Toffler

Table of Contents

‌

1. Projects
2. Adding Projects
3. The TLC Project
4. Contexts
5. Perspectives
6. Today
7. Waiting For...
8. People
9. Someday
10. The Daily Review
11. The Weekly Review
12. Get Clear
13. Get Current
14. Get Creative
15. The Monthly Review
16. The Yearly Review
17. Reflecting on the higher levels
18. OmniFocus on iOS
19. hat I would like to see in the future

Projects

A central part of setting up OmniFocus is defining the projects list in a way that makes sense for you. For me personally, it makes sense to define separate trees for my different roles in life, one for "Personal" and one for "Unomaly", where I currently work.

The next level within these role folders contain areas of responsibility for the particular role. For my personal role, some of the areas can include:

• Family & Friends
• Home
• Photography
• Writing

Professional areas of responsibility could include:

• Admin
• Business Development
• Marketing
• Product Development

It all depends on your roles, so these examples should be seen as guidelines. For your situation, professional areas could instead include "Development", "Infrastructure", "Support", or maybe only having "Current Clients" if you are managing a lot of customers and their respective actions.

Adding Projects

During my weekly review, which I will discuss in detail later, I make sure to file projects under their respective area of responsibility. I have noticed a cognitive overhead having to think about filing each time a new project is added, which is why I simply refrain from doing that. When processing something in the Inbox and realizing it should be part of a new project, I simply type the project name into the project field and press cmd+enter to create it at the bottom of the projects list. It doesn't matter if it ends up being uncategorized for a while as long as I give the project a verbose description, since I know it will end up in the proper folder at least during the weekly review.

The TLC Project

I have a special single-action project under my Friends & Family area called TLC, which have repeating actions for each person I want to keep in touch with but won’t necessarily do on a regular basis without a gentle reminder once a month or so.

This means that every once in a while, an action will pop up with a name in my short dashes context, telling me to reconnect with the person in question. When handling the particular action, it can simply be deferred if I have already been in contact with the person recently, or make sure something happens by creating an action or contacting him/her directly.

Contexts

Contexts are defined as being the constraints put on us in different ways. Simply put, if you are physically in the office, there is no sense in looking at the actions available in the At Home context since you can't do anything about them at that time and place.

David Allen suggests having a context for At Computer and Calls, but since technology such as computers and phones have become ubiquitous, those may not apply in the same way for everyone. Granted, if you are someone who calls a lot of people, it could definitely be beneficial to keep that Calls list for when you are in an undisturbed area and in calling mode. For the rest of us, calls could just as well be placed in the Short Dashes context, which is part of the A Fresh Take on Contexts approach. These new kind of contexts makes deciding about time and energy more explicit.

My full list of contexts are:

• Routines
• Office
• Work
  • Full Focus
  • Short Dashes
  • Thinking
  • Hanging Around
  • Braindead
• Errands
• Home
• Agendas: Meetings
• Agendas: People
• Waiting
  • Email
  • People

The contexts are listed in the order of my usual day, meaning I first want to check off any routines actions that have come up, and then do the things I can only do in the office. The Work contexts are where I spend most of my time, and the Full Focus is where the "real" work happens, since it contains all actions related to actually getting stuff done, including code and articles to write. The Errands context contains several sub-contexts with certain stores which I frequently visit. If I add an action to the general Errands context, I usually prefix it with the store name where I am likely to buy it if possible in a way to group things I can acquire at the same place.

Perspectives

One of the most powerful feature within OmniFocus is perspectives, the ability to filter and group actions and projects in a way that is relevant to you in a particular situation. These perspectives are part of my daily workflow, and for an in-depth look at these, read my article on perspectives on Inside OmniFocus.

Today

My day starts with looking at the Today perspective, which contains flagged, due and overdue actions. It is my safety net and makes sure things never fall through the cracks, since it will show me all things which are becoming due. Before tackling anything else in OmniFocus, I try to make sure the actions within the Today perspective have been checked off.

An extremely important thing about due dates is to only use them when things are actually due, and not setting arbitrary due dates only to be reminded of things. For that purpose, flagging the action is sufficient as it will pop up at the same place as the due actions. This means that if something is due, I better work on that first thing.

Perspective setup

• Project hierarchy: Don’t use
• Group actions by: Context
• Sort actions by: Due
• Filter by status: Due or Flagged
• Filter by availability: Available
• Filter contexts: Active

Waiting For...

The Waiting For... perspective is used when waiting for someone else to complete something. It could be a delegated action, or that I am waiting for a delivery to be scheduled. Whatever it is, it can be tracked within this perspective, and if someone is supposed to get back to me by a certain date, setting a due date assures that I know when to take action if necessary.

Since I don't handle a large amount of email at work, I can use the Waiting For… perspective to track email responses as well. There is a sub-context called Email where I group all actions related to me waiting for someone to respond via email. This setup depends on the volume of email tracking which needs to be handled, and if there is a lot, it's usually much easier to simply handle it within the email application itself by using certain snoozing features, flags or similar.

Perspective setup

• Project hierarchy: Don’t use
• Group actions by: Context
• Sort actions by: Project
• Filter by status: Any Status
• Filter by availability: Remaining
• Filter contexts: Remaining

People

The People perspective is used to to gather everything I have to discuss with people, as well as everything I am waiting for the people for, into one place. To distinguish between people, the actions are always prefixed with the person’s full name, which means I can simply search for the actions for a specific person by pressing cmd+alt+f and start typing. The actions are additionally ungrouped and sorted by name, which means that actions from both Agenda: People as well as Waiting: People are gathered together per person.

Making it this easy to add waiting actions for people have taken my ability to track responses to a completely new level, since the overhead of actually tracking things using this approach is minimal.

Perspective setup

• Project hierarchy: Don’t use
• Group actions by: Ungrouped
• Sort actions by: Name
• Filter by status: Any Status
• Filter by availability: Remaining
• Filter contexts: Remaining
• Sidebar Selection: Agenda: People & Waiting - People

Someday

My favorite perspective is called Someday and this is where I keep track of things I may want to do in the future, but can't act on right now. It contains a lot of different kinds of information separated into a number of lists. While I have lists for projects and goals I may want to tackle in the future, the most fun lists are the following:

Blogging ideas contains a list of things I may want to blog about in the future. They can be links to other articles, notes I have jotted down at some point and thrown into my inbox, or half-written pieces which were written in the spur of a moment.

Gift ideas is the perfect list for keeping track of things other people want or need. If you for instance realize your partner has been looking a lot at a particular jacket but still hasn't bought it, add and action with their name in this list and the jacket as a sub-action to that. After a while, you will have a decent list of wants and needs corresponding to friends and family members. When Christmas time comes around or someone is celebrating their birthday, you will be prepared with a list of ideas on what to get them!

Next time in... which in essence is a database of recommendations and a way to keep track of things to do at a particular place. Let's say you have a friend who recently visited London and just couldn't stop raving on about a fantastic bar called Nightjar and the amazing cocktails they serve. The next time I go to London, I want to be reminded of this place, so what I do is to create an action called London within this list, and as a sub-action I add Visit Nightjar together with who recommended it and other details in the notes field. This approach makes it easy to acquire a wealth of recommendations and keep them in a trusted place for the future.

Restaurants to try is a great way of keeping track of restaurants in your local area. You can of course use a dedicated app like Foursquare, but the power with these kinds of lists lie in the fact that they are agnostic with regards to the information stored.

These are some of my favorite someday lists, but you can just as well add a list for Books to read, Movies to watch and Games to play and even Weekend trips to take depending on your needs and what you want to keep track of.

Perspective setup

• Project hierarchy: Use
• Group actions by: Ungrouped
• Sort actions by: Unsorted
• Filter by status: Any Status
• Filter by availability: Remaining
• Filter contexts: Remaining
• Focus: Unomaly - Someday (folder) & Personal - Someday (folder)

The Daily Review

The daily review is a quite simple step to add to the beginning of the day, but with a profound impact of making sure I'm on top of every everything I need to be aware of. The daily review action itself is a recurring action set to defer another: 1 day, which makes it automatically pop up the next day after completion. I make sure the action is flagged, which means it will be listed on top of my Today perspective.

The action itself contains a small list of things to do within its note field. One could argue that it should be a recurring project instead with every step as a discrete action, but I found it to only adds to the clutter and not necessarily adding any benefits over only having a small list in the notes field.

My daily review consists of the following steps:

• Review perspective: Forecast & Calendar
• Review perspective: Waiting for
• Review perspective: Stalled
• Process mailbox
• Process Dropbox inbox folder
• Process Evernote ((I currently use Alternote, which uses Evernote for syncing but has a cleaner interface which makes it more pleasant to work with.)) inbox notebook
• Process the OmniFocus inbox
• Schedule slices in the calendar for important actions

The steps are fairly self-explanatory, but I use the Forecast view to check the calendar for today, as well as any actions which need to be handled within the coming days. It is also a good way to see which actions are becoming available today and going forward.

I make sure to process all inboxes at least once a day, which for instance means that for every email, I decide the next action for it. If it can be completed within a couple of minutes, I do it there and then ((This is a standard practice within GTD and can have profound importance in keeping things moving forward, even if you only implement this small thing.)). Otherwise I will add an action to deal with it at a later time. In Evernote, there are usually notes in the inbox waiting to be filed, while others are to be deleted. Notes from meetings are checked for any actions or to delegate to other people before moving them to the appropriate notebook.

The Weekly Review

The weekly review is the thing making this all work. If (and when) I fall off the grand GTD wagon, I know I will always have the weekly review to fall back on. It is so important to me that I schedule it in my calendar every week, usually on Friday morning. I try to do the weekly review in a café, or at least somewhere I know I won't be disturbed for one hour and a half.

The things on my checklist for the weekly review are fairly standard, but I have added a couple of things which make sense to me. I suggest you include the things you want to be on top of at least once a week, to make sure nothing falls through the cracks.

Get Clear

The first part is called get clear and includes everything I need to do to keep up with my world and its inputs. It contains the following actions to complete:

• Clean the office desk and make sure all the loose papers and cards are put into the inbasket for further processing.
• Clean the home desk is similar to the office desk, but is usually done in the weekend, since I do the normal weekly review at another location.
• Clean your mind close your eyes and take a moment to note anything swirling around in the head and make sure to write it down in the inbox.
• Process all Inboxes involves processing all inboxes which are part of my daily review.
• Empty Gmail spam boxes once a week, I go though the spam folder in my personal and professional mailboxes to make sure no legitimate email have been marked as spam. After looking through the spam folders, I delete all remaining emails.
• Check Facebook inbox other folder On multiple occasions I have missed opportunities, since I don't get a notification for anything in my other folder in Facebook. This is why I make sure to look at it at least once a week.
• Review iPhone camera roll for last week I usually take a lot of photos during the week, and some of them require processing. Some photos should be added to Day One, others may contain snapshots of whiteboards with information to process.

Get Current

Get current is all about getting up to speed with all commitments and include the following actions:

• Review the calendar for next and previous week make sure I haven't missed anything important the last week, and check the next week for anything which needs to be prepared. Activities outside of office hours are added to the shared family calendar to let my girlfriend know I will be home late.
• Review Waiting For look through all actions and follow up on the ones need to be nudged and check off those which are done.
• Do the Omnifocus Review this is where I use the built-in review system in OmniFocus and go though all projects and make sure they are up to date.
• Move new projects to appropriate folder Since I can add projects on-the-fly, those projects are filed into their respective area of responsibility.

Get Creative

Get creative is where the fun things start. What can I do to make the coming week extra fun and something to look forward to? It could be to pick a great restaurant from my restaurants to try list and making a reservation or starting a fun project at home. These are the action items I check off for this part of the weekly review:

• Review Someday/Maybe Go through the various lists for things I want to move on.
• What do you want to achieve for next week? Any particular projects currently on hold which should be activated?
• Home projects to fit into the schedule? I try to at least have a couple of active projects which are fun and part of my self-development.
• Review Weekly Review agenda look though my weekly review agenda context for things I want to do during the last part of my weekly review. It could be things like updating some of my checklists, or try out a new context for the coming week.

The Monthly Review

My recurring project for the monthly review contains a small number of items, and the most important thing is to check the physical tickler file for things which should be acted upon. This is something I plan to expand on in the future, grouping more recurring tasks as part of the monthly review instead of having them repeat throughout the month.

The Yearly Review

Similarly to the monthly review, the yearly review consists of moving the appropriate tickler folder for the upcoming year into relevant monthly folders for the year to come and expunging old information in the tickler file. The project is usually activated one week before Christmas, which gives me ample time to review and ponder the year gone by and plan ahead for the next.

Write retrospective post is like a sprint retrospective within an agile development setting, but applied to one year. It's a post where I explore the year gone by and my thoughts about it. These kinds of posts are usually kept in Day One, but I am thinking about publishing a cleaned up version of these on the blog in the future.

Clean out reference is where I expunge old reference material from physical folders as well as from my Evernote reference setup.

Move tickler for next year into month folders means moving items from my yearly tickler folder to monthly folder for the upcoming year, or throw them away if they are not relevant anymore ((Things such as warranty information may become obsolete if I don't own the things anymore.)).

Reflecting on the higher levels

The Getting Things Done book define six horizons of focus, and the end of the year is the perfect time for thinking about these higher levels — what you want to do with your life, your goals and the focus for the coming years.

runway is the bottom level where all your next actions reside, and since these are reviewed as part of the weekly review, these are usually left as is.

10k feet is the first level of goals, which in terms of OmniFocus are all projects, which the next actions are working towards completing. Since these projects are reviewed during the weekly review as well, I usually don't spend a lot of time reflecting on them. Just be mindful of these as we are climbing higher, since you may find that some of these don't necessarily align with either your long-term or short-term goals. The decision then has to be made whether to keep them or drop them altogether.

20k feet contains the areas of focus, as defined in the GTD book. Take some time to reflect on all areas which are currently active within your life and if some of them should be removed or others added as your responsibilities change.

30k feet is where you define your one to two year goals. These goals should be attainable and there should be a way of moving these forward by creating projects which can make them happen. Some example goals could be:

• Make sure to get at least 7 hours of sleep each night
• Research getting an activity band
• Take advantage of weekends
• Book weekend travels to European cities
• Write more
• Start a niche blog
• Better mind, better focus
• Meditate once a day

40k feet is where things start to get somewhat complicated, since the kind of goals here are your five to ten year goals and plans. Taking inspiration from Personal Goal Setting, I have found it useful to divide the goals up into several categories and areas:

• Career — What do you want to achieve?
• Financial — How much do you want to earn? Are there goals on the 30k level to make this happen?
• Education — What do you want to excel at? What knowledge do you need to achieve other goals?
• Family — Do you want to be a parent? How do you want to be seen by friends and family?
• Artistic — Do you want to achieve any artistic goals? Writing a book?
• Attitude — Is any part of your mindset holding you back? Is there any part of the way you behave that upsets you? If so, set a goal to improve your behavior or find a solution to the problem.
• Physical — Are there any athletic goals you want to achieve, or do you want good health deep into old age? What steps are you going to take to achieve this? Think about both your body and mind.
• Pleasure — How do you want to enjoy yourself? Travel? Sports?
• Public Service — Do you want to make the world a better place?

Try finding at least one goal within each of these categories, and provide short-term direction in the 30k level for a couple of them to actually move them forward.

50k feet are your life goals and where you answer questions like what the end-game for your life is, and what kind of legacy you want to leave for the future. These things are usually hard to come up with, but once you do, there are ways of making a lot of these things happen by affecting the levels below until you come down to the 10k feet and actually make these things occur.

Using outlining or mind-mapping tools for exploring the 30k level and above are often fruitful and usually provides real insights, so make sure to touch upon these subjects at least once a year.

OmniFocus on iOS

While my Macbook Air is where I use OmniFocus the most, I sometimes use it on my iPad, but more often than not on my iPhone. The iOS version works reasonably well, but is seriously lacking in the organizational parts of managing folders and projects. This means the iPhone version is mostly reduced to a capture tool and for using the specialized contexts, such as Errands and Agendas for checking things off on the go.

Siri integration is seriously the most amazing thing of the iOS version, since it lets me capture things into my inbox using my iPhone 6S Plus simply by saying:

Hey Siri, remember to ...

Since Siri is always listening, capturing thoughts and ideas become ubiquitous and aids in making sure nothing slips through the cracks by lowering the bar of the initial capture.

What I would like to see in future iOS versions of OmniFocus is a stronger resemblance to the flexibility in the Mac version, where projects and actions can be dragged and dropped virtually everywhere with ease, especially on the iPad ((The iPad Pro makes the organizational deficiencies painfully obvious, given the huge screen.)). Another thing in need of improvement is when showing a custom perspective doesn't show the individual projects or contexts to choose from on the iPad, but instead displays all actions in a flat list therein. If the context for instance, is Someday, this list can become quite long and unmanageable.

What I would like to see in the future

While OmniFocus is an excellent tool for keeping track of everything one could ever want to track, there are some areas in which it could use an improvement. The first and most obvious thing to improve is the Forecast view, which is great for looking ahead and seeing commitments which are due in the coming days, as well a keeping track of things about to start. Its calendar integration works reasonably well, and displays all calendar items from chosen calendars. What's missing is the ability to edit or create new items. That coupled with a more powerful calendar view could bring the Forecast view into the forefront of keeping track of hard commitments ((By hard commitments, I mean things which are due on a specific date or time, or meetings that are generally tracked in a calendar.)).

The other area which I would like to see OmniFocus improve a bit on is the place for reference material. There is currently support for attaching a note to both actions and projects, which works reasonably well. I would like to see notes getting an overhaul and becoming more of a first-class citizen within the ecosystem. A distinct use-case for me personally would be the ability to view project-wide notes when viewing actions contained within the context view, without having to switch to the projects view. That way, all project reference material can be kept there and will be available for all actions within.

I will leave you with something I think captures the essence of GTD and the reason for using OmniFocus:

I can't forget, because I don't need to remember.‌‌— Johnny Chadda

If you still haven't downloaded OmniFocus, get the Mac version and the iOS version.