L15 · Recover interrupted work
Skill packs and prompts are provided in English so they work best with the AI tools. Use them as-is.
Recover interrupted work
Learning time: about 28.7–46.1 active minutes. Choose ONE presentation: the text (about 6.1 minutes, estimated) OR the lesson video (3:40, measured). Then 25–40 minutes of practice and checking (estimated). Do not count both presentations. Setup delays and optional extra study are separate; learner timing has not yet been piloted.
Where you are: Module 8, lesson 15. You have practised scoped builds, independent review and isolated work. Now you will recover a project after an interruption.
What you will do
Reconcile a saved handoff with actual project state, decide whether to resume a conversation or begin a fresh one, and write a safe next instruction. Your evidence supports outcomes O3 and O7: recoverable records and checked results.
Teaching
A laptop restart can leave several different states behind. Files may have been written but not committed. A commit may exist locally but not on GitHub. A remote tool may have completed an action even though your terminal never displayed its response. A conversation can end while a separate job continues.
Start by checking what happened. Opening the same chat is only one part of recovery. Claude Code documents saved sessions associated with project directories; Codex also has resume routes. The available command and session list depend on the surface and installed version. Use its current session picker or supported help, and match the project and session identity before continuing.
Keep a handoff that names the project path, current branch or checkout, latest known commit, uncommitted work, completed checks, active jobs and next action. These fields are a course convention. They help a new session inspect the project without reconstructing every conversation.
If a run was interrupted, avoid launching a second writer until you know whether the first is still active. Inspect the terminal, task list or provider's run status. Do not terminate unfamiliar processes. If ownership is unclear, stop the new write and ask the person responsible.
Preserve unexplained changes before choosing a repair. A destructive reset can discard work you wanted to keep. Claude's file checkpoints also have limits: changes made only through shell commands and external effects may fall outside their coverage. Git history, a saved conversation and a tool's run record are different evidence sources.
Worked example
This original simulated case concerns the Workshop Launch Kit. Before an unexpected restart, the handoff said: “Calculator input validation written; tests not yet run; next action is run checks.” After restart, the owner observes two modified files and no active job. The files contain the validation changes. There is no recorded test result.
The owner preserves the changed files, compares their difference from the starting commit, and runs the specified checks. They do not ask the builder to write the feature again. A check fails on a negative attendee value, so the next task becomes a bounded repair. The handoff is updated with the observed failure and current files.
Use this complete recovery request before allowing edits:
Recover the local fictional Workshop Launch Kit without changing files
or starting another writer. Identify the project directory, branch or
detached checkout, current commit and uncommitted changes. Read the
existing project instructions and HANDOFF.md. Compare its claims with
the actual files and any saved test results. Identify active jobs only
through available status evidence; do not guess or stop unknown jobs.
Report completed work, uncertain work, possible duplicates and the
smallest safe next action. Preserve all unexplained changes. Do not
reset, clean, delete, force-push, purchase, send or deploy. If a remote
action may have happened, inspect its recorded status before retrying.
Wait for my choice before any recovery edit.
In a new session, supplying this request and the actual project records is safer than saying “continue what we were doing.” In a resumed session, the same reconciliation is still necessary.
Do it yourself
Read this separate simulated interruption record:
- Handoff: “Budget note saved locally; commit and push planned next.”
- Current local history contains a new commit named “Explain capacity limit.”
- The working folder has one uncommitted note explaining a retry failure.
- Live GitHub still shows the earlier commit.
- A separate agent is currently reading the committed budget note; its task is read-only.
Write a recovery decision with what is complete, what remains, what must be preserved and whether a second build should start. Do not invent a hash or a successful push. Explain whether the read-only reviewer prevents saving the uncommitted note, and what version its eventual review would cover.
Feedback and retry
Pause here before reading the feedback.
The commit exists locally, while the push remains incomplete according to the live remote check. Preserve the uncommitted note. There is no reason to repeat the budget build. The reviewer can continue on its named committed version, but its result will not cover later changes. Saving the separate note can be safe if it does not alter the reviewed material; record the difference explicitly.
Retry: a tool that creates an external record timed out. You have its request identifier but no completion receipt. What comes first? Inspect the provider's status or existing record using that identifier. If completion remains unknown, record uncertainty and pause the duplicate action. A timeout is not proof that the original request failed. No external action is required in this classroom exercise.
Check your understanding
Choose an answer and write one sentence explaining why before you read the answers.
- Which statement is supported after reopening a saved conversation?
- A. All remote jobs resumed.
- B. Every uncommitted file is backed up remotely.
- C. The previous conversation is available; actual files and jobs still need checking.
Answers
- C. Conversation recovery alone establishes neither remote execution nor a backup.
Summary
Your recovery record should explain what you observed, what is uncertain and why the next action preserves completed work. Keep new execution separate from the initial read-only check.
Sources
- Anthropic, Manage sessions and Checkpointing, checked 8 November 2026.
- OpenAI, Developer commands, resume sections.
- GitHub, GitHub flow. Recovery cases and handoff fields are original course procedures.
Hands-on recovery rehearsal before assessment
In your confirmed practice repository, create a harmless new note named recovery-practice.md and leave it uncommitted. Record git status, the file's contents, current branch and last commit in your handoff. Do not interrupt another running process. Close only your own idle agent conversation, then open a fresh one in the same folder. Give it a read-only recovery task: inspect the handoff, status and actual note; identify the next unfinished task without overwriting anything. Compare the note before and after. Record the actual result, or state why the client action was not available. This rehearses saved state inspection; it is not a laptop reboot or proof a background remote job resumed. Resume a small authorized edit only after reconciliation.
