On two ways to determine what's urgent on a todo list, and why I ended up using both.
I've built a feature into the todo list I use in the terminal that's meant to answer one question: What should I do now? Each task is assigned a number for its urgency, and the list is sorted by that.
There are two ways to calculate the number. One is a formula. The other is to ask an AI. I've tried both, and the difference is more educational than the list itself.
The Formula
The first method is borrowed from Taskwarrior, an old and well-tested task management program. Each task gets points for the things you can see from the outside. An approaching deadline earns up to 12 points. High priority earns 6, and a task you've already started earns 4. A task waiting for its subtasks gets 5 points deducted. The points are added up, and there's your number.
The advantages are what you'd expect from a rule. The number is the same every time. It's free and instant, and it doesn't require internet. You can have each task explained line by line: 9 points for the deadline and 6 for priority. If you disagree, you adjust the weights, not your trust.
The disadvantage is that the formula only looks at the labels and never the task itself. "Customers are being logged out every five minutes" and "rename an internal variable" will get the exact same number if neither has a deadline or priority. The formula is only as good as your own discipline in applying labels, and that discipline is rarely strong on a busy Tuesday.
The AI
The second method sends the task text itself to jev, a model from TypeSafe, which I've also written about in The one who teaches shouldn't grade. jev doesn't write prose. It answers one question with a number: How important is it to get this task done? The scale ranges from "nothing much happens if it never gets done" to "something's broken, or people are blocked right now."
It reads what's written. The outcome is self-evident: the customers being logged out got 0.98, and the variable got 0.25.
The advantage is that it captures what you forgot to label. It understands differences in content that the formula can't see.
The disadvantages are just as concrete. Each call costs money and takes a moment. The task text leaves the machine and is sent to an external service. The answer might change when the model is updated. It can also be wrong with great confidence, and it can't explain itself the way the formula can.
The Solution Was to Give the AI One Line in the Formula
I didn't let the AI determine the order. It was given one factor out of eleven, and that factor is worth a maximum of 6 points, the same as high priority. Three choices make the difference:
- It's only asked about importance. It's not asked about deadlines or priority, because the formula already accounts for those. Otherwise, the same thing would be counted twice.
- The answer is saved. Each task is assessed once, so the cost and waiting time occur only once. The order remains stable until you ask for a new assessment.
- The answer is in the explanation like everything else. You can see "impact 0.98 × 6 = 5.88" next to the deadline and priority and override it manually.
| The Formula | jev | |
|---|---|---|
| Sees | labels: deadline, priority, status | the text itself |
| Cost and Speed | free and instant | money and waiting time per task |
| Same Answer Every Time | yes | not guaranteed |
| Can Explain Itself | line by line | only a number and a confidence |
| Data Leaves the Machine | no | yes |
The Point Extends Beyond the Todo List
I see the same pattern in companies that want AI to prioritize cases, customers, or leads. The temptation is to let the model decide everything. The robust solution is a formula you can read and correct, where the AI provides precisely what the rules can't see, with a weight you've chosen yourself.
That's what I mean by building the skeleton around the AI. Most of the system is rules. The AI gets the single place where understanding actually trumps rules, and that place has a limit.