TODO, DOING, DONE - the Key to Being Machine-Productive
"What was I doing?...."
"What am I supposed to do now?...."
"What did I do yesterday?...."
"What do I have to redo tomorrow?...."
These are questions that rise during creative work on a project.
When you get a single TODO, in the form of a question or command, it's simple to just go ahead and do it. But when you're working on a project with more than 2 TODOs (and this is my definition of a project), you can get confused, forget and get very frustrated.
I solve this problem with the following method: I iteratively break the project into single TODO commands.
The method I found for myself is free, simple, and compact.
I call it TODO, DOING, DONE.
It's based on Scott Belsky's thoughts, the scrum software development method, and the 37signals menifesto.
All you have to do, is open a TXT file in your notepad. I prefer the simple Windows Notepad.
Name that TXT file: "PROJ_NAME-TODO-YYYYMMDD.txt" (e.g. "LocaDo-TODO-2011-02-15.txt"). Place it in the folder of the project.
In the file, write 3 lines of text with line breaks, like this:
"TODO:
DOING:
DONE:"
Pretty simple, right? Now comes the real work: fill in the spaces.
Iteratively break the project's TODOs into smaller TODOs. Do it again and again until you get to a single command TODO.
The guidelines come from Scott Belsky's post about TODOs that fit into POSTITs.
If your project is an application, break it into smaller pieces (super-TODOs):
1. Build GUI
2. Write code
3. Test & improve
This is the first iteration of breaking the project into smaller TODOs.
The next iteration takes each of the TODOs and further breaks them into even smaller TODOs (mini-TODOs):
1. Build GUI:
{
a. splash screen
b. welcome screen
c. register screen
d. login screen
e. forgot password screen
f. logo
....etc....
}
2. Write code:
?
3. Test & Improve:
?
You can see that we don't know what are the next TODOs in the 2nd and 3rd super-TODOs. We can leave it blank until we finish the first super-TODO. I believe that the GUI will tell us how the code will work, and what to test.
Again, iterate through each of the mini-TODOs you wrote (micro-TODOs):
1. Build GUI: <<-- super-TODO
{
a. splash screen: <<-- mini-TODO
background-color:black <<-- micro-TODO
text-color:blue
big-text:"Application Name"
small-text:"Application Slogan"
b. welcome screen
text:"Welcome to the App, here you will find...."
c. register screen
text-field: userName
text-field: password
text-field: password again
text-field: email
button:register
button:reset
d. login screen
text-field: userName
text-field: password
e. forgot password screen
text-field: userName
text-field: email
f. logo
colors:?
....etc....
}
Now you can see that when you reach the low resolution of micro-TODOs, byte sized commands, you can just get to DOING. Simply do one by one. You are now a machine - You just do what's on the list. This helps you hold the line against frustration caused by distractions and forgetting.
Every TODO you're working on, cut and paste into the DOING section of the txt file:
TODO:
1. Build GUI:
{
a. splash screen:
________ <<-- notice the whitespace here
text-color:blue
big-text:"Application Name"
small-text:"Application Slogan"
b. welcome screen
text:"Welcome to the App, here you will find...."
....etc....
}
DOING:
1. Build GUI: <<-- copied from TODO
{
a. splash screen: <<-- copied from TODO
background-color:black <<-- *cut* from TODO
}
Once you're finished with that micro-TODO, cut and paste it into the DONE section:
TODO:
1. Build GUI:
{
a. splash screen:
text-color:blue
big-text:"Application Name"
small-text:"Application Slogan"
b. welcome screen
text:"Welcome to the App, here you will find...."
....etc....
}
DOING:
DONE:
1. Build GUI: <<-- cut from DOING
{
a. splash screen: <<-- cut from DOING
background-color:black <<-- cut from DOING
}
Now, like a machine, move on to the next TODO by adding it to the DOING section. Don't forget to copy the super-TODO, the mini-TODO and the micro-TODO.
Now again, and again and again, until you finish all the micro-TODOs in the first super-TODO.
Now you can break the 2nd super-TODO into mini-TODOs. And then into micro-TODOs. And now do it.
DONE? Next! Break the next super-TODO, and do it.
You're done. The project is finished.
You will learn how much time it takes to do each micro-TODO by writing the startTime, endTime and overallTime of each micro-TODO next to it:
DONE:
1. Build GUI:
{
a. splash screen:
background-color:black [14:45-14:50 = 5min]
}
Also write overall times for DONE mini-TODOs and for DONE super-TODOs. Ideally, also for the whole project. This will teach you the most.
Now let's talk about leaving things for tomorrow.
You will probably not finish all micro-TODOs on the first DOING iteration. What do you do? In the end of the iteration, simply copy-paste the remaining TODOs into a new TODO,DOING,DONE file.
When you gain confidence in your TODO,DOING,DONE lists, you will use the same lists for different projects. You will be able to make smart assumptions regarding time.
This is my method. I hope it will help you have fun and get more productive with your creative work.
Remember:
Break big TODOs into machine commands:
Project -> Super-TODOs -> Mini-TODOs -> MicroTODOs.
and get from DOING to DONE.
Good luck! Let me know how it works out for you.