You do not need to reread every AI conversation to resume an interrupted coding project. You need to recover the last verified state: the goal, current files, accepted decisions, completed checks, unresolved gaps, and the next bounded action.

A transcript tells you what was discussed. A restart brief tells you what is true now.

The five-minute restart sequence

  • Read the current product goal and active roadmap milestone.
  • Inspect the working tree and recent commits before trusting a summary.
  • Find the latest successful tests, build, or runtime evidence.
  • List open gaps and decide which one blocks the user outcome first.
  • Start a fresh agent run with a narrow outcome and explicit completion evidence.

This sequence prevents two expensive mistakes: repeating work that already landed and continuing from a claim that was never verified.

Start from current reality

Run the repository's normal status and test commands. Look at the smallest relevant code path. If the roadmap says a feature is complete but the current page, test, or runtime disagrees, current evidence wins.

Separate what you observe from what you infer:

  • Observed: the checkout route exists, the build passes, and production returns 404.
  • Inference: deployment did not include the new route.

This keeps a new agent from treating a plausible explanation as a fact.

Rebuild the decision chain, not the conversation

The useful history is compact:

  • Why the current approach was chosen.
  • Which alternatives were rejected and why.
  • Which public behavior or boundary must remain unchanged.
  • Which attempt failed and should not be repeated.
  • Which exact version, commit, or object is active.

GitHub and other agent platforms increasingly support repository-level instructions because persistent project context reduces repeated prompting. GitHub's documentation describes repository instructions as a way to carry structure, conventions, build, and test knowledge across sessions: Customize Copilot for your project.

Do not put every decision into one giant instruction file. OpenAI reports that an oversized AGENTS.md crowded out the task and relevant code; their solution was a map to focused documentation: Harness engineering.

Choose the next action by broken link

Trace the user journey from entry to result. Find the first point where verified reality stops matching the goal.

If signup works but onboarding fails, do not redesign billing. If the local page works but the release is missing, do not rewrite the component. The next action should repair the first broken link.

Use this restart brief

Goal

After this run, the user can [specific action].

Verified now

  • Current branch and commit:
  • Relevant working-tree changes:
  • Passing checks:
  • Runtime or page evidence:

Decisions to preserve

  • Product boundary:
  • Public behavior:
  • Data authority:
  • Rejected path:

Unresolved gap

  • First broken link:
  • Evidence:
  • Why it blocks the outcome:

Next run

  • Authorized surface:
  • Required checks:
  • Stop conditions:
  • Expected handoff:

What should stay out of the brief?

Leave out:

  • full chat transcripts;
  • speculative root causes;
  • obsolete plans;
  • unrelated future ideas;
  • raw logs with no conclusion;
  • “latest” references without stable identity.

Keep raw material available for audit, but do not make the next agent search through it before acting.

Switching from one coding agent to another

Codex, Claude Code, Cursor, and Copilot each have their own session mechanisms. Cross-tool continuity should therefore live in project facts that every tool can read: current files, focused instructions, a roadmap outcome, verification evidence, and a short handoff.

A developer discussion about switching agents identifies the same loss points: architecture decisions, conventions, failed approaches, and the reason behind choices. See what gets lost when switching coding agents.

When the project is too stale to resume directly

Pause and re-plan when:

  • dependencies or platform contracts changed materially;
  • production differs from the last local state;
  • the user goal changed;
  • the working tree contains unexplained edits;
  • the last run ended during an unknown external write.

In those cases, the first task is a read-only reality audit. It is not safe to keep implementing from the old plan.

The core principle

Resume from verified project state, not remembered conversation. A good restart takes minutes because the durable facts are already beside the work.