Posted On: 2024-04-01
This year, I've been revising my planning process, and today's post wraps up my first plan in this new style. Inspired by my success over the winter, I set for myself a concrete goal, and defined an arbitrary deadline for when the goal must be accomplished. Along the way, I maintained momentum on the project using the weekly sprint system that I implemented last year, while adding new (arbitrary) check-in deadlines to make sure I was still on track. For today's post, I'll break down what works about this new approach, and what specifically I've achieved using it.
In a previous retrospective I noted that having a highly detailed plan up-front helps me achieve better outcomes - regardless of whether or not I actually follow the plan. To realize that benefit, I decided to plan as much as I could up-front, breaking down my high-level goal (implement the designated scene) into its core requirements and necessary supporting systems. As these requirements were themselves fairly high-level, I continued breaking things down, ultimately spelling out exactly what I intended to achieve at the individual task level. Even at this stage, I noted several things that I wanted to accomplish but would have to cut - I knew the plan was ambitious, and I needed to keep things focused on only the essentials.
While the whole of the plan is too long to include here, I think a couple examples might be illustrative for how this breakdown worked. At the top of the plan, I wrote "Next major goal: Gameplay. Get [the desired scene] up and running." This high-level goal is hardly actionable, so I broke it down into "Core requirements", which focused on the specific gameplay elements that I wanted to complete (ie. "Ability to toggle flying on and off"). I noticed that these core requirements overlooked essential, non-gameplay elements, so I also documented "supporting stuff", including things like "create a spritesheet for [character]" and "setup an input system". Since these were still not directly actionable, I looked at each item individually, and carved them further up into specific tasks, such as "create [character] as an actor"* or "add spritesheet into engine". Importantly, I didn't fret about whether or not these were the ideal tasks - that's what weekly plans are for.
At the very start of my planning, I picked not only an arbitrary deadline for my goal, but a series of arbitrary check-in points along the way. Each was assigned a question to evaluate (ie. "are the deadlines still reasonable?") as well as a specific date when it should happen (always a Monday, so it could be included in weekly planning.) These check-ins served as concrete points at which the plan could be revised - and I would often add new notes to the plan (add X, cut Y, etc.) at the same time. Although these weren't perfect (I probably should have had an extra one a week before the deadline), having explicit dates set aside for getting my head out of the weeds and looking at the bigger picture certainly made progress much smoother than it otherwise would have been.
I maintained my weekly planning approach, where the first task each week was to spell out which of the remaining tasks that I thought I could accomplish. For the most part, this remained the same as how it worked last year, albeit with a few minor differences:
One major change that having a deadline brings is the need to control scope on a regular basis. I wrote quite a bit about this in my previous post, but the general summary is that having a deadline led me to prioritize clean, working code over code that will fit all my future needs. Some of those "future needs" were items that I'd originally included in my long-term plan, but somewhere along the way turned out to be not strictly necessary.
Despite trimming scope at every step along the way, I still found myself cutting things at the last minute to get it all done on time. This specific issue came about because the deadline I'd given myself landed on a Monday (like all the interim check-ins), but for some reason I'd unconsciously expected to have the whole week to work on it. To make this work, I ended up cutting something that was important, but not necessary in the strictest sense, allowing me to shorten the last two weeks worth of work into only a single week*.
In addition to the long-term deadline, I also set specific goals for the two weeks after it:
My next major milestone needs to complete (and fully stable) by June, as I've promised to show my progress to someone then. In the next few days, I'll be repeating what I did back in January: picking out a realistic goal for that deadline, slicing up the time to inject arbitrary check-ins, and breaking down the work into bite-sized pieces. Hopefully by doing that, I can repeat the success of these past few months, and keep moving my current project forward.