I've just updated Complice to give it primitive support for FVP directly!

A user sent me this article and asked about some changes to Complice that would make it easier to use FVP. I took a different approach than he suggested (creating a filter to only show starred actions) but I came up with something that I think works substantially better.

First I added a new hotkey (d) to mark a dot next to an intention in your list, which is sort of the bare minimum needed to implement FVP or Mark Forster's other systems, which people have tried using the star ★ feature for. So select an intention with the arrow keys or j/k, then press d to dot it. Pressing d again clears the dot.

Then it became clear that the usual assumption Complice makes about your "next action" (that it's the top item on today's list that you haven't yet done) is completely backwards for Forster mode. So I changed it so that if you've put dots next to any intentions, it'll treat the lowest dotted item on the list (that you haven't done yet) as your next action.

Then I made sure that that algorithm worked on the backend too so that this same next action is used for the new tab page extension as well.

I've added some styles to visually diminish the items between the dotted ones, since those sort of aren't in consideration. I'm intending to make a mode where it hides those altogether, but that's a larger project at this point.

There are still a few other improvements to make, like clearly disambiguating between "do" mode and "prioritize" mode, and at the moment the UI doesn't guide you through the process whatsoever so you need to already know how you're using the dots, by eg reading this guide above.

If anyone has used other systems by Mark Forster and can comment on which are compatible or incompatible with what I've done so far, that would be great. I know he has dozens but I've barely dabbled with them at all. And of course I'm also interested in hearing other ways that this system could be improved.

If you're new to Complice, know that it's very opinionated about a few things, and one of them is that you start with a fresh list every day. That's not likely to change anytime soon, which technically goes against FVP but ultimately seems compatible with what Will describes above where he starts fresh about daily. And it has tons of other people features for tracking progress towards specific goals, and doing daily-weekly-monthly reviews based on what you've worked on in those periods.

This is basically the algorithm I use when trying to get my 4yo to make a choice. I can tell you it works even with just 2 options! I choose a default (usually based on what I want), and then go through the other option(s) one at a time asking, "do you like this one better than the current default". If yes, that becomes the new default. I weed out the bad choices myself (based mostly on time and safety) and simply don't present them at all. At the end of the list, even if the kid is acting like a brat and refusing to participate at all, I still have a default option to execute on.

I've always figured it works because of that initial choice of default option. It's easier to compare how much we want to do one thing vs. another than it is to pick from a large list, and even more so if we clearly define and commit to an option that will trigger if we don't choose otherwise. Using (variously arbitrary) defaults makes it very obvious that refusing to choose is choosing to let somebody else make the decision for you (even if "somebody else" is just the random order of the list). I've also noticed this method also doesn't induce decision fatigue as fast as other methods.

So it seems like there's a bunch of great things about this technique, including avoiding overwhelm and thinking abougt prioritization. At least partially it seems like part of the benefit of the system forces you to look at and confront things that you've been trying to avoid.

In my own life and also in my work as a procrastination coach, I've found these sorts of methods that through brute force cause you to have to look at things you're avoiding often have a shelf-life. Eventually, it seems like people's avoidance mechanisms reassert themselves through meta-avoidance like avoiding using the technique, or avoiding adding certain items to your list.

I'm curious how long you've been using this algorithm, and if you've encountered any of this meta-avoidance.

This is my favorite kind of lesswrong post -- a quick rationality technique that I can immediately go try and report back on.

I was able to prototype it quickly in my notes list by using a dedicated symbol as the marker.  It looks like any weird/unused symbol could be used as this.  Seems like a quick hack to work with any digital list (I used §).

Question about non-stationarity: How often is the "stable" prerequisite violated in practice?

E.g. if a bunch of items are physically exhausting, and a bunch are not, I might want to not do physically exhausting items in sequence.  I didn't run into this personally in my tiny trial, so at least the answer isn't "all the time".

Thanks for presenting this algorithm! I had not heard about it, and might try it at some point.

One thing I'm curious about is its interpretation as a sorting algorithm. Because basically what you are doing is sorting your list using pairwise comparisons. It cannot be better than the classical sorting algorithms, because comparison based sorting takes at least $O\left(nlog\right(n\left)\right)$. But maybe the benefits is that it's more intuitive to do for a human being than quicksort or mergesort? Or that it require a weaker sense of transitivity than those? Also, I wonder if this isn't a known sorting algorithm.

let input: [Task] be the input list (n elements)
initialize:
  emitted: [Bool] = [False, False, ..., False] (n elements)
  descending-stack: [Int] = [-1]
  current-min: (Infinity | Task) = Infinity
  last-pop: Int = -1

repeat:
    for i from last-pop + 1 to n-1:
        if not emitted[i] and input[i] < current-min:
            push(descending-stack, i)
            current-min = input[i]

    last-pop = pop(descending-stack)
    if last-pop == -1:
        finished()

    emit(input[i])
    emitted[i] = True

This algorithm seems like it can be generalized for any human decision algorithm. For instance, I'm usually pretty indecisive while trying to order food, but I'd bet that implementing this algorithm would speed up my decision making immensely, while guaranteeing I'd be selecting the best option available.

This seems useful and sensible, thanks!

asking whether the new task is something you want to do more than the old task

Why not just say "whether the new task is a better thing to do than the old task"? Like, there's the rule to start your day with whatever has the biggest "ugh field", i.e. whatever is most painful. I get that you're using "want to do more than" broadly, but still, it carries the wrong connotation for me. :-)

