渐进式调查模式
使用 Grep 查找入口点，使用 Read 阅读文件，再用 Grep 查找用法，最后使用 Read 阅读调用方。
渐进式调查模式 是 CoddyKit 上的免费 Claude Architect 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Claude Architect 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Claude Architect 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Why Investigate Incrementally
When Claude Code lands in an unfamiliar codebase, dumping every file into context is wasteful and unreliable. Large blobs trigger lost-in-the-middle: the model attends to the start and end of context far more than the middle, so facts buried in a giant paste get missed.
The Incremental Investigation Pattern solves this. Instead of loading everything, Claude follows a deliberate chain that widens understanding one verified step at a time, pulling only the files that matter.
The Four-Step Chain
The canonical loop for built-in tools is:
- Grep entry points — search file contents to locate where a feature begins.
- Read files — load the matched files to understand the definition.
- Grep usages — search for everywhere that symbol is referenced.
- Read consumers — open the call sites to see how it is actually used.
Each step narrows the search space using evidence from the previous step. You never guess which files matter — the codebase tells you.
# Conceptual flow with Claude Code built-in tools
# 1) Grep -> find entry points
# 2) Read -> the matched definition files
# 3) Grep -> usages of the symbol
# 4) Read -> the consumer / call-site filesThe Built-in Tools You'll Use
This pattern leans on Claude Code's built-in tools. Know exactly what each does:
- Glob — find files by name pattern, e.g.
**/*.test.tsx. - Grep — search inside file contents.
- Read — load a single file into context.
- Edit — make a precise, unique-match change.
- Bash — run shell commands.
Incremental investigation is built almost entirely from Grep and Read — search to discover, read to confirm.
Step 1 — Grep the Entry Point
Start by searching for the symbol or string that anchors the feature. You are looking for the definition, not every mention yet. A focused query keeps the result set small and relevant.
Searching contents (Grep) beats opening directories blindly: the match points you straight at the file that defines the behavior you care about.
# Find where the checkout handler is defined
# Grep tool query:
# pattern: "def process_checkout"
# glob: "**/*.py"
# -> returns: billing/checkout.py:42Step 2 — Read the Definition
Open only the file (or files) the Grep surfaced. Now you read the actual implementation: its inputs, return values, and the other symbols it depends on. Those dependencies become the seeds for your next search.
This is the discipline of the pattern — you Read after you Grep, so every file you load is one the evidence already justified.
# Read tool:
# file_path: billing/checkout.py
#
# You learn: process_checkout() calls
# - validate_cart()
# - charge_card()
# These become your next Grep targets.Step 3 — Grep the Usages
Now flip direction. You understand the definition; next find who calls it. Grep for the symbol name across the codebase to enumerate every consumer.
This answers the questions that matter for a safe change: How many call sites exist? Do they pass the arguments correctly? Will an edit here ripple outward?
# Grep tool query:
# pattern: "process_checkout\("
# glob: "**/*.py"
# -> api/routes.py:88
# -> tasks/retry_jobs.py:19
# -> tests/test_checkout.py:55Step 4 — Read the Consumers
Open the call sites the usage-Grep returned. Reading consumers reveals real-world behavior the definition alone can't show: edge cases, error handling, and assumptions each caller makes.
With definition and consumers understood, you now have a complete, evidence-backed picture — without ever loading the whole repository.
# Read tool on each consumer:
# api/routes.py -> HTTP entry, validates auth first
# tasks/retry_jobs.py -> retries failed charges
# tests/test_checkout -> documents expected contract
# Now an Edit is safe and well-scoped.Trim Tool Output as You Go
Grep and Read can return verbose output. Don't let it pile up — trim verbose tool output to the relevant fields before it crowds your context window.
Keeping context lean directly fights lost-in-the-middle: a smaller, sharper context means the facts you gathered stay near the model's attention rather than buried in noise. Each step should add signal, not bulk.
Glob vs Grep — Pick the Right Door
Two discovery tools, two jobs:
- Glob when you know the file shape — "all test files", "every migration" — e.g.
**/*.test.tsx. - Grep when you know a symbol or string inside the code and need to find where it lives or who uses it.
Incremental investigation usually opens with Grep (you're chasing a symbol), and reaches for Glob when you want to scope by file type.
# Glob: enumerate by pattern
# pattern: "src/**/*.controller.ts"
# Grep: enumerate by content
# pattern: "checkout", glob: "src/**/*.ts"Adaptive, Not a Fixed Pipeline
Use a fixed pipeline / prompt chain when the steps are known and sequential. But investigation is open-ended, so this pattern is best run with adaptive decomposition — the model chooses the next Grep or Read based on what the last step revealed.
Drive it through the agentic loop: each tool result returns stop_reason: "tool_use", you append the result to history, and the model decides the next move. Terminate on end_turn — never by scanning text for words like "done".
while True:
resp = client.messages.create(
model="claude-opus-4-1",
max_tokens=2048,
messages=history,
tools=[grep_tool, read_tool, glob_tool],
)
if resp.stop_reason == "end_turn":
break # model decided investigation is complete
# stop_reason == "tool_use": run tool, append result, loop
history.append(run_tools(resp))Scope the Investigation Agent
If you delegate investigation to a subagent, give it a tightly scoped toolset. 4-5 tools per agent is optimal; 18+ degrades selection reliability. An investigator needs little more than Glob, Grep, and Read.
Apply least privilege: a read-only explorer should NOT hold Edit, Write, or Bash. And remember subagents do not inherit the coordinator's history — pass the target symbol, the goal, and any prior findings explicitly in the prompt.
explorer = AgentDefinition(
name="code-explorer",
description="Read-only incremental investigation of a symbol",
system_prompt="Grep entry points -> Read -> Grep usages -> Read consumers. Report findings only.",
allowed_tools=["Glob", "Grep", "Read"], # least privilege, no Edit/Write
)Quick Check
Test your grasp of the pattern's core decision.
Recap — The Investigation Discipline
Key takeaways:
- Grep entry points → Read files → Grep usages → Read consumers. Evidence guides every step.
- Avoid loading whole repos — large context causes lost-in-the-middle; trim tool output to relevant fields.
- Grep finds symbols in content; Glob finds files by pattern.
- Run it as adaptive investigation through the agentic loop; terminate on
end_turn, never on text like "done" or a hard iteration cap. - A delegated explorer stays read-only (Glob, Grep, Read), keeps to 4-5 tools, and gets all context passed explicitly.
Investigate like an architect: search to discover, read to confirm, edit with confidence.
用 AI 导师学习 Python — 免费
在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。
- 课程
- 26
- 课程
- 104
常见问题解答
「渐进式调查模式」课时是免费的吗？
是的 — 「渐进式调查模式」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Claude Architect 课程的其余内容，请升级到 CoddyKit PRO。 Claude Architect 课程共包含 4 节课。
「渐进式调查模式」这节课中我会学到什么？
使用 Grep 查找入口点，使用 Read 阅读文件，再用 Grep 查找用法，最后使用 Read 阅读调用方。 你通过在浏览器中直接运行的动手代码来练习 Claude Architect，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Claude Architect 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Claude Architect 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。
「渐进式调查模式」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Claude Architect 课中编写并运行代码吗？
能。每节 Claude Architect 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。