- Read the table
- Handle what's in the way
- Keep a way back
- Work backward from done
- Play safe
- Adjust every shot
- Take the shot you'll make
- Dead stroke
Read the table
The urge on any project is to start. There's an obvious first task, and doing it feels like progress. But the first task you can see isn't always the first one you should do.
So I start by looking at all of it. What's the goal, in a sentence? Who is this for, and what does a good day look like for them? What already exists, and what has been tried? What's actually broken, and what only looks broken? I want to know what "done" looks like before I take the first step, because the finish shapes everything before it.
This part is slow on purpose. It's also the cheapest. An hour spent looking around saves the week you'd lose finding out, three tasks in, that you've boxed yourself in.
Look at the whole situation before you commit to the first move.
The first move you can see is rarely the first move you should make.
Handle what's in the way
Every project has a few problems sitting where they'll cause trouble later. An unclear data model. A dependency nobody trusts. A question about the user that everyone has been politely avoiding. None of them block today's work, and that's what makes them dangerous: they block the work after that.
Spotting them is the easy half. The harder half is timing. Take one on too early and you spend effort on something that might sort itself out, or you knock loose new problems. Leave it too late and you've run out of room to recover. So I name them early, put them in order, and pick a moment for each one, usually as soon as it starts to limit what comes next.
Not every awkward problem needs fixing. Some can be worked around. Deciding which is which is most of the job.
Name the problems that will block you later, and choose when to deal with each.
The dangerous problem is the one that doesn't block today.
Keep a way back
Risky work is unavoidable. At some point you have to migrate the data, rewrite the shaky part, or ship the thing you're unsure about. Since the risk is coming anyway, the useful question is what you'll do if it goes wrong.
Before I take a risky step, I make sure there's a way back. A backup I've actually restored from. A switch that turns the new path off. The old version, still ready to deploy. A small test with real users before the big launch. These cost a little time up front. Usually that means leaving an easy win for later on purpose, so it's still there when I need somewhere safe to land.
The difference shows up when things break. Without a way back, a failed risk ends the project. With one, it costs you a step, and you keep going.
Set up a fallback before you take a risk, not after it fails.
Take the risk once the way back is already built.
Work backward from done
Projects usually get planned front to back: do this, then this, then hope it lands somewhere. I'd rather start at the end. What does "done" look like, concretely? And what's the step right before it that makes done easy?
That step is where I aim. For an app, it might be getting one real person through the whole flow, end to end, even if it's ugly. For a launch, it might be the one piece that everything else depends on. Once I know it, the earlier work has a direction: each task either puts me in a good position for that step or it doesn't.
Working backward also shows the wasted motion. A lot of busy, sensible-looking work turns out to set up nothing in particular, and it's easier to cut once you can see that.
Find the step that sets up the finish, and plan backward from it.
Plan the last move first. Everything else is getting there.
Play safe
Sometimes there's no good move. The requirements are fuzzy, the data isn't there yet, or the only path forward is a big bet on a guess. The pressure is to do something that looks like progress, so somebody forces it.
When there's no good move, I'd rather make one that improves the position. Ship a smaller version that teaches me something. Write down the open question and go get the answer. Build a throwaway prototype instead of the real thing. Push the risky feature to a later milestone. None of these finish the project, but they turn a bad situation into a workable one.
Nobody applauds this kind of move, and it's often the smartest one available. A forced bet that misses usually costs more than a careful move that doesn't try to win outright.
When there's no good move, improve the position instead of forcing a bad one.
No good shot? Make the next one better.
Adjust every shot
A plan is a guess about the future, and the future keeps sending corrections. A feature takes twice as long. A user does something nobody expected. A library turns out to be the wrong one. The worst response is to keep following the original plan as if none of that happened.
So after every meaningful result, I look again. Where am I really, as opposed to where I meant to be? Is the goal the same? (It usually is.) Is the route still the best one? (Often it isn't.) Then I re-plan the next few steps from the situation as it is now.
This is what makes a plan predictable instead of fragile. A plan that never changes looks disciplined until reality hits it. A plan that gets checked after every result absorbs surprises one at a time, while they're still small.
Keep the goal fixed, and redo the route after every result.
The goal stays put. The route gets rewritten after every shot.
Take the shot you'll make
Most decisions come with a flashy option and a boring one. Software is full of flashy options: the clever architecture, the brand-new framework, the feature that would be amazing if it works. The boring option is the well-known tool, the simple data model, the plain feature people asked for. It isn't exciting, but it works nine times out of ten.
I lean hard toward the reliable option, because a miss also costs everything after it that was counting on that step working. When something really is worth the risk, I take it on purpose, with a way back in place, and I know why I'm taking it.
I don't think that makes me less ambitious. In my experience, ambitious projects get finished by people who stay predictable.
Choose the option you'll pull off nearly every time over the impressive one.
No hero shots. Just the run.
Dead stroke
Some stretches of work feel like everything lands on its own. Each decision is easy, nothing fights back, and people describe it afterward as luck or a groove. "It just came together."
Look closely at one of those stretches and the moves were rarely hard. Somebody looked at the whole situation first, dealt with the problems in the right order, kept a way back, and adjusted as they went. By the end, no single step had to be heroic. The ease came out of the planning.
That's the bet behind Deadstroke Labs. I don't wait for that feeling to show up. I try to set things up so it can: look first, fix the right things at the right time, and keep checking the plan. When it works, the result looks effortless from outside, even though every part of it was deliberate.
Treat flow as the result of planning, not a replacement for it.
It looks inevitable because the thinking came first.