- 类别Claude Code
- 产品Claude Code
- 日期2026年7月6日
- 阅读时间5分钟
- https://claude.com/blog/a-field-guide-to-claude-fable-finding-your-unknowns
在使用 Claude Code 时,我常常会想起地图与疆域之间的区别。
地图,是对待完成工作的表征,是我的提示词、技能和上下文,是我提供给 Claude 的东西。疆域则是工作实际发生的地方,是代码库,是真实世界,是它实际面临的约束。
地图与疆域之间的差异,我称之为未知项。当 Claude 遇到未知项时,它需要基于对我意图的最佳猜测来做决策。完成的工作越多,Claude 可能遇到的未知项就越多。
Claude Fable 是第一个让我觉得工作质量受限于我澄清其未知项能力的模型。
重要的是,仅仅提前规划并不总是足够的。你可能会在实现过程中发现未知项,或者你的未知项可能会指向一个事实:你实际上应该用完全不同的方式来解决这个问题。
我发现,与 Fable 合作是一个在实现之前、期间和之后不断发现自身未知项的迭代过程。
了解你的未知项
你的未知项是什么?当我带着问题来找 Claude 时,我倾向于将其分解为四种方式:
- 已知的已知项:这基本上就是我提示词里的内容。我告诉智能体我想要什么?
- 已知的未知项:我还没弄清楚什么,但我意识到自己还没弄清楚?
- 未知的已知项:什么东西太过显而易见以至于我永远不会写下来,但看到时却能认出来?
- 未知的未知项:我完全没有考虑过什么?我不了解哪些知识?我知道某件事可以做到多好吗?
最优秀的智能体编码者拥有相对较少的未知项。观察像 Boris 或 Jarred 这样的人编写提示词,我明显感觉到他们清楚地知道自己想要什么细节。他们与代码库以及模型行为都深度同步。
但他们也会假设存在未知项。从很多方面来说,减少未知项并为其做好规划,就是智能体编码的技能。但幸运的是,这是一项你可以通过与 Claude 合作来提升的技能。
帮助 Claude 帮助你
指导 Claude 是一门微妙的平衡艺术。如果你指示过于具体,Claude 会严格遵循你的指令,即便此时调整方向可能更为合适。如果你指示过于模糊,Claude 往往会根据行业最佳实践做出选择和假设,而这些可能并不适合你的任务。
当你没有考虑到自己的未知因素时,你会两头落空。你不知道路径何时会布满障碍,也不知道路径何时会畅通无阻,但你仍然希望 Claude 能够灵活转向。
Claude 可以帮助你更快地发现自己的未知因素。它能极其迅速地搜索你的代码库和互联网,并且对大多数主题的了解远超于你。它还能从失败中更快地迭代。
这个过程最重要的部分是向 Claude 提供关于你起点的背景信息。例如,告诉它你当前处于思考过程的哪个阶段;说明你对问题和代码库的熟悉程度;让它像一位思考伙伴一样与你协作。
在本文中,我将详细介绍自己用来发现这些未知因素的一些模式,包括:
实施前:
- 盲点排查
- 头脑风暴与原型设计
- 访谈
- 参考资料
- 实施方案
实施过程中:
- 实施记录
实施后:
- 方案推介与解释说明
- 测验
实施前
盲点排查
开始工作时,最有用的做法之一就是了解自己的盲点。例如,如果你正在代码库的新区域编写功能,或者使用 Claude 帮助你完成不熟悉的工作(如迭代设计方案),你很可能存在大量“未知的未知”。
你可能不知道要问什么问题,不知道什么才算好的结果,不知道有哪些历史工作已经完成,也不知道有哪些坑需要避开。
在这些情况下,你可以请 Claude 帮助你找到这些“未知的未知”,并向你解释清楚。我喜欢直接使用“盲点排查”和“未知的未知”这两个字眼。向 Claude 说明你的身份和知识背景,通常对于它理解如何以最佳方式开始与你协作至关重要。
示例提示词:
- “我正在尝试添加一个新的身份验证提供方,但我对这个代码库中的身份验证模块一无所知。你能帮我做一次盲点排查,找出我相关的‘未知的未知’,并帮助我更好地向你提问吗。”
- “我不知道什么是调色,但我需要给这段视频调色。你能教我理解我在调色方面的‘未知的未知’,这样我就能更好地提问了吗?”
头脑风暴与原型设计
当我在一个充满大量“已知的未知”的领域工作时,涉及那些我只有看到时才能定义的标准,我喜欢请Claude和我一起进行头脑风暴和原型设计。
在原型设计阶段尽早识别并表述出“已知的未知”极具价值,因为在实施阶段才发现它们,代价会(相对)高昂。功能或规格上的微小改动,可能导致代码实现上的巨大差异,而且你的智能体也更难撤销之前的修改。
例如,你可能只是想看看在框架中添加一个按钮的效果,而不想为此连接后端路由或在前端维护额外的状态。
另一个例子是视觉设计,对我来说,这很难用语言描述,但我看到时就知道我想要什么。在这些情况下,我会要求提供同一个作品的几种不同设计方案。
我几乎每次开始编码会话时,都会先进行探索或头脑风暴阶段。这有助于我带着明确意图开始,从而定义项目的范围。Claude经常能发现我可能会错过的高价值方法,但有时也会只见树木不见森林。头脑风暴可以防止我将范围设定得过窄或过宽。
示例提示词:
- “我想为这些数据做一个仪表盘,但我没有审美,也不知道能做成什么样。给我做一个HTML页面,展示4种截然不同的设计方向,这样我就能给出反馈了。”
- “在连接任何真实功能之前,先用假数据做一个模拟新编辑器工具栏的单个HTML文件。我想先看看布局效果,你再碰真正的应用。”
- “这是我的粗略问题:用户在新手引导后流失了。搜索代码库,头脑风暴出10个我们可以介入的点,从成本最低到最具野心的方案。告诉我哪些方案你觉得可行。”
访谈
在充分进行头脑风暴之后,我可能仍然存在一些未知因素。
在这种情况下,我会让 Claude 就任何未知或模糊之处对我进行提问。当你让 Claude 对你进行提问时,尽量提供关于你问题的背景信息,以引导它提出更有针对性的问题。
示例提示词:
- "每次只问一个关于任何模糊之处的问题,优先提出那些我的回答会改变架构的问题。"
参考资料
有时你无法详细描述你想要的东西。例如,你可能缺乏相应的术语,或者它过于复杂,需要花费很长时间才能说清楚。
在这种情况下,最佳方法是提供参考资料。虽然你可以包含图表、文档或图片,但最好的参考资料是源代码。
如果你有一个以特定方式实现某些功能的库,或者一个你非常喜欢的设计组件,只需将 Fable 指向该文件夹,并告诉它要查找什么,即使它使用的是不同的编程语言。与截图等方式相比,这能为 Claude 提供关于标记和结构更丰富的细节。
示例提示词:
- "vendor/rate-limiter 目录下的这个 Rust crate 实现了完全符合我需求的重试退避行为。请阅读它,并在我们的 TypeScript API 客户端中重新实现相同的语义。"
实施方案
当我认为自己准备好开始实现时,我倾向于让 Claude 整理一份实施方案供我审阅。该方案侧重于最可能发生变更的部分,例如数据模型、类型接口或用户体验流程。这能让 Claude 揭示出我可能确实需要修改的地方。
示例提示词:
- "用 HTML 编写一份实施方案,但首先列出我最可能调整的决策:数据模型变更、新的类型接口,以及任何面向用户的内容。将机械性的重构细节放在最后,这部分我信任你。"
实现过程中
实现说明
一旦我对方案感到满意,我会开启一个新的会话,并将任何产物传递给提示词。这为 Claude 提供了一个全新的上下文窗口,但其中包含了你在规划阶段整理的所有信息。例如,我可能会传入一个规格说明文件和一个原型,然后让智能体来实现它。
但事实是,无论你做了多少规划,总会有未知的未知因素潜伏其中。智能体可能会在工作中发现,由于代码中遇到了一个边缘情况,它需要采取不同的策略。
我让 Claude Code 保留一个临时的 `implementation-notes.md`(或 .html)文件,用来记录它所做的决策,这样我们就能为下一次尝试积累经验。
示例提示词:
- “请保留一个 implementation-notes.md 文件。如果你遇到一个迫使你偏离原计划的边缘情况,请选择保守方案,将其记录在‘偏差’部分,然后继续执行。”
实施后
推介与说明
交付产品最重要的环节之一就是获得认可和批准。在最终文档中构建推介和说明材料有助于:
- 当评审者与你一样从零开始面对未知时,加速他们的理解
- 当专家希望看到你已考虑到他们本会预见的未知因素和常见故障点时,加速审批流程
示例提示词:
- “将原型、规格说明和实施笔记打包成一个文档,方便我直接发到 Slack 上争取支持。请把演示 GIF 放在最前面。”
测验
经过长时间的工作会话后,Claude 可能已经完成了比我意识到的多得多的内容。仅通过阅读代码差异,我只能对发生的事情有一个浅显的了解,因为很多行为都取决于现有的代码路径。
在提供大量上下文后,让 Claude 就变更内容对我进行测验,有助于我理解发生了什么。只有在我完美通过测验后,我才会合并代码。
示例提示词:
- “我想确保自己完全理解这次变更中发生的一切。请给我一份关于这些变更的 HTML 报告,包含上下文、直觉理解、具体操作等内容,让我阅读并理解,并在报告底部附上一个我必须通过的关于这些变更的测验。”
如何整合:发布 Fable
Fable 的发布视频是使用 Claude Code 端到端剪辑完成的。这对我来说是一个全新的领域,我也绝非专家。
于是我从自己已知的部分入手。我知道 Claude 能够使用代码编辑视频并进行转录,但我不确定其准确度是否足够。接着我让 Claude 向我解释像 Whisper 这样的转录技术是如何工作的,以及我能否利用 ffmpeg 精确地剪掉诸如“嗯”之类的语气词或较长的停顿。
我希望 Claude 能创建一个与我说话内容同步的 UI,但不确定这是否可行,于是我让 Claude 使用 Remotion 和一段转录文本先制作一个原型视频,看看效果如何。
最后,视频本身看起来有点暗淡,我知道这是调色的结果,但我其实并不了解什么是调色。我的第一轮尝试是让 Claude 生成几个不同版本供我挑选,但我意识到,在调色方面,我根本不知道“好”的标准是什么。于是,我转而让 Claude 教我调色的知识,以此来发现我的未知领域。
让地图与疆域相匹配
模型越强大,采用正确方法所能达成的效果就越多。当一个长周期任务的结果出现偏差时,很可能你需要花更多时间来界定你的未知领域,或者制定一个能让你和 Claude 共同适应并克服这些未知的执行计划。
每一次解释说明、头脑风暴、访谈、原型制作和参考查阅,都是在问题变得代价高昂之前,发现自身未知领域的低成本方式。
所以,开启你的下一个项目时,先让 Claude 帮你找到你的未知领域。
本文由 Anthropic 技术团队成员 Thariq Shihipar 撰写。
借助 Claude 改变您组织的运作方式
- Category
- ProductClaude Code
- DateJuly 6, 2026
- Reading time5min
- https://claude.com/blog/a-field-guide-to-claude-fable-finding-your-unknowns
When working with Claude Code, I’m often reminded of the difference between the map and the territory.
The map, a representation of the work to be done, is my prompts and skills and context, it’s what I give Claude. The territory is where the work needs to happen, the codebase, the real world, its actual constraints.
The difference between the map and the territory is what I call unknowns. When Claude runs into an unknown, it needs to make a decision based on its best guess of what I want. The more work being done, the more unknowns Claude might run into.
Claude Fable is the first model where I find the quality of the work is bottlenecked by my ability to clarify its unknowns.
Importantly, just planning ahead isn’t always enough. You can find unknowns deep in implementation, or your unknowns may point you to the fact that you should actually be solving the problem in a different way altogether.
I’ve found that working with Fable is an iterative process of discovering my unknowns before, during, and after implementation.
Knowing your unknowns
What are your unknowns? When I come to Claude with a problem I tend to break it down in 4 ways:
- Known Knowns: This is essentially what is in my prompt. What do I tell the agent that I want?
- Known Unknowns: What haven't I figured out yet, but I’m aware that I haven’t?
- Unknown Knowns: What's so obvious I’d never write it down, but would recognize it if I saw it?
- Unknown Unknowns: What haven't I considered at all? What knowledge am I not aware of? Do I know how good something can be?
The best agentic coders have relatively few unknowns. Watching someone like Boris or Jarred prompt, it is obvious to me that they know what they want in-detail. They are deeply in-sync with both the codebase and the model behaviors.
But they also assume unknowns. In many ways, reducing and planning for your unknowns is the skill of agentic coding. But luckily, this is a skill you can improve at, by working with Claude.
Help Claude help you
Instructing Claude is a delicate balance. If you are too specific, Claude will follow your instructions even when a pivot may be more appropriate. If you are too vague, Claude will often make choices and assumptions based on industry best practices that may not be a fit for your task.
When you don’t account for your unknowns, you fail both ways. You don't know when the path will be filled with obstacles, and you don’t know when the path will be clear, but you still want Claude to veer.
Claude can help you discover your unknowns faster. It can search through your codebase and the internet extremely quickly, and it knows much more about the average topic than you. It can also iterate from failure faster.
The most important part of this process is to give Claude context about your starting point. For example, tell it where you are in your thought process; disclose your experience with the problem and codebase; and let it work with you like a thought partner.
In this article I detail some of the patterns I use to uncover these unknowns including:
Pre-implementation:
- Blind spot pass
- Brainstorms and prototype
- Interviews
- References
- Implementation plan
During implementation:
- Implementation notes
Post implementation
- Pitches and explainers
- Quizzes
Pre-implementation
Blind Spot Pass
When starting work, one of the most useful things you can do is understand your blind spots. For example, if you’re writing a feature in a new part of the codebase, or using Claude to help you with unfamiliar work like iterating on a design, you’re likely to have a lot of unknown unknowns.
You may not know what questions to ask, what good looks like, what historical work has been done, or what potholes to avoid.
In these situations, you can ask Claude to help you find your unknown unknowns and explain them to you. I like to use the literal words “blind spot pass” and “unknown unknowns.” Giving it context on who you are and what you know is usually important for Claude to understand the best way to start collaborating with you.
Example prompts:
- “I'm working on adding a new auth provider but I know nothing about the auth modules in this codebase. Can you do a blind spot pass to help me figure out my relevant unknown unknowns and help me prompt you better.”
- “I don’t know what color grading is but I need to grade this video. Can you teach me to understand my unknown unknowns about color grading, so that I can prompt better?”
Brainstorms and prototypes
When I’m working in an area with a lot of unknown knowns, involving criteria I only know to define when I see it, I like to ask Claude to brainstorm and prototype with me.
It’s extremely valuable to identify and verbalize unknown knowns early during prototyping, because finding them out during implementation can be (relatively) expensive. Small changes in a feature or spec can cause drastically different implementations in code, and it can be more difficult for your agent to revert previous changes.
For example, you may just want to see how a button added to a frame looks without having to wire up a backend route or maintaining additional state in the frontend.
Another example is visual design, which for me, is something that is difficult to articulate, but I know what I want when I see it. In these cases, I’ll ask for several design approaches to an artifact.
I also start almost every coding session with an exploration or brainstorming phase. This helps me start with intent to define the project’s scope. Claude often finds high-value approaches I would have missed, and sometimes misses the forest through the trees. Brainstorming prevents me from setting too narrow or too wide a scope.
Example prompts:
- "I want a dashboard for this data but I have no visual taste and don't know what's possible. Make me an HTML page with 4 wildly different design directions so I can react to them.”
- “Before wiring anything up, make a single HTML file mocking the new editor toolbar with fake data. I want to react to the layout before you touch the real app."
- "Here's my rough problem: users churn after onboarding. Search the codebase and brainstorm 10 places we could intervene, from cheapest to most ambitious. I'll tell you which ones resonate."
Interviews
Once I’ve done sufficient brainstorming, I likely still have unknowns.
In this case, I ask Claude to interview me about any unknowns or ambiguities. When asking Claude to interview you, try and give it context about your problem to guide its questions.
Example prompt:
- "Interview me one question at a time about anything ambiguous, prioritize questions where my answer would change the architecture."
References
Sometimes you can’t describe what you want in detail. For example, you might not have the language or it might be so complicated that it would take you quite a while.
In this case, the best approach is a reference. While you can include diagrams, documentation or pictures, the absolute best reference is source code.
If you have a library that implements something in a certain way or a design component you really like, just point Fable at the folder and tell it what to look for, even if it’s in a different language. This provides Claude much richer detail around the markup and structure, compared to for example a screenshot.
Example prompts:
- "This Rust crate in vendor/rate-limiter implements the exact backoff behavior I want. Read it and reimplement the same semantics in our TypeScript API client."
Implementation Plans
When I think I’m ready to implement, I tend to ask Claude to put together an implementation plan for me to review. The plan focuses on the parts that might be most likely to change such as data models, type interfaces, or UX flows. This allows Claude to surface things I might actually need to alter.
Example prompt:
- "Write an implementation plan in HTML, but lead with the decisions I'm most likely to tweak with: data model changes, new type interfaces, and anything user-facing. Bury the mechanical refactoring at the bottom, I trust you on that part."
During implementation
Implementation notes
Once I am satisfied with my plan, I make a new session and pass any artifacts to the prompt. This gives Claude a fresh context window but with all of the information it compiled from your planning. For example, I might pass in a spec file and a prototype and ask an agent to implement it.
But the truth is that no matter how much planning you do, there are always unknown unknowns lurking. The agent may find during its work that it needs to take a different tack due to an edge case it found in the code.
I ask Claude Code to keep a temporary ‘implementation-notes.md’ (or .html) file where it keeps track of decisions it makes so we can learn for our next attempt.
Example prompt:
- "Keep an implementation-notes.md file. If you hit an edge case that forces you to deviate from the plan, pick the conservative option, log it under 'Deviations', and keep going."
Post implementation
Pitches and explainers
One of the most important parts of shipping something is getting buy-in and approvals. Building pitch and explainer artifacts in the final document helps:
- Accelerate understanding when reviewers start with the same unknowns you did
- Accelerate approvals when experts want to see you accounted for the unknowns and common failure points they would have anticipated
Example prompt:
- "Package the prototype, the spec, and the implementation notes into a single doc I can drop in Slack to get buy-in. Lead with the demo GIF."
Quizzes
After a long working session, Claude might have accomplished a lot more than I realized. Reading the code diffs can only give me a light understanding of what happened, since much of the behavior will depend on existing code paths.
Asking Claude to quiz me about the change after giving me a bunch of context helps me understand what happens. I only merge after I pass the quiz perfectly.
Example prompt:
- “I want to make sure I understand everything that's happened in this change. Give me a HTML report on the changes for me to read and understand with context, intuition, what was done, etc. and a quiz at the bottom on the changes that I must pass.”
How this comes together: launching Fable
The launch video for Fable was edited end-to-end using Claude Code. This was a new domain for me and I’m by no means an expert.
So I started with what I did know. I knew that Claude could use code to edit videos and transcribe them, but I wasn’t sure if it was accurate enough. I then asked Claude to explain to me how transcription like Whisper worked, and whether I would be able to accurately cut out things like ums or large pauses using ffmpeg.
I wanted Claude to create a UI that was timed with the words I was saying, but wasn’t sure it was possible so I asked Claude to create a prototype video using Remotion and a transcription to see if it would work.
Finally, the video itself looked a bit muted, which I knew was the result of color grading but I didn’t really know what color grading was. My first pass attempt was to try and get Claude to do a few variations to pick, but I realized that I didn’t know what “good” looked like when it came to color grading. So instead, I asked Claude to teach me about color grading to discover my unknowns.
Matching the Map and Territory
The better models get, the more you can achieve with the right approach. When a long-horizon task comes back wrong, it's likely you need to spend more time defining your unknowns or creating an implementation plan that allows for you and Claude to adapt through them.
Every explainer, brainstorm, interview, prototype, and reference is a cheap way to find out what you didn't know before it gets expensive to fix.
So start your next project by asking Claude to help you find your unknowns.
This article was written by Thariq Shihipar, member of technical staff, Anthropic.