Prioritization design
Objective
Reduce psychological overwhelm experienced when organizing and prioritizing TODO lists. Reduce analysis paralysis during planning and procrastination during execution.
Background
The primary tool in productivity is a TODO list. Productivity systems and methodologies such as GTD and Bullet Journal offer ways to deal with those TODO lists. The main remaining challenge still exists, and that’s the feeling of overwhelm when seeing the entire TODO list. Sometimes the list itself might become a distraction, when attractive entries draw attention at the expense of other, more important entries.
Effectively, the goal of productivity systems isn’t to check off as many items as possible – that’s busywork. The modern approach in productivity is about putting time into what matters.
We can only effectively do one thing at a time. Productivity systems essentially must answer one simple question: what should I do next? Prioritization is the key aspect of productivity systems.
Yet, most of the existing solutions don’t provide a robust prioritization tool. Existing solutions fall into three main categories:
Absolute priorities
Fixed buckets of absolute priorities: P0, P1, P2, etc.
| Efficacy | Efficiency | Reliability |
|---|---|---|
| ★★☆☆☆ | ★★★★☆ | ★★★★★ |
Pros:
- Simple to implement
- Simple to understand
- System reliably remembers the priorities
Cons:
- Items are not prioritized inside each priority bucket. This method doesn’t answer the fundamental question: The answer to “What should I do next?” becomes “Something from one of the high priority buckets” rather than pointing at a single specific task.
- Keeping priority buckets limited in size creates a cascade effect
- The same item get re-examined multiple times; inefficient. Can work for teams when there’s a dedicated project manager who does the heavy lifting. The maintenance cost becomes prohitively high in personal use.
- Human brains are not suited for absolute judgements. Assigning abstract priorities requires keeping on your mind an abstract absolute priority scale and measuring existing concrete tasks to your abstract scale. It’s beeen proven to be unreliable.
- Mixed level of support for multiple lists. The meanings of P0, P1, P2 might differ depending on which list or project a task belongs to.
Stack ranking
Performed by e.g. dragging items up and down the list. Produces a full order.
| Efficacy | Efficiency | Reliability |
|---|---|---|
| ★★★★★ | ★★☆☆☆ | ★★☆☆☆ |
Pros:
- Easy to understand visually
- Decisive: No two tasks can be of the same priority
- Answers the fundamental question “What should I do next?” – it’s the top item in the stack.
Cons:
- Implementations are fragile, high potential for data loss. Apps allow for custom ordering of tasks but don’t attribute semantics to it. It’s easy to misclick “order by name” and lose the prioritization work.
- Prohibitively inefficient with long lists. If the backlog stretches for multiple screens, it’s essentially unworkable.
- Mentally taxing: involves making rapid comparisons between multiple items at the same time.
- Repeated reviews of priority lists create wasted effort: comparing and re-comparing the already existing partially prioritized lists.
- It only works within one list. What if the user wants to prioritize tasks split across two lists, keeping the two lists distinct?
- Seems to require to compare the bottom of the list as well as the top of the list; whereas in most cases it’s not important which item is number 56 and which is 57; it matters most which items are 1, 2, and 3.
Selection
In this model, prioritization happens implicitly when user selects a limited number of items from available sources to create the daily shortlist.
| Efficacy | Efficiency | Reliability |
|---|---|---|
| ★★★☆☆ | ★★★☆☆ | ★★☆☆☆ |
This method trades efficiency for reliability. It feels efficient because the user can quickly pluck their daily shortlist from the available sources, rather than assign abstract priorities or drag items up and down the list.
But the core inefficiency of this approach is that during each prioritization session the user will look at the same tasks. This system alsdo doesn’t build knowledge about user’s pool of tasks, it only knows what the user plucked from the pool each day.
Pros:
- Quick to build a shortlist from scanning source lists
Cons:
- Scanning the same sources during each prioritization session
- The shortlist is still not prioritized
- Execution might be skewed towards urgency
The efficacy of this method is moderate because the shortlist is still not prioritized, and therefore the method doesn’t fully answer the fundamental question of “What should I be working on next?”
The efficiency of this method is also moderate because the user has to view the same tasks multiple times, as many times as it takes for them to be picked for the shortlist.
The reliability of this method is less than moderate not because of a potential data loss, but because the user won’t be able to scan the entire backlog each day. This means that important tasks might stay in the backlog unattended, while the user might be confident that they made the right choices. Execution might be skewed towards urgency.
Design
Main design ideas
Pairwise comparisons
The main input from the user during prioritization is comparing tasks against each other. This method treats these comparisons as the first class citizen, and the prioritized list is built directly from them.
| Efficacy | Efficiency | Reliability |
|---|---|---|
| ★★★★★ | ★★★★☆ | ★★★★★ |
Human brains naturally excel at this, even when comparing tasks cross-context. It also helps to only compare no more than two tasks at any given time. This breaks down the prioritization process into simple, atomic steps.
Pros:
- Comparing tasks against each other is the most robust method for the human mind, both in terms of cognitive load and accuracy.
- No wasted effort; previous work is stored and reused.
- Priotitization can be done incrementally across multiple sessions without risk of losing data or accuracy. User can eventually process a backlog of virtually any size.
- No unnecessary work: no effort is used to find out fine-grained ordering of low importance tasks. Pairwise comparisons allow for constructing a partial order focused on the top of the importance hierarchy.
Cons:
- Long backlogs require many comparisons (however, prioritization can be split across multiple sessions).
- User might need time to start trusting the system, because they aren’t being shown the entire list.
- Not obvious to represent visually. User can inspect each item – which other items has it been compared against? – but to date there’s no robust way of visualizing the state of the system.
Resistance detection
Task that keep on being undone are automatically flagged as resistant. No explicit user input is necessary. The app tracks which apps are deemed important yet remain undone, and uses a statistical heuristic.
When Task Compass detects Resistance, it views it as an issue with the task rather than an issue with the user. There is no strong intervention, other than resolving the state in one of the following ways:
- Scheduling a focus session for the task
- Starting Pomodoro and/or marking it as complete
- Reassessing the importance of the task
- Eliminating the task
Focus sessions appear in user’s calendar and are 1h long by default. If the focus session passess and the task remains incomplete, Task Compass suggests scheduling another focus session.
Integrating with existing system
Task Compass radically rejects the idea of creating an own silo. Instead, it creates a layer on top of Apple Reminders that allows users to continue using their own systems built on top of the Reminders ecosystem.
The Remidners information available to Task Compass is limited by what the EventKit API provides.
Rejected ideas
Multiple ideas that are often encountered in existing systems, Task Compass rejects, and here’s why.
Use of AI for automated prioritization
This one is firmly rejected right from the outset. Having an AI choose for the user would remove the most important aspect of living an intentional life: it would remove user’s agency.
Multidimensional categorization
This refers to extra categories, tags, flags, and more.
Many productivity systems are built on the premise that more dimensions in task organization result in better organization. They offer dependencies, priority fields, tags, flags, and more.
Of course, there needs to be at least one level of grouping tasks together. But there are diminishing returns with each new categorizing dimension.
This also creates more work to annotate all the tasks. It might also turn out that in practice, users often don’t fully trust the categorization. People often need to “see all the tasks” to make sure they didn’t miss anything. They’d still scan the whole list in search for what’s most important.
Tags and flags are still available in the native Reminder app. They aren’t accessible via the EventKit API that Task Compass uses.
Dependencies
Dependencies help to filter out inactionable tasks from views and dashboards. They are mostly relevant in corporate and team contexts, and less so in personal TODO management. Task Compass leans to the side of simplicity.
Conclusion
Task Compass provides a robust prioritiation engine that automates the algorithmic and repetitive aspects of prioritization. The steering wheel remains entirely in user’s hands.
The automatic resistance detection alerts the user to risks of important tasks remaining undone.