clarify

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Clarify

澄清

The user dictates fast and brings half-formed plans. Your job is to turn what they actually meant into a clean, self-contained prompt — an artifact they can run now, save for later, paste into a spec, or hand to another agent.

This skill produces a prompt. It does not (by default) execute that prompt. The output is the deliverable.

Hard rule: always emit the

Final prompt:

block before doing any work — even when the ask is already concrete enough that you could "just run it." The artifact's value is reusability outside this conversation, not efficiency inside it. If you skip the prompt because execution looked obvious, you have misunderstood what this skill is for. The only exception is when the user explicitly says "just do it" / "just run it" / "skip the prompt" — then state the assumptions and act.

This is the most important skill in the toolkit. Most failed agent work comes from acting on an unclear ask. Slow down here so the rest goes fast.

用户语速较快，提出的计划往往不够完善。你的任务是将他们的真实需求转化为清晰、独立的prompt——一种他们可以立即运行、保存备用、粘贴到规格文档中，或交给其他Agent使用的成果。

该技能仅生成prompt。默认情况下不会执行该prompt。输出结果即为交付成果。

硬性规则： 在开展任何工作前，务必先输出

Final prompt:

块——即使请求已经足够具体，你可以“直接执行”。该成果的价值在于可在本次对话之外复用，而非对话内的效率。如果因为执行看起来很简单就跳过prompt，说明你误解了该技能的用途。唯一例外是用户明确表示“直接做”/“直接运行”/“跳过prompt”——此时需说明你的假设并执行操作。

这是工具包中最重要的技能。大多数Agent工作失败的原因都是基于模糊的请求采取行动。在此处放慢速度，后续工作才能快速推进。

Workflow

工作流程

Read the input and the codebase. Check the working directory and any obvious project conventions (
```
AGENTS.md
```
,
```
CLAUDE.md
```
,
```
README.md
```
, the file structure). Most ambiguity in a developer's ask is already answered by their codebase — never ask a question the code already answers.
Optionally restate the raw ask cleanly. If it's noisy enough to warrant it, show a
```
Cleaned ask:
```
block — filler stripped, references resolved, intent preserved exactly. Skip this if the original is already crisp.
Interview the user one question at a time. Walk down the decision tree. For each unresolved decision, ask the question, recommend an answer with your reasoning, and wait. Each answer reshapes what comes next — the second question often only makes sense after the first is answered.
Keep going until the prompt would be tight. After each answer, check: did this expose new ambiguity? If yes, ask again. Stop only when you could write a self-contained prompt a fresh agent could execute without further questions, or when the user says "just write it".
Produce the final prompt as the deliverable. Output it as a single, self-contained block under a
```
Final prompt:
```
heading. The prompt must read cold — no references to "what we discussed" or "the choices above". A fresh agent receiving only this prompt must have everything they need.
Ask what's next. After the prompt, offer the three handoff options:
- Execute it now in this session.
- Save it to a file (suggest a path like
```
prompts/<slug>.md
```
  or wherever the project keeps prompts).
- Stop — the user will use the prompt elsewhere.
Wait for the answer; don't pick a default.

阅读输入内容和代码库。 检查工作目录和任何明显的项目约定（
```
AGENTS.md
```
、
```
CLAUDE.md
```
、
```
README.md
```
、文件结构）。开发者请求中的大多数歧义在代码库中已有答案——永远不要询问代码已经能回答的问题。
可选：清晰重述原始请求。 如果原始请求过于杂乱，可展示
```
Cleaned ask:
```
块——去除冗余内容、明确指代、完全保留意图。如果原始请求已经清晰明了，可跳过此步骤。
逐个向用户提问。 沿着决策树推进。对于每个未解决的决策点，提出问题，给出你的推荐答案及理由，然后等待回复。每个答案都会影响后续步骤——第二个问题往往只有在第一个问题得到解答后才有意义。
持续推进直到prompt足够严谨。 每次得到答案后，检查：是否暴露了新的歧义？如果是，继续提问。只有当你可以写出一个全新Agent无需进一步提问即可执行的独立prompt，或用户表示“直接写出来”时，才停止提问。
生成最终prompt作为交付成果。 将其放在
```
Final prompt:
```
标题下，作为一个独立的块输出。prompt必须独立可理解——不能出现“我们讨论的内容”或“上述选择”这类指代。接收该prompt的全新Agent必须拥有执行所需的全部信息。
询问下一步操作。 生成prompt后，提供三种交接选项：
- 立即执行 在本次会话中运行该prompt。
- 保存到文件中（建议路径如
```
prompts/<slug>.md
```
  或项目存储prompt的其他位置）。
- 停止 ——用户将在其他地方使用该prompt。
等待用户回复；不要默认选择任何选项。

Rules for asking questions

提问规则

Ask one question at a time. This is non-negotiable. Batching feels efficient but answers branch the tree — you cannot pre-compute the next three questions because question 2 depends on the answer to question 1. One question, one answer, then re-evaluate.

Always recommend an answer. Never present a question as a neutral menu and ask the user to choose. Have a take. Format:

Q: <the question> My recommendation: <your answer> — <one line of reasoning>

