There’s many time management systems and software tools that include the concept of priorities. But priorities change with time and circumstance. Priorities can be useful, but not if you’re constantly re-evaluating them to keep them accurate. I think we can get around this conundrum with a combination of due dates and measuring one or both of two other characteristics: impact and effort.
The reason for prioritizing tasks is to help us decide now which task we should do at some future time. Obviously, we would prefer priorities to remain fixed once established. The basic problem is that they do not remain fixed.
The two archetypes for priorities are David Allen’s Getting Things Done (GTD) and the Franklin Covey approach. GTD is perhaps the one with the most buzz about it these days; the FC method is “tried and true.” And then there’s dozens of other systems out there. Most have some concept of priority, but I really don’t think any of the ones I’ve seen do it “right.” I’ll start by looking at GTD.
In GTD, priority is the last item in the rather ostentatiously named Four-Criteria Model for deciding what to do next. According to Allen’s method, you filter your possible “next actions” according to, in order:
- Context: are you in the right place to do that task?
- Time: do you presently have enough time to do that task?
- Energy: do you have the energy level presently to do that task?
- Priority: is the task of sufficient importance to execute now, compared to other eligible tasks?
Let’s look at each of these items in turn.
Lot’s of people depend on contexts to help keep them focused; one context for home, another for work, and so on. Most time management software support some mechanism to implement contexts, at least to a degree. If you prefer pen and paper systems, this just means keeping a separate list for each context. But I don’t use contexts because that’s not how my life works. There are plenty of home-related tasks that I can only do during work hours (e.g. schedule a plumber to deal with that leaky kitchen faucet) because my “home” task is someone else’s work task.
This underscores a key point of all time management systems: one size never fits all. To get a good system going, you need to invest the time to reflect on how you do things and tweak the system to suit you. Never let the system tweak you.
Having the time to do something is very situational; it depends on what else is going on at the time, and whether you can do the task all at once or whether you can divide it among multiple sittings.
In GTD, if you need multiple sittings to do a task, then you should probably break that task into subtasks. This is true, in my personal experience, at least some of the time. The bigger the task, the less likely I am to be motivated to do it when there’s so many other smaller tasks I could do. In those cases, I’ve found that breaking the task into subtasks helps a lot.
Of course, sometimes the task is just big by definition and you already know innately what the subtasks are. For instance, when I’m writing a research grant application – a big task by anyone’s definition – I end up with various subtasks that are mostly administrative plus one that reads “write the proposal.” This is itself a big task, but one that I know how to do in my sleep. It will take many sittings, but there’s no point at all in breaking it apart because I’ve got it down pat.
I think we can all agree that figuring out how much time is currently available to do a task is nothing that software can do. But it could be useful to be able to allocate a certain amount of time for the task; it’s rather like setting how long an appointment will last. This won’t work for everyone, but it will work for some.
The only piece of software that I know of that makes any attempt to manage the planned duration of a task is SmartTime. It tries to schedule tasks for you by filling in blank spaces in your schedule automatically based on a user-defined duration for each task. As far as it goes, it works quite well. Where it doesn’t work well is for those big tasks that take multiple sittings. If you have lots of those, you may find SmartTime hard to use.
Guessing your energy level is impossible for anything but your own brain. So don’t expect any help from software – or pen and paper for that matter – for that.
Finally, we get to priority, whatever that is. Unfortunately, the notion of “prioritizing” is so ingrained in out language and society that it’s virtually impossible to avoid. Politicians talk about priorities; our bosses prioritize corporate goals; we’re told to get our lives in order by setting priorities…. Is it any wonder we expect our time management systems to deal with priorities too? Indeed, all but the simplest software applications support task prioritization.
GTD-like apps usually have between three and five levels or priorities. Systems that follow the Franklin-Covey method use the so-called ABC-123 method, which is a nested three-level system. But I’ve never seen a crisp, robust definition of what exactly a priority is. And most of us will eventually run into “priority paralysis:” we’re so busy making sure we’ve set the priorities correctly on all our tasks that we don’t actually get anything done.
I’ve noticed that the GTD Four-Criteria Model is nearly spot on the way I do things, except that I do it unconsciously. Whatever is on my list, I scan it for what makes sense to do at the moment, taking into account where I am, how much time I can devote, and how I’m feeling. My preferred app for task management is Pocket Informant on the iPhone, which supports both GTD and ABC-123 priorities. (I’ve written about PI elsewhere.) But I use priorities to mark what I refer to as impact of a task: how significant are the consequences of completing it (or not completing it). More on that later.
So the problem is this: we’re surrounded by priorities, but they keep changing. Can we come up with a way to rank tasks that is natural enough to be used easily?
Mark Forster rightly identifies a number of flaws in blatant prioritization. These can be summed up simply: priorities change. So tracking changes to priorities becomes more organizational work that robs you of time to do the tasks themselves.
Forster’s solution, in Autofocus and it’s variants, is wonderfully simple: don’t bother prioritizing tasks. Instead, he advises, just spend a few moments scanning your list; the priority items will be apparent because you’ll just know. In my particular case, Forster’s method overlaps completely with GTD’s Four-Criteria model because it’s all internalized for me. Your mileage, though, may vary.
Toodledo offers another interesting approach. It calculates a measure of importance of tasks by combining other characteristics, including due date, priority, and whether the task is “starred.” The equation is:
Importance = 2+P+S+D, where
P = priority
S = 1 for starred, 0 otherwise.
D = 0 if due-date is non-existent or further than 14 days out, 1 if due-date is between 7 and 14 days out, 2 if due-date is between 2 and 7 days out, 3 if due-date is tomorrow, 5 if due-date is today, and 6 if overdue.
Of course, Toodledo’s importance measure depends on priority, so we’re back to square one. But I have used Toodledo, and I can say that the on-the-fly calculation of importance based on other, “simpler” characteristics is very useful. Since due dates are already included in the importance measure, you don’t need to consider time constraints when setting a task’s priority. Even this little thing made it easier to find a natural habit for assigning priority.
The downside is that sometimes Toodledo’s importance ordering just feels wrong. This means that I messed up in assigning something somewhere. This raises the spectre of blindly following Toodledo off a time management cliff: what if I miss a truly important item because I messed up?
There’s other systems for assigning priorities too, like NUNI. But again, the notion of urgency is tied to time. And Mark Forster has argued against urgency too. Spending all our time on “urgent” things virtually guarantees that things that are not urgent now will become urgent by the time we can deal with them. So we end up only ever dealing with urgent things. Who wants to live line that?
A New Approach: Effort & Impact
So I thought: what are the characteristics of priority? And can we partition them up so that we can treat them separately faster and easier than dealing the one big hairy priority monster?
First off: due dates. If our system can deal with due dates, then we don’t need to worry about time when deciding on a priority. That’s why I enjoy Toodledo’s importance measure. And most personal time management apps do handle due dates.
So what is it about some tasks that make us want to mark them as “high priority?” Not time; that handled by due dates. After letting my hind-brain stew on this for a few months, I came up with two characteristics: impact and effort.
Let’s consider effort first. I realized that my high priority tasks often involved a lot of work; the more work I thought a task needed, the higher it’s priority. The amount of work a task needs is not something that’s likely to change over time. So by tying priority to effort, we’ve eliminated one source of variability and it’s just that much more likely that a task’s priority will remain constant.
Here’s where breaking tasks down also comes in handy. By breaking a task into subtasks, I can partition up the effort required into smaller chunks, which leads me to lower the priorities of each chunk. If I break things down finely enough, effort contributes nothing at all to priority. Still, as I’ve already indicated, some of my tasks are big just because I already know exactly how to do it and there’s no point breaking it up. So effort remains a characteristic that works for me.
The other characteristic is impact, by which I mean the significance of successfully completing a task (on time, if there’s a due date). Buying toothpaste has a low impact. Submitting a $100,000 grant application has a high impact. This may sound like “importance” but it’s a little different. When we say a task is important, our focus is on the task. But I think the only reason a task is important is if it has significant consequences. It’s not the task that matters, it’s what the task implies if completed. After all, the task is a means, not an end; focusing on the task to the exclusion of the end is rather silly, and the more we focus on the task, the less likely we are to think about why we’re bothering to do it.
This may sound a little like goals in GTD, but it really isn’t. Goals are overarching end-states that drive the selection of projects; they’re “big picture” items that could take years to attain. By “impact,” I mean what a task’s completion implies, how it changes your world, and the world at large, in a very specific way. Again, it’s not about the importance of the task itself; rather, it’s about the effects of completing the task.
I think it is sufficient to have only two levels for each if these characteristics: low or high effort, and low or high impact. This gives us four possible values: E (high effort and low impact), I, EI, and none of the above.
We can map these alternatives to scalar values. “None of the above” maps to the lowest value and EI maps to the highest. The trick is deciding what to do with E and I. We can say that E is more important than I, or that I is more important than E, or that they are of equal importance.
The choice here is a personal one based on how we regard effort and impact with respect to each other. Personally, I don’t see how one can compare effort and impact; they’re apples and oranges. But that’s just me. If you’re seriously considering this approach to priorities, you should invest some time to decide which alternative you’re most comfortable with.
If you agree with me, then we can set E and I to 1; EI becomes 2 (1+1), and the null value becomes 0. Elsewise, if you think effort is more important than impact, you can set I to 1, E to 2, and EI to 3. There’s a similar way of handling impact being more important than effort.
This is pretty easy to do in your head. You can write these rules on a post-it that you keep in your notebook, or even stuck to the back of your PDA. I’ve sketched what the two alternatives I described above might look like, in the image on the left. It won’t take long for this technique to become second nature, if you stick to it.
Some may be uncomfortable with only two ranking levels for each characteristic. Using three levels is also doable, though a little trickier to do automatically. Look at what you might have on a post-it reminder of the values (see the images to the right) and you’ll see what I mean.
The top grid on the right is just for the case where you think effort and impact are of equal significance. If, however, you think one is more important than the other, things get even more interesting because you have to decide how much more significant one is than the other. One way you can do this is using a (0, 1, 2) scale for the least important property and (0, 2, 4) for the more important property. Again, you can see the result in the image. It’s not rocket science, but it’s trickier than if you just have two levels for each characteristic.
The Ugly Part
The worst part of all this is that no app currently supports this scheme of assigning priorities, so if you want to use this method, you’re pretty much stuck with pen and paper. It would be nice if at least some apps implemented some reconfigurability in their priority settings so that different users can change how priority is calculated from user data. Maybe some companies will read this and agree that more flexibility would be good.
The point is this: if you want to capture any sense of task priority, and if you want something more than just following your gut (which may certainly be sufficient for some people) you need to break the notion of “priority” down into pieces that are easily combined into an overall measure and are individually also easy to assign and crisply definable.