Projects

My lists of things-to-do have been monotonically increasing since the time I started maintaining such lists. There are many plans to execute, things to learn and ideas to explore. Around last week or so, I found this pretty relatable post on Reddit.

Oh look, a new project idea!

from /r/ProgrammerHumor

Seeing myself out there, its important to know what makes me jump off from or into and idea. I believe I have seen two kinds of works. The first type has something in the details that touches you. Something that comes after you start working on it. An in-chore challenge that stimulates. Many of these are things you do for a living or something that you have to do. The second type touches you directly on a more personal level. All your personal projects which start with a 'this will be pretty slick' realizations come here.

To start with, the first type tasks usually come with implicit deadlines and are usually well structured in the sense that you can take 10 minutes and lay out a solid execution plan for the next 10 hours of work time. This results in a direct point of entry, either the deadline, or the concrete plan. The second type pulls you in because of its personal appeal.

As far as turn offs are considered. The first type, being drier to you as a whole, just needs a 'nothing stimulating left to do' state. For the second one, the appeal gets attenuated and the starting realization starts to look meager in magnitude than a newer idea. Both of these deteriorate the overall quality of outcome. In first case its because the work is mostly done near deadline. In second, its because no real progress is actually made. This cycle moves round and round and nothing much happens in general, even with all the lists stripped naked. This phase of indecision goes on for days with me. Hand waving at things without actually touching them. More touchpad than keyboard.

1. Micro tasks

A possibly promising way is to knit a tiny list of micro tasks for tomorrow with some quick and concrete steps to be taken for certain works. This will let me start off by getting in the working cycle and will keep indecision at bay. For the first type, this will keep the lamp lit. There is something to do so I don't get out of it and then stay sulky for weeks. Also, the final output would be a result of thoughts spread out over a longer period of time than last few days of the checkpoints. For second type, a tiny list reinforces the idea by making it more real. Hitting the real issues while actually working on something is not encouraging. The time that goes in making the list doesn't get counted towards a burnout and shapes the project in a better way, incrementally.

I have started to manage my lists in separate agenda views these days. There are stuck projects, which don't have any TODO state associated with them. These need a little bit of planning to pry out a few well defined TODOs. These are defined by org-stuck-projects as (skipping active, micro and old tags):

;; Avoid duplicating micros
(setq org-tags-exclude-from-inheritance '("micro"))
;; Define stuck projects
(setq org-stuck-projects
      '("+LEVEL=1/-DONE" ("*") ("active" "micro" "old") ""))

Further, org-agenda-custom-commands allows creating a dashboard for these lists. For projects (key p), I am interested in the micro tasks, the usual TODOs, all the currently active (being touched recently) 5-10 projects, the ones which don't have a defined way out (stuck) and the ones which are too old. Translating to custom agenda commands, these go like:

(setq org-agenda-custom-commands
      '(("n" "Main agenda with micro tasks"
         ((tags "micro"
                ((org-agenda-overriding-header "Micro tasks")))
          (agenda "")))
        ("p" "Projects to work on"
         ((tags "micro"
                ((org-agenda-files user-project-files)
                 (org-agenda-overriding-header "Micro tasks")))
          (todo "TODO"
                ((org-agenda-files user-project-files)
                 (org-agenda-overriding-header "Tasks")))
          (tags "active"
                ((org-agenda-files user-project-files)
                 (org-agenda-overriding-header "Active projects")))
          (stuck ""
                ((org-agenda-files user-project-files)
                 (org-agenda-overriding-header "Needs action")))
          (tags "old"
                ((org-agenda-files user-project-files)
                 (org-agenda-overriding-header "Too old")))))
        ("d" "Upcoming deadlines" agenda ""
         ((org-agenda-entry-types '(:deadline)))
          (org-deadline-warning-days 30)
          (org-agenda-time-grid null)
          (org-agenda-overriding-header "Upcoming deadlines"))))

The plan is to start with micro tasks, move onto usual TODOs and cycle stuck projects under active to keep everything fresh.

This should work better. Probably.