Introducing Dag
In which we introduce a new open source planning tool I wrote for myself that focuses on improving planning, not the plans.
I’m sure you’ve heard this Eisenhower’s quote before:
Plans are worthless, but planning is everything.
I very much agree with this. I have never seen a plan survive contact with reality. And yet, most people I meet believe that planning is about making plans. They also believe that “good planning” is about coming up with “good plans”.
I disagree.
I believe that planning is not about predicting the future (something that we just can’t do no matter how hard we try) but rather a gym for us to flex the muscles that allow us to make better and more principled decisions under uncertainty.
But if all plans are worthless, how do we evaluate if our planning is any good?
I think we should not focus on how accurate our ETAs were, or how well we predicted certain outcomes: instead we should focus on the improvement in the speed and quality of our decision making.
Yet, every time I try to convince somebody about changing their planning posture from “plans” to “decisions”, there is one thing that invariably comes out: planning ends up focusing on artifact that artifact generation and updating is so damn expensive. This is because the tooling is poor.
Most people use either rectangular canvases (like spreadsheets or tables) or fully graphical software. They spend hours upon hours doing the thing and polishing the artifacts. Then they share them and they either become frozen in time or force an incremental mode around them. Nobody wants to start again. Nobody wants to look at the problem from another angle. It’s too expensive and it feels like demeaning for those that spent so much time coming with the plan artifacts.
Tooling, IMO, is the biggest obstacle to a nimbler and more systemically nuanced approach to planning in which the act of thinking of a plan is the focus and not the plan itself.
So I wrote a thing.
It’s called Dag (as in Directed Acyclic Graph but also, apparently, in Australian, an entertainingly eccentric person) and it’s a tool designed to ephemerally help you think about tasks to achieve goals, how they depend on one another and how much effort we believe they might take.
It uses a Sankey diagram to explain how effort flows thru our plan. It looks like this:
The “source code” of the above diagram is this:
This is an example dag
* this > that [1|0.5]
* that > also this [2]
* also this > well, can't miss this
* that > some other thing [3]
* this > oh yeah, forgot [4|1]
* oh yeah, forgot > oh crap [2]
* oh crap > oh c'mon, really? [1|1]
* some other thing > yes, ok, fine [2]
* oh yeah, forgot > also this
* oh yeah, forgot > yes, ok, fine
* that > oh crap
and the ending square brackets are optional but if present indicate the “effort” and, even more optionally, the “uncertainty” we feel for our own estimate of the effort. Worth noting that this is valid Markdown syntax which allows you to add comments and textual decorations (Dag will also try to render the Markdown for you on the side as you type).
It’s a “tool for thought” which focuses on the act of planning, on the act of figuring out how to decompose activities into dependent tasks, along with the predicted effort and, crucially, our own uncertainty around such predictions.
Find Dag at stefanom.github.io/dag/ and play with it directly in your browser.
No installation necessary.
There are a few key insights baked into this simple piece of software:
what’s important is the dependency map, not how it’s visually laid out. It will continue to change so it should make it easier for us to think of it that changing it is trivial and effortless. We think of the dependency graph, the software lays it out for us. We don’t have to worry about the visuals, we just worry about the structure.
there is no expectation of permanence. The plan will continue to change, daily if we can, weekly most likely. We should continue to engage with it regularly to help us understand how the environment has changed.
uncertainty should be modeled explicitly. If we know our plan sucks and there is no way those ETAs actually mean much, we should not be afraid of modeling our plans as stochastic processes.
it should be as simple as possible, there isn’t even a button. We type, the diagram changes, we gain insights, we type again, rinse and repeat.
The tool is open source under a very liberal license (MIT) and I very much welcome feedback and contributions although, honestly, I wrote it for myself and having it working for my own needs is reward enough. Yet, it has been decades since I started a new open source project and that also feels good.