PricingLoginStart free
Claude Architect · 课时

过时的上下文与重新开始

恢复后的工具结果过时时，请重新进行摘要。

第 4 / 4 课13 个步骤

过时的上下文与重新开始 是 CoddyKit 上的免费 Claude Architect 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Claude Architect 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Claude Architect 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Resuming a Session

Claude Code lets you continue work across days. --resume <name> reopens a named session with its full message history intact: the prompts, the model's reasoning, and crucially the tool results that were captured the first time.

That replay is powerful. But it hides a sharp edge: those tool results are a snapshot of the past, not a live view of your system. This lesson is about recognizing when that snapshot has gone stale and what to do instead.

claude --resume refactor-auth

Why the History Is Frozen

Remember how the API works: the model keeps no state of its own. Every turn you send the full messages history — including prior tool_result blocks. The model reasons over whatever those blocks say.

A resumed session simply reloads that saved history. If a Read captured a file's contents last Tuesday, the model still believes Tuesday's version today — even if the file changed ten times since.

messages = [
    {"role": "user", "content": "Refactor the auth module"},
    {"role": "assistant", "content": [tool_use_read_authpy]},
    # tool_result below is a FROZEN snapshot from the prior session
    {"role": "user", "content": [tool_result_authpy_old]},
]
client.messages.create(model="claude-opus-4-1", max_tokens=2048, messages=messages, tools=tools)

What 'Stale Context' Looks Like

Stale context is when the resumed tool results no longer match reality. Common triggers:

  • A teammate edited the same files between sessions.
  • A migration changed the database schema the model had cached.
  • A dependency bump altered an API the model read earlier.
  • A build artifact or test output captured earlier is now obsolete.

The danger: the model proceeds confidently on outdated facts, producing edits that conflict with the current codebase.

Resume vs. Fresh Session

You have two recovery levers when a session ages:

  • --resume <name> continues the named session, replaying its full saved history.
  • fork_session branches from a shared point — useful for exploring an alternative without disturbing the original.

Both inherit the old tool results. When the codebase has drifted substantially, neither is ideal. Sometimes a fresh session seeded with a structured summary beats resuming, because it forces every fact to be re-fetched against current reality.

claude --resume refactor-auth     # replays old tool results
claude                            # fresh session, no stale snapshots

The Core Decision

Ask one question: has the ground truth changed since the session was captured?

  • Little or no drift (you paused for an hour, no one else touched the repo) → --resume is fine and cheap.
  • Significant drift (days passed, merges landed, schema migrated) → start fresh and re-summarize the goal, then let the model re-fetch live tool results.

This is a context-management reliability call — domain D5 on the exam.

Summarize Anew, Don't Replay

"Summarize anew" means: carry forward the intent and decisions, but drop the frozen tool outputs so they get re-acquired. You write a compact, structured summary of where the task stands, then open a clean session with that summary as the opening prompt.

The model then runs Read, Grep, and Bash against the current codebase — no stale snapshot to mislead it.

summary = """
GOAL: Finish refactoring auth to use the new TokenService.
DONE: Extracted TokenService; updated login() and logout().
TODO: Migrate refresh() and the 3 middleware call sites.
NOTE: schema migrated since last session — re-read current files before editing.
"""
messages = [{"role": "user", "content": summary + "\nRe-read the current files, then continue."}]

Keep Hard Facts Verbatim

Progressive summarization is lossy: it makes numbers, percentages, and dates vague. When your summary must preserve exact values — a version pin, a row count, a deadline, an order ID — don't fold them into prose.

Pull them into a separate "case facts" block kept verbatim, outside the narrative summary. The summary can compress the story; the facts block stays exact.

case_facts = {
    "target_version": "TokenService 2.4.0",
    "affected_call_sites": 3,
    "migration_applied": "2026-06-09",
}
prompt = SUMMARY_PROSE + "\n\nCASE FACTS (verbatim, do not paraphrase):\n" + str(case_facts)

Re-Fetch Before You Edit

In a fresh session the discipline is simple: investigate before mutating. Use the incremental pattern — Grep entry points, Read the files, Grep usages, Read consumers — so every edit is grounded in current contents.

This is also why Edit uses a unique-match contract: if the file drifted and your expected text no longer matches uniquely, the edit fails loudly rather than corrupting the file. Re-Read and retry.

# Fresh-session re-grounding before any change
# 1) Grep for the symbol
# 2) Read the current file
# 3) Edit with a unique match (fails loudly if the file drifted)

Don't Confuse This with /compact

/compact compresses the current conversation to free context space. It is useful, but it carries the same lossiness risk: numbers and dates can become vague. It does not solve staleness — the compacted facts are still from the original captures.

Starting fresh is different: you discard the old tool results entirely and re-derive them live. Use /compact for a long but still-accurate session; start fresh when the underlying system has moved on.

Subagents Never Inherit History

This staleness lesson rhymes with multi-agent design. Subagents do not inherit the coordinator's conversation history — all context must be passed explicitly in each subagent prompt.

The same hygiene helps you: when you hand a fresh session (or a subagent) a structured summary plus a verbatim facts block, you are doing deliberately what resume does accidentally — except you control exactly which facts survive and you force live re-fetching of the rest.

# Coordinator passes explicit, current context to each subagent
subagent_prompt = (
    "You are refactoring auth. Context summary:\n" + summary +
    "\nCASE FACTS:\n" + str(case_facts) +
    "\nRe-read the current files yourself; do not assume prior state."
)

A Practical Checklist

Before resuming a stale session, run this gate:

  • Drift? Did the repo/schema/deps change since capture? If yes → lean fresh.
  • Summarize goal, decisions made, and remaining TODOs.
  • Preserve exact numbers/dates/IDs in a verbatim facts block.
  • Re-fetch live: Grep → Read before any Edit.
  • Verify against current state, not the remembered one.

Cheap to resume when nothing moved; cheap insurance to start fresh when it did.

Quick Check

Test your judgment on the resume-vs-fresh decision.

在交互式课程中回答

Recap

Key takeaways:

  • Resumed sessions replay frozen tool results because the model holds no state and reasons over the full saved history.
  • When the system has drifted (merges, migrations, dependency bumps), those results are stale and can drive confident-but-wrong edits.
  • When drift is significant, start fresh and summarize anew rather than --resume or fork_session, which both inherit the old snapshots.
  • Keep exact numbers, dates, and IDs in a verbatim case-facts block; summarization makes those vague.
  • Re-fetch live (Grep → Read) before any Edit; /compact saves space but does not cure staleness.
免费开始

用 AI 导师学习 Python — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程
26
课程
104
免费开始学习查看完整课程

常见问题解答

「过时的上下文与重新开始」课时是免费的吗？

是的 — 「过时的上下文与重新开始」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Claude Architect 课程的其余内容，请升级到 CoddyKit PRO。 Claude Architect 课程共包含 4 节课。

「过时的上下文与重新开始」这节课中我会学到什么？

恢复后的工具结果过时时，请重新进行摘要。 你通过在浏览器中直接运行的动手代码来练习 Claude Architect，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Claude Architect 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Claude Architect 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。

「过时的上下文与重新开始」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Claude Architect 课中编写并运行代码吗？

能。每节 Claude Architect 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 固定流程与自适应分解
  2. 多轮分解
  3. 会话管理
  4. 过时的上下文与重新开始
← 返回 Claude Architect