How to restart coding where you left off tomorrow

Tomorrow's you is a new hire on yesterday's branch

Sleep clears working memory. Morning you knows the project exists but not which test failed, which flag was on, or which file held the bug. Reloading that state from git history and Slack search can cost forty-five minutes before a single new line ships.

Restart tax is not laziness. It is physics. The fix is not "try harder in the morning." The fix is parking state where cold start can read it in ninety seconds - then starting at that park, not at the inbox.

Example: Monday after Friday without a park

Example: Friday you fixed auth for staging but left one integration test red. Monday you open the laptop, read email, skim Slack, open three bookmark tabs, run the full suite because you forgot the filter, and at 10:30 remember the failing test name. Friday's last hour of depth evaporated in Monday archaeology.

Parked state would be: branch name, ./vendor/bin/phpunit --filter=OAuthRefreshTest, file app/Auth/TokenRefresh.php line 88, hypothesis "clock skew on expiry edge." Monday starts with the filter command, not memory.

The four-line restart card

Write these before you close the laptop:

1. Outcome: what "done" means for this thread.
2. Next action: the smallest concrete step (run X, open Y, try Z).
3. State: branch, failing test, URL, or screenshot pointer.
4. Landmine: the open question or risk you must not forget.

Example:

Outcome: payments webhook ignores duplicate events.
Next: run test --filter DuplicateWebhook and inspect idempotency key path.
State: branch fix/webhook-dedupe; test red on second delivery.
Landmine: staging uses different header casing than prod.

That card is the whole ritual. Do not rewrite the backlog at night. One line beats an essay. Good next action: "Add null guard before refresh call in TokenRefresh.php:88." Bad: "Continue auth work."

Minimum park bar (same day or overnight)

Before standup, dinner, or any context switch longer than two hours:

• Commit or stash with a message that states intent, not "wip"
• Paste failing test output or error snippet in the ticket comment
• One next physical action: file, line, or command
• Note environment quirks: account id, feature flag, port, seed command

Future you is someone else. The same bar appears in leave work someone else can continue. Ticket comment or pull request description beats private scratch unless the scratch is guaranteed open tomorrow (useful work notes). Link the ticket from the commit message so git blame finds context.

Red tests are valid park state. Do not hide failing tests to "look clean." A red test with output pasted is a beacon. A green suite with an uncommitted hack is a trap. Commit when tests are green enough to share; stash when messy but reproducible with pasted failure. Never leave a dirty tree without a note explaining which files matter.

Non-dev park example: research and writing

The card is not only for code. Same shape for non-coding work so restart tax does not become a developer-only myth.

Example: you are drafting a client proposal and stop at 16:40.

Outcome: send proposal v1 for ACME billing integration by Thursday.
Next: rewrite pricing section using the three-tier table in notes/acme-rates.md; cut the case-study waffle.
State: Google Doc "ACME proposal v1" open at heading Pricing; client brief PDF page 4 has the must-include SLA language.
Landmine: legal still owes the liability cap sentence - do not invent one; park a comment for them.

Morning sequence: open the doc at Pricing, open the brief to page 4, rewrite the table - do not reopen email first. The four fields transfer: outcome, next action, state pointer, landmine.

Another non-dev example: spreadsheet reconciliation. Outcome = "Q3 variance sheet matches bank export." Next = "re-check rows 40-55 against August CSV." State = "file Finance/Q3-variance.xlsx, filter Vendor=Stripe." Landmine = "two refunds posted twice in CSV; do not double-count."

Morning sequence that respects the park

1. Open the ticket linked from yesterday's commit (or the doc named in the card)
2. Checkout the branch named in the ticket
3. Run the exact test command from the ticket
4. Open the file at the line from the ticket
5. Do not open Slack until step four completes or a true emergency interrupts

Shutdown routine ending the remote workday is the container; the restart card is the payload. Closing the laptop without a park is betting memory against biology.

Branch hygiene and long gaps

One active feature branch per thread. Park others with the last command in the ticket, not a mental stack. Deep work for developers caps parallel hypotheses for a reason. Pull main before park if merge is imminent; note "rebase needed" if not done so morning you does not assume freshness.

Weekends and longer gaps need a richer park: link to the pull request, summarize reviewer conversation, list open questions. Still one first action, but add "decision pending from Alex on token TTL."

If you might be out, raise the bar: reproduction steps, stakeholder name, deadline. Your vacation should not force a teammate into duplicate exploration. When rotating a pair, both write the restart card while context is shared; the driver reads it aloud before switching.

When interruption strikes mid-block

Meeting in twenty minutes still gets stash, output paste, next line. Two minutes now saves forty later. Optional: note which run configuration was active, or a screenshot of a debugger breakpoint if complex. Do not rely on IDE session restore across sleep and updates - it fails often enough to hurt.

Add one explicit not-tomorrow line when temptation is high: "Not tomorrow: refactor UserRepository." Prevents Sunday brain from assigning Monday a different task without noticing.

If park notes exist and mornings still drag, look at the system: slow test suite, unclear ticket, meetings at 09:00 that forbid cold start, or ten parked threads so morning picks the wrong one. One primary thread per day (why remote workers need a clear next action). Fix the system before self-blame.

Ninety-second park under pressure

You do not need a perfect note. You need a readable one. Timer: ninety seconds before the meeting starts.

1. Stash or commit with intent in the message (20 seconds)
2. Paste the last error or failing assertion into the ticket (30 seconds)
3. Write next action as file:line or command (20 seconds)
4. One landmine word if needed: "flag", "seed", "timezone" (20 seconds)

That is enough. Fancy formatting can wait for a calm Friday. The mornings that hurt most are the ones after chaotic evenings - which is exactly when people skip the park.

If you park ten threads, morning still fails: you pick the wrong one. One primary thread per day. Other cards wait in tickets with dates, not in a mental stack competing for first open.

Restarting coding tomorrow is a handoff problem. Write one command, one file, one hypothesis where morning eyes land first. Pay ninety seconds at shutdown to buy an hour before lunch.