The restart equation

You open the repo. It has been three weeks. The file tree looks vaguely familiar, but you cannot remember which branch has the working code. Your last commit message says “WIP refactor,” which tells you nothing. There is a Notion doc you were supposed to update but never did.

Before you write a single line, you need to reconstruct what you were doing. That will take at least 20 minutes. Maybe 30 if the logic was non-trivial. You have 45 minutes tonight before you need to sleep.

The equation is simple: if the cost to restart exceeds the time you have available, the session does not happen. And if enough sessions do not happen, the project is effectively dead.

This is not about motivation

When people talk about abandoned projects, the language is almost always emotional. You lost interest. You got distracted. You gave up.

But what actually happened is more mechanical. You ran the numbers, consciously or not, and the session stopped being worth it.

A 45-minute session with a 30-minute cold start leaves you 15 minutes of productive time. That is not enough to make meaningful progress. So you do something else. This is not failure. This is rational resource allocation.

The real question is not “why did I stop working on this,” but “why did the startup cost climb so high that restarting became irrational?”

The cost compounds silently

The first few sessions are fine. You are still in the flow. The mental model is fresh. You remember why you structured the API that way, what the three open tabs represent, where you left the half-finished feature.

But every break adds a small amount of decay. A few days away and the details blur. A week and you need to re-read your own code. Two weeks and you are staring at file names trying to remember what utils/helpers.ts even does.

None of this is visible. There is no dashboard that says “this project now costs 25 minutes to restart.” The cost is silent and cumulative.

By the time you realize how expensive it has become to come back, you have already stopped coming back.

What actually raises the cost

Three things drive restart cost up over time:

Unfinished state. The further you are from a clean checkpoint, the harder it is to resume. If you stopped mid-refactor with two functions half-migrated and tests failing, the cost to reload that partial state is high. Your brain has to re-simulate what you were trying before you can move forward.

Decision opacity. Every architectural choice you made without writing it down becomes a puzzle later. Why is this function async? Why did I use a Map instead of an object? Why does this component own this piece of state? Reverse-engineering your own reasoning is expensive.

Drift from tools. If you were using Claude Code or Copilot, those sessions are gone. The AI does not remember what you were building or what conventions you followed. You start each session from zero, re-explaining the project structure every time. The tool cannot help with continuity because it has no memory.

All three compound the longer you are away. And all three are invisible until you try to restart.

Lowering the equation

The fix is not “work more consistently.” That is advice for people who already have the restart cost under control.

If the equation does not work, you need to change the variables. Either increase the session budget or lower the startup cost. Since most people cannot magic up more time, the only real lever is the cost.

That means externalizing the things your brain forgets: where you were, what you decided, what the next step is. Not in a task manager. Not in a doc you have to remember to check. In the place where you actually restart: your editor or your AI tool.

The VS Code extension does this quietly. It auto-checkpoints when you stop working and shows a briefing when you come back. Not a task. Not a reminder. Just the state you need to resume without burning 20 minutes reconstructing it.

The goal is simple: make the cold start cheap enough that a 45-minute session is still worth opening your laptop for.

When the math works again

A project is not abandoned because you stopped caring. It is abandoned because the cost-benefit analysis stopped making sense.

Lower the restart cost and the sessions start happening again. Not because your motivation changed. Because the friction dropped below the threshold where the session is worth it.

You cannot control how much time you have. But you can control how much of that time goes toward remembering versus building.

Fix the equation and the project un-abandons itself.

---

The difference between a dead project and a live one is often just five minutes of saved startup cost.