I wrote my own FVP prioritizer and found it reduces overwhelm and encourages me to prioritize self-care and communication more highly.

I don't stick with most scheduling apps because my main goal with task prioritization is to reduce overwhelm and figure out how to sequence my decisions. FVP is nice because it doesn't involve figuring out a big, complicated app, and it gives a specific structure for sequencing things.

There are features FVP needs that are easy to do on paper but need specific implementation on a computer.

• Task add/delete and undo/redo features usable during the prioritization session
• Choosing to do a task immediately
• Reprioritizing the undone tasks
• Putting a task on and off the "backburner" - I want to be able to dump every thing I might conceivably want to do into a list without any discrimination whatsoever, then during prioritization, say "this task isn't going to get done in this FVP session but I want to keep track of it for later"
• The ability to "upweight" items I've been neglecting in some fashion. For example, tagging an item such that the app will nag me a little bit to get it done when I try to prioritize something else instead.

I just created a Google sheet on my phone dedicated for this. Tasks go down a column. Bolded tasks are marked. I turn the background black if the task is completed (no strikethrough feature on the app). Orange background indicates a task I'd ideally like to do next, but can't - as an example, grocery shopping, but the store's closed.

I never use the star feature on Google sheets, so I'm using it to make this readily accessible. I star the spreadsheet, which then is readily accessible by clicking the triple-bar menu and selecting the "Starred" folder.

One nice thing about this approach is that I can create sub-todos. For example, let's say that one of my ongoing projects is studying aging literature. I might have a list of 10 topics I want to dig into. But I don't want to clutter up my list of daily tasks with a gigantic running list of specific aging subtopics. So I create a separate tab on the spreadsheet specifically for "aging research," and list topics there. I can do this for tasks related to PhD applications or any other task that routinely occupies a chunk of my day and doesn't have an enforced order to the tasks.

I like this because it's using software I use already, so the interface is familiar and flexible. It's free. And there's little risk that Google is going to vanish and take my todo list with it.

I modified this slightly lately: sometimes, there's one task (task A) that I have a strong desire to do on one dimension, but I have a strong desire on another dimension to do not that. In this case, I can have a hard time making good comparisons- once I get to task A, I highlight it, then every comparison afterwards becomes very hard- in one way I would like to do task A, but in another way, I'd rather do the other thing. Since I do a similar comparison multiple times, comparing task A to several other tasks that have a cloudy preference, this puts me at high risk (double jeopardy) of accidentally marking another task at some point as higher-priority, even though task A might have been the better choice.

To avoid this, and to reduce the number of difficult comparisons, once I identify a task that feels high-priority along some dimension, I will use a new marking to highlight task A, then restart the process starting with the next two items. I will then ignore the extra-marked task (task A) until I've gotten all the way through the list, then compare the final result of the second half against task A, meaning I only have to make the hard comparison once, both saving mental effort, and reducing the chance of accidentally skipping the most important task.

Thanks for posting this, it seems like a system that will help me stay on top of things that need doing, at least on some days. I've applied this today to my todos, and it has already helped me do some useful things today, in a way that felt less overbearing than other approaches to todos I've used in the past.

As someone who both has spent a nontrivial amount of time thinking about todo lists, and has experience with programming, I'm somewhat surprised that I've never done this exact approach before, since the procedure here is very similar to the code I would write when I need to find the element of a list that maximizes some property, which is a very common task.

(By the way, are you still working on your aging sequence? I enjoyed the first two posts you wrote there, but it's been half a year since I've seen anything in that sequence)

Oh, this is very good.  Thank you.

How would you say this approach relates to https://www.lesswrong.com/posts/dJQ7BFz9ZPqstP3an/urgent-and-important-how-not-to-do-your-to-do-list? [LW · GW]

You wrote that it's important for your preferences to be fairly stable. I've been using a prioritizing grid (e.g. https://www.beverlyryle.com/prioritizing-grid) to go through my entire do list in 1 fell swoop. I wonder if that's more or less efficient than your approach.

Had some fun making a simple python implementation (text-based, no fancy GUI). I uploaded it to GitHub here

While I absolutely agree that an unsorted to-do list is a minefield, I intuitively feel that FVP is a more-wrong approach to To-Do lists. I also feel that it might work for very small, short term lists but would struggle to scale.

Tasks are extremely varied things and so not always easily comparable, for example when comparing the task "Buy milk" and "Finish term Paper", the term paper is probably more important in the longer term, but in the short term you wont have any milk for your breakfast. Unless extremely time crunched, breakfast comes first.

*Edit - After some reflection I think the main disadvantage of FVP is when you have to put in the decision making effort. You have to make a decision just before you do the task. Better to rank an issue as you write them on the list, that way you can separate the effort of doing the task from the effort of writing it on your to do list, see below for my favoured solution.

I use and love this, Urgent & important: How (not) to do your to-do list - LessWrong [LW · GW].  

My algorithm is:

• Write task description
• Decide if I “Must”, “Should or “Could” do it
• Decide if I should do it “Today” or “Later”
• Assign how long it might take me (optional)
• Use my spreadsheet to sort by rank (right click A column and sort A-Z)
• Do tasks from top to bottom
• When a Task is complete, replace “Must”, “Should or “Could” with "Done"

Here is my spreadsheet, I hope it serves you well.

To do list

I would love to receive feedback.