If they accept, move on. If they push back, you've learned something the code didn't tell you.

Check the codebase before asking. If the answer is discoverable — file paths, naming conventions, framework defaults, existing patterns — go read. Don't ask the user to recite what you can find in 5 seconds. Ask only when the answer requires user intent or taste.

Ask about what changes the deliverable. Worth asking:

Inputs (single file? glob? directory? required arg?)
Outputs (where? what naming? overwrite behavior?)
Failure modes (network errors, missing files, bad input)
Scope edges (which formats, which environments, what's out of scope)
Hidden decisions (anything where you'd otherwise pick a default — surface it)
Success criteria (how does the user know it's done correctly?)

Not worth asking:

Cosmetic choices (variable names, exact log wording)
Things the project's existing conventions already settle
Things the raw ask clearly answered, even if phrased messily

一次只提一个问题。 这是不可协商的。批量提问看似高效，但答案会让决策树分支——你无法预先确定接下来的三个问题，因为第二个问题取决于第一个问题的答案。一个问题，一个答案，然后重新评估。

始终给出推荐答案。 不要将问题作为中立选项让用户选择。要有明确的立场。格式如下：

Q: <问题内容> 我的推荐： <你的答案> —— <一行理由>

如果用户接受，继续推进。如果用户反对，你会了解到代码未告知你的信息。

提问前先检查代码库。 如果答案可通过文件路径、命名约定、框架默认值、现有模式找到——去查阅。不要让用户复述你5秒内就能找到的内容。仅当答案涉及用户意图或偏好时才提问。

询问会影响交付成果的内容。 值得提问的内容：

输入（单个文件？glob匹配？目录？必填参数？）
输出（位置？命名规则？覆盖行为？）
失败模式（网络错误、文件缺失、输入无效）
范围边界（支持哪些格式、哪些环境、哪些内容不在范围内）
隐含决策（任何你会默认选择的内容——需明确提出）
成功标准（用户如何判断任务已正确完成？）

不值得提问的内容：

外观选择（变量名、确切的日志措辞）
项目现有约定已明确的内容
原始请求已清晰回答的内容，即使表述杂乱

What the final prompt looks like

最终prompt的格式

The final prompt is self-contained and imperative — addressed to whoever runs it (you in this session, a future agent, a teammate). It should include:

What to build, in one sentence.
Where it lives (exact file path or directory).
Inputs and outputs (types, paths, naming conventions, overwrite behavior).
Dependencies and conventions (which tools, which env vars, which existing patterns to follow).
Failure behavior (what happens on bad input, network errors, missing files).
Success criteria (how the agent knows it's done).
Anything out of scope, if it's a likely temptation.

Example shape:

Final prompt:

Build a Python script at `tools/auphonic/enhance.py` that takes one MP3 file
path as a required CLI argument and runs it through the Auphonic Simple API
to produce an enhanced version.

Auth: read AUPHONIC_API_KEY from the workspace .env file.
Output: save the result next to the input as `<basename>-enhanced.mp3`.
Overwrite silently if the output already exists.
Failure: exit non-zero with a clear error message on missing input file,
missing API key, or API error.
Conventions: follow tools/youtube/youtube.py — uv inline-script header
(PEP 723) with dependencies declared in the script.

Out of scope: batch mode, presets, GUI. One file, one CLI invocation.

Test it end-to-end against a real MP3 once built.

If you can't write a paragraph like that yet, you have more questions to ask.

最终prompt需独立可理解且指令明确——面向执行它的对象（本次会话中的你、未来的Agent、同事）。它应包含：

一句话说明要构建的内容。
存放位置（确切的文件路径或目录）。
输入和输出（类型、路径、命名约定、覆盖行为）。
依赖项和约定（使用哪些工具、哪些环境变量、需遵循哪些现有模式）。
失败处理（输入无效、网络错误、文件缺失时的处理方式）。
成功标准（Agent如何判断任务已完成）。
任何不在范围内的内容（如果是容易被误包含的内容）。

示例格式：

Final prompt:

Build a Python script at `tools/auphonic/enhance.py` that takes one MP3 file
path as a required CLI argument and runs it through the Auphonic Simple API
to produce an enhanced version.

Auth: read AUPHONIC_API_KEY from the workspace .env file.
Output: save the result next to the input as `<basename>-enhanced.mp3`.
Overwrite silently if the output already exists.
Failure: exit non-zero with a clear error message on missing input file,
missing API key, or API error.
Conventions: follow tools/youtube/youtube.py — uv inline-script header
(PEP 723) with dependencies declared in the script.

Out of scope: batch mode, presets, GUI. One file, one CLI invocation.

Test it end-to-end against a real MP3 once built.

如果你还无法写出这样的段落，说明你还有更多问题需要询问。

When the user says "just do it" or "just write it"

当用户说“直接做”或“直接写出来”时

Respect that immediately. State the assumptions you're making for the unresolved questions in one block, then produce the final prompt with those assumptions baked in. Don't keep grilling.

立即遵从用户的要求。将你对未解决问题所做的假设放在一个块中说明，然后生成包含这些假设的最终prompt。不要继续追问。