The Zen of Task Management with Org
I use Org Mode not to be more productive, but to reduce my stress so I can focus on my work and still pay my bills on time.
After more than 15 years of refining my Org configuration, I can't say it's perfect, but it's stable and comfortable enough that I think it might be useful to others.
Projects
Projects are lists of tasks and notes with a purpose.
Projects themselves don't have due dates: a project is finished when the last task (possibly with a due date) is completed. Only projects have a "category" property, tasks don't. Projects are either top-level or 2nd-level items, and tasks are either 2nd level or 3rd level items. Items below 3rd level are never tasks, always notes.
Work
is a top-level project. I used to define distinct agenda views
for work and non-work tasks, but it didn't stick. Now I use the same
agenda views for all projects. When an agenda view is part of my
routine, it has a "sub-view" that filters out non-work tasks, but
that's really the only way that Work
tasks are treated differently.
Routines
My daily routine is to work on tasks that are scheduled for today.
When I'm done, I check the tasks that are in progress (with a STRT
to-do keyword) or next to do (with a NEXT
to-do keyword) and I either
work on them, schedule them, or give them a deadline.
My weekly routine is to review items to do and waiting items (TODO
and
WAIT
) that aren't scheduled and don't have a deadline, and to archive
completed tasks (DONE
or CANX
, short for "Canceled".)
What matters here is that the tasks are divided into a flow of active tasks and a stock of inactive tasks: my daily routine is dedicated to handling the flow, while the weekly routine is dedicated to sorting the stock.
Priorities
I rely on my routine agenda views to show me tasks in priority order.
What Org calls "priority cookies" (i.e., [#A]
), I use to capture the
importance of a task relative to its siblings within the same project,
never its "urgency". ("Urgency" is anything with a due date in the
past.
Active tasks (i.e. scheduled items, items with a deadline or with a
NEXT
to-dokeyword) have priority over all other tasks.Repeating tasks
never need NEXT
as their to-do keyword, TODO
is enough.
TODO
or WAIT
tasks that have no deadline and are not scheduled, I call
them dormant tasks: some may be important ([#A]
), but they are not
activated until I decide so.
In pictures
Here is a sample file with projects and tasks.

When I want: Agenda week view

Daily routine #1: Tasks with SCHEDULED
or DEADLINE
this week

Daily routine #2: Tasks with STRT
or NEXT
keywords

STRT/NEXT
tasks.
Weekly routine #1: Upcoming deadlines

Weekly routine #2: TODO
items without SCHEDULED
or DEADLINE

Why this works?
Any task management tool out there has only three jobs: to help you focus, prioritise and remember.
The right focus
"Focus" is not a binary state, it's a dynamic process: you can shrink or enlarge the focus window.
I could have limited my routine to today's tasks (vs. the whole week)
or to STRT
tasks (vs. STRT
and NEXT
), but experience has shown me that
this is not the right focus window for me. I need to see the whole
week to reschedule tasks or update deadlines. I need to see tasks that
are coming up to motivate me to finish the ones I have started.
A sense of priorities
For a long time, I tried to capture the priority of tasks as an absolute value, but that was a mistake, because priority is a relational property. You need context to judge how tasks relate to each other.
The local context is provided by the notion of "project": if you have
a project to buy a boat, you have to find money first. I'd call this
"bottom up" prioritisation. Agenda views provide several more global
contexts: if your agenda commands are well adapted to your routine,
they will nudge you towards better prioritisation of your tasks (when
to SCHEDULED
them, STRT
vs. NEXT
, or even setting priority cookies
like [#A]
). I'd call this "top down" prioritisation.
My routine is really quite simple: I work on what I need to do today, then what I need to finish or to do next. My agenda commands serve this routine well and help me to keep a sense of priorities because I can set them bottom up and top down.
No task left behind
It's easy to add or capture tasks in an Org file. It's good because you don't forget anything… if and only if every task is accessible from an agenda view that is part of your routine.
My "active" tasks fall into one or more of these categories:
- Is
SCHEDULED
- Has a
DEADLINE
- Has a
STRT
orNEXT
keyword
For example, the task "Write a first draft of this paper" has a due
date at the end of the month, and I have scheduled it for next Monday.
It will be marked NEXT
until I start working on it next Monday, when I
will mark it STRT
. Or, for another example, "Pay my rent" is a TODO
that is scheduled every month.
"Inactive" tasks have a TODO
or WAIT
keyword but they are not planned,
they have no SCHEDULED
or DEADLINE
information.
My routines go through tasks from all these categories:
- Every day, I first check the weekly view (handling
SCHEDULED
andDEADLINE
). - Every day, I then check the tasks that are in progress or to be done (
STRT
andNEXT
). - Every week I check the
TODO
andWAIT
tasks that do not appear in my calendar.
This last step, processing TODO
items without SCHEDULED
or DEADLINE
,
is particularly important: it took me a long time to realise that my
discomfort with my Org setup came from not knowing whether I could
forget a task.
Fighting entropy
The great thing about Org is that you can constantly tweak it to make it work better for you. But the constant tweaking can also be counterproductive. How does this setup help me fight to-do list entropy?

This cartoon might sound familiar. Over the years I've had to break a lot of bad habits:
- Unclear distinctions between projects and tasks.
- Unclear distinctions between to-do keywords, tags, categories.
- Trying to set priorities at the wrong level.
- Misuse of
SCHEDULED
andDEADLINE
to remind me about tasks. - Too many agenda commands, too many not even part of a routine.
- Too many projects, too many tasks.
- Too many to-do keywords and tags.
The main effect of these habits was that I ended up with a long list
of inconsistent tasks to do "right now": too many NEXT
items, too many
tasks scheduled for today, etc.
The current setup helps me fight these bad habits:
- I never schedule or add a deadline unless someone else expects me to finish on the scheduled or deadline date.
- I limit the number of tasks from each routine agenda view. For
example, when I list the
STRT/NEXT
tasks, I don't want to see more than ~10 tasks per project. - I prioritise tasks from within my agenda views ("top down") and from within projects ("bottom up").
And because this setup feels efficient, I don't have to add tags, keywords, and categories just in case I need them.
I've also found that these routines help me write better to-do items:
- I do write fewer tasks (and more notes).
- I keep my tasks self-explanatory.
- I use scheduling and deadlines sparingly.
See "On using to-do lists efficiently" for the rationale behind these recommendations.
My configuration
Below I describe how I organise my Org file, how I use to-do keywords, tags, agenda views and capture templates.
I put everything in a file with minimal hierarchy
I do use a single Org file for all tasks and appointments.
(I do have several Org files for various notes, but tasks and appointments are in a single file.)
For organising projects, tasks and notes, I stick to these conventions:
- Projects are top-level or second-level items.
- Projects don't have a to-do keyword or tag.
- Only projects have the
CATEGORY
andARCHIVE
properties. - All tasks belong to a project, which is their direct parent.
- All tasks and only tasks have a to-do keyword and optionally tags.
- All other entries are appointments or headings for notes.
What are the benefits of this approach?
- The search is efficient as everything I need is in one file.
- This file is readable, (un)folding shows me what's important.
- I can restrict agenda commands to projects/categories.
- All tasks for a project are at the same level, it's easy to act on them.
I use to-do keywords for the status of the task
Here are the six to-do keywords I use:
STRT
: Task is in progress and must be completed.NEXT
: Task is active and must be performed next.TODO
: Task is something to do in general.WAIT
: Task is waiting for something else.CANX
: Task has been canceled or delegated.DONE
: Task has been done.
Notice that mentally there are three groups:
STRT/NEXT
: For "activated" tasks that I need to do next.TODO/WAIT
: For tasks I might need to do at some point.CANX/DONE
: For tasks I can archive now.
For a while I used TODO
for tasks I should do next and MAYBE
for tasks
I might want to do someday. But I found MAYBE
semantically sloppy and
a bit stressful. I switched to using NEXT
and TODO
, which is clearer:
NEXT
actions are active tasks without blockers, while TODO
items are
things to do in the standard sense of the word: I can do them (e.g. if
they are habits) or review them before activating them and letting
them enter my routine.
I set to-do keywords like this in my configuration:
(setopt org-todo-keywords
'((sequence "STRT(s)" "NEXT(n)" "TODO(t)" "WAIT(w)" "|" "DONE(d)" "CANX(c)")))
I use tags to specify the type of activity for the task
I don't use tags to describe the task's project, category or status.
Here are the types of activity I use:
Code
: Something to code.Listen
: Something to listen.Read
: Something to read.Watch
: Something to watch.Write
: Something to write.
Here is my configuration for tags:
(setopt org-tag-alist
'((:startgroup)
("Handson" . ?o)
(:grouptags)
("Write" . ?w) ("Code" . ?c)
(:endgroup)
(:startgroup)
("Handsoff" . ?f)
(:grouptags)
("Read" . ?r) ("Watch" . ?W) ("Listen" . ?l)
(:endgroup)))
Tags are grouped:
Handsoff
(Read
,Listen
andWatch
): For when I consume something.Handson
(Write
andCode
): For when I produce something.
Tag groups allow me to exclude tags from each other when setting them, and to filter by tags from the same group in agenda views.
I capture very few important things
Here is what I "capture" (M-x org-capture RET
), by order of frequency:
- Appointments (mostly from
Gnus
) - Things to read for my work (from
eww
ordired
) - Things to read for leisure (from
eww
ordired
) - Other things for work or leisure
Here is my configuration for org-capture-templates
:
(setopt org-capture-templates
'(;; One capture for appointments
("r" "Rendez-vous" entry (file+headline "~/org/bzg.org" "Rendez-vous")
"* %:fromname %?\n SCHEDULED: %^T\n\n- %a" :prepend t)
;; A capture template for things to sort out later
;; (!) To indicate the captured item is immediately stored
("c" "A trier (!)" entry (file "~/org/bzg.org")
"* TODO %a" :prepend t :immediate-finish t)
;; A capture for misc things to read
("d" "Divers à lire (!)" entry (file+headline "~/org/bzg.org" "Divers")
"* TODO %a :Read:" :prepend t :immediate-finish t)
;; A capture template for work items
("m" "Mission" entry (file+headline "~/org/bzg.org" "Mission")
"* TODO %?\n\n- %a\n\n%i" :prepend t)))
Some capture templates have lowercase and uppercase keybindings: in these cases, the lowercase keybinding is for when I need to edit the item further (most of the time), while the uppercase keybinding is for when I can save the entry immediately.
I use agenda views to manage all my tasks
Agenda views for my daily routine:
- The weekly agenda of tasks with
SCHEDULED
orDEADLINE
- The list of in progress and next tasks (
STRT
andNEXT
)
Agenda views for my weekly routine:
- The list of upcoming due tasks (
DEADLINE
) - The list of to-do or pending tasks with no
SCHEDULED
orDEADLINE
- The list of completed and cancelled tasks to archive (
DONE
andCANX
)
Agenda views for things I may want to check anytime:
- The weekly calendar for appointments (i.e., scheduled events with a time)
- The list of started "hands on" tasks (
Write
andCode
) - The list of started "hands off" tasks (
Read
,Watch
andListen
)
"Appointments" are defined as scheduled events with a start time (see
Special Agenda Views). I occasionally check them manually, but they
are not part of my daily routine because (org-agenda-to-appt)
lets me
be warned about upcoming ones.
The list of started "hands on/off" tasks is the reason why I have a
separate STRT
to-do keyword: sometimes I just want to finish tasks.
Here is my org-agenda-custom-commands
:
(setopt org-agenda-custom-commands
'(;; For weekly archiving
("#" "To archive" todo "DONE|CANX")
;; Agenda view of appointments for this week
("$" "Weekly appointments" agenda* "Weekly appointments")
;; Agenda view to see SCHEDULED/DEADLINE non-appt tasks for this week
;; MLL is for "Mission logiciels libres", my work
;; RDV is for "Rendez-vous" (personal appointments)
("ù" . "Scheduled/deadline tasks for this week")
("ùù" "Week tasks" agenda "Scheduled tasks for this week"
((org-agenda-category-filter-preset '("-RDV"))
(org-agenda-use-time-grid nil)))
("ù," "Work week tasks" agenda "Scheduled work tasks for this week"
((org-agenda-category-filter-preset '("+MLL" "-RDV"))
(org-agenda-use-time-grid nil)))
("ù?" "Non-work week tasks" agenda "Scheduled non-work tasks for this week"
((org-agenda-category-filter-preset '("-MLL" "-RDV"))
(org-agenda-use-time-grid nil)))
;; Agenda view to see STRT/NEXT tasks for this week
("*" . "What's next?")
("**" "STRT/NEXT" tags-todo "TODO={STRT\\|NEXT}")
("*," "STRT/NEXT (Work)" tags-todo "TODO={STRT\\|NEXT}"
((org-agenda-category-filter-preset '("+MLL"))))
("*?" "STRT/NEXT (Non-work)" tags-todo "TODO={STRT\\|NEXT}"
((org-agenda-category-filter-preset '("-MLL"))))
;; Agenda view to list TODO items with no SCHEDULED/DEADLINE
(";" . "What's to do?")
(";;" "TODO" tags-todo "TODO={TODO}+DEADLINE=\"\"+SCHEDULED=\"\"")
(";," "TODO (Work)" tags-todo "TODO={TODO}+DEADLINE=\"\"+SCHEDULED=\"\""
((org-agenda-category-filter-preset '("+MLL"))))
(";?" "TODO (Non-work)" tags-todo "TODO={TODO}+DEADLINE=\"\"+SCHEDULED=\"\""
((org-agenda-category-filter-preset '("-MLL"))))
;; Agenda view to see WAIT tasks with no SCHEDULED/DEADLINE
(":" . "What's waiting?")
("::" "WAIT all" tags-todo "TODO={WAIT}+DEADLINE=\"\"+SCHEDULED=\"\"")
(":," "WAIT MLL" tags-todo "TODO={WAIT}+DEADLINE=\"\"+SCHEDULED=\"\""
((org-agenda-category-filter-preset '("+MLL"))))
(":?" "WAIT -MLL" tags-todo "TODO={WAIT}+DEADLINE=\"\"+SCHEDULED=\"\""
((org-agenda-category-filter-preset '("-MLL"))))
;; Agenda view to see upcoming deadlines with 60 days of warning period
("!" . "Upcoming deadlines")
("!!" "Deadlines all" agenda "Past/upcoming deadlines"
((org-agenda-span 1)
(org-deadline-warning-days 60)
(org-agenda-entry-types '(:deadline))))
("!," "Deadlines MLL" agenda "Past/upcoming work deadlines"
((org-agenda-span 1)
(org-agenda-category-filter-preset '("+MLL"))
(org-deadline-warning-days 60)
(org-agenda-entry-types '(:deadline))))
("!?" "Deadlines -MLL" agenda "Past/upcoming non-work deadlines"
((org-agenda-span 1)
(org-agenda-category-filter-preset '("-MLL"))
(org-deadline-warning-days 60)
(org-agenda-entry-types '(:deadline))))))
Some tricks
Agenda commands that I use routinely have their own keybinding.
The C-...
keybindings are for work and the C-M-...
keybindings are for
non-work tasks:
;; Weekly appointments
(global-set-key (kbd "C-$") (lambda () (interactive) (org-agenda nil "$")))
;; Work routine keybindings
;; Weekly tasks
(global-set-key (kbd "C-M-ù") (lambda () (interactive) (org-agenda nil "ù,")))
;; Started and next tasks
(global-set-key (kbd "C-M-*") (lambda () (interactive) (org-agenda nil "*,")))
;; Tasks with an upcoming deadline
(global-set-key (kbd "C-M-!") (lambda () (interactive) (org-agenda nil "!,")))
;; Tasks to do and not in the agenda
(global-set-key (kbd "C-M-;") (lambda () (interactive) (org-agenda nil ";,")))
;; Tasks waiting and not in the agenda
(global-set-key (kbd "C-M-:") (lambda () (interactive) (org-agenda nil ":,")))
;; Non-work routine keybindings
(global-set-key (kbd "C-ù") (lambda () (interactive) (org-agenda nil "ù?")))
(global-set-key (kbd "C-*") (lambda () (interactive) (org-agenda nil "*?")))
(global-set-key (kbd "C-!") (lambda () (interactive) (org-agenda nil "!?")))
(global-set-key (kbd "C-;") (lambda () (interactive) (org-agenda nil ";?")))
(global-set-key (kbd "C-:") (lambda () (interactive) (org-agenda nil ":?")))
When you rely on very few agenda custom commands, the sorting strategy is especially important:
(setopt org-agenda-sorting-strategy
'((agenda time-up deadline-up scheduled-up todo-state-up priority-down)
(todo todo-state-up priority-down deadline-up)
(tags todo-state-up priority-down deadline-up)
(search todo-state-up priority-down deadline-up)))
Once I'm in an agenda view for to-do items, I often adjust priority
cookies (e.g. [#A]
) with M-<up>
and M-<down>
.
With the cursor on a project heading, I often use the <
speed key (or
M-x org-agenda-set-restriction-lock RET
) to restrict the agenda views
to that project: then I can go through the routine for that project,
which is very handy.
I use elisp:
links to call weekly routines. E.g. I have this task for
sorting TODO
tasks every Friday:
** TODO [#A] Review [[elisp:(org-agenda nil ";,")][work to do]] SCHEDULED: <2025-04-25 Fri. ++1w>
Last but not least, because I basically live in my main org file, I want to be able to find it easily:
;; Easily jump to my main org file
(defun bzg-find-bzg nil
"Find the bzg.org file."
(interactive)
(find-file "~/org/bzg.org")
(delete-other-windows))
(global-set-key (kbd "C-x <C-backspace>") 'bzg-find-bzg)
🦄 Enjoy!
Stabilising a good setup helps me forget about the tool I use and focus on what I want to do. I hope this setup can help you achieve Ataraxia too!
You can find my GNU Emacs and Org configuration on codeberg.org.
Feel free to discuss this on Hacker News or on Reddit.
Thanks to Fabrice Niessen and Rudolf Adamkovič for their useful feedback.
📣 Let's discuss this on floss.social
📧 Subscribe to read me from time to time