你是不是也遇到过这样的场景：面对 ChatGPT、Claude 或 Midjourney 的输入框，明明知道它很强大，却感觉“有劲使不上”？你精心构思的问题，换来的却是 AI 敷衍的回答、跑偏的创作，或者一句“作为 AI，我无法…”。问题可能不在于模型，而在于你递给它的“钥匙”——Prompt（提示词）。

网上充斥着各种“万能 Prompt 模板”，但真正能让你举一反三、理解其底层逻辑的却很少。今天，我们不谈那些零散的技巧，而是直接带你潜入一个拥有 4.4 万颗星 的 GitHub 宝藏项目。这不仅仅是一个模板库，更是一个由顶级 AI 团队和研究者共建的“提示词金矿”。我们将通过拆解这个项目， 偷学顶级团队是如何系统化地思考、设计和编写 Prompt 的 ，从而让你彻底告别“无效提问”，掌握与 AI 高效协作的核心方法论。

这篇文章将为你解决三个核心问题：

1. 为什么你的 Prompt 总是不奏效？ —— 揭示从“用户指令”到“系统提示词”的思维转变。
2. 顶级团队的 Prompt 究竟强在哪里？ —— 通过真实项目案例，拆解结构、逻辑与设计原则。
3. 如何将这些“偷学”的技巧，应用到你的日常开发、学习和创作中？ —— 提供可直接复用的框架和代码级示例。

让我们开始这次“掘金”之旅。

1. 这篇文章真正要解决的问题：从“碰运气”到“工程化”

很多开发者对 Prompt 的理解还停留在“向 AI 提问”的层面，这是一种典型的“用户指令”思维。你告诉 AI“写一段 Python 排序代码”，它可能会给你一个冒泡排序，但这真的是你项目里需要的、带异常处理和类型注解的工业级代码吗？大概率不是。

这种思维的局限性在于，你把 AI 当成了一个“有求必应但理解力有限的神灯”，每次交互都是一次独立的、充满不确定性的“许愿”。结果就是效率低下，输出质量不稳定。

而顶级团队和研究者们，早已将 Prompt 视为一种 “工程化”的沟通协议和系统设计 。他们不是在“提问”，而是在“编程”——为 AI 定义角色、设定上下文、明确输出格式、构建思维链。这背后的项目，就是我们要深入分析的 GitHub 上的 awesome-chatgpt-prompts 或类似的高星 Prompt 工程仓库。这些仓库的价值不在于提供了多少个模板，而在于它们展示了如何将模糊的需求，转化为 AI 可精确执行的“程序”。

本文要解决的，正是帮你完成从“用户”到“工程师”的思维跨越。我们将通过分析这个金矿项目的结构，提炼出一套可复用的 Prompt 设计框架，并辅以代码示例，让你能立刻在 Claude、ChatGPT API 或 LangChain 等开发环境中应用。

2. 基础概念与核心原理：Prompt 不仅仅是“问题”

在深入项目之前，我们必须统一几个关键概念，这是理解后续所有内容的基础。

Prompt（提示词） ： 广义上指任何输入给大语言模型（LLM）的文本，用以引导其生成响应。它可以是一个问题、一段描述、一个命令或一段包含指令的文本。

System Prompt（系统提示词） ： 这是工程化 Prompt 的核心。它通常在对话开始时一次性输入，用于设定 AI 的“身份”、“行为准则”、“知识边界”和“响应格式”。例如，“你是一位资深的 Python 后端开发专家，擅长编写简洁、高效且符合 PEP 8 规范的代码。请用中文回答。” 这个设定会持续影响整个会话。

User Prompt（用户提示词） ： 在系统提示词设定的框架下，用户每次提出的具体问题或请求。

Few-Shot Prompting（少样本提示） ： 在 Prompt 中提供少量输入-输出示例，让 AI 通过类比来理解任务并遵循格式。这是让 AI 完成复杂、格式化任务的利器。

Chain-of-Thought（思维链，CoT） ： 在 Prompt 中鼓励或要求 AI “逐步思考”，将复杂问题分解为多个中间步骤。这能显著提升其在推理、数学和逻辑问题上的表现。

为什么系统提示词如此重要？ 你可以把大语言模型想象成一个拥有海量知识但“人格”空白的超级大脑。系统提示词就是在为这个大脑安装一个“人格面具”和“操作系统”。没有它，AI 会使用默认的、通用的、中立的“人格”来回应你，这往往不是最优的。通过精心设计的系统提示词，你可以将它“定制”成代码专家、创意作家、严格审稿人或思维缜密的顾问。

理解了这些，我们再去看那个 4.4 万星的项目，就会发现它收藏的不仅仅是“问题”，而是一个个精心设计的 “AI 角色定义”和“任务执行程序” 。

3. 环境准备与前置条件

我们的分析不局限于某个特定项目，而是提炼通用方法论。但为了让你有具体的实操感，我们会以 OpenAI GPT 系列模型或 Anthropic Claude 模型为主要对象，并使用 Python 进行示例演示。

你需要准备：

1. 基础环境 ： Python 3.8+ 的运行环境。
2. 关键库 ： OpenAI 官方库 openai 或 Anthropic 官方库 anthropic 。我们将使用 openai 进行演示。
3. API 密钥 ： 一个有效的 OpenAI API 密钥或 Anthropic API 密钥。请妥善保管，不要写入公开代码。
4. 思维准备 ： 一个代码编辑器（如 VS Code）和一种“拆解学习”的心态。

安装依赖：

pip install openai

重要安全提醒 ： 请勿将 API 密钥直接硬编码在脚本中。推荐使用环境变量管理。

# 在终端中设置环境变量（Linux/macOS）
export OPENAI_API_KEY='your-api-key-here'

# 在终端中设置环境变量（Windows PowerShell）
$env:OPENAI_API_KEY='your-api-key-here'

4. 核心流程拆解：顶级 Prompt 的“解剖学”

现在，让我们化身“外科医生”，解剖那个高星项目里一个典型的优秀 Prompt。你会发现，它们通常遵循一个清晰的结构。我们将其归纳为 “角色-任务-约束-示例” 四步法。

4.1 第一步：定义清晰的角色与背景

这是设定 AI “人格面具”的一步。一个好的角色定义能极大限制 AI 的胡言乱语，并激发其在特定领域的知识深度。

平庸的提示 ：“帮我写代码。” 优秀的提示 ：“你是一位拥有10年经验的谷歌首席软件工程师，擅长系统设计和代码评审。你崇尚简洁、可维护和高性能的代码，并对常见的陷阱有深刻理解。”

在代码中，这通常体现在 system 参数中：

system_prompt = """你是一位资深的全栈安全专家，专注于Web应用安全。你熟悉OWASP Top 10，并能从攻击者和防御者双重视角分析问题。你的回答应专业、精准，并优先考虑可行性。"""

4.2 第二步：明确具体的任务与目标

告诉 AI 要做什么，以及成功的标准是什么。任务描述应具体、可衡量。

平庸的提示 ：“分析这段代码。” 优秀的提示 ：“请分析以下Python Flask路由函数，识别其中可能存在的安全漏洞（如SQL注入、XSS、认证绕过等）。对于每个漏洞，请：1) 指出代码行；2) 解释漏洞原理；3) 提供修复后的代码片段。”

4.3 第三步：设定严格的约束与格式

这是控制输出质量的关键。包括格式、长度、风格、禁止事项等。

常见的约束类型 ：

• 格式 ： “请以JSON格式输出，包含 vulnerabilities 数组，每个元素有 line , type , description , fix 字段。”
• 风格 ： “使用中文回答，语言风格需严谨，像技术文档。”
• 边界 ： “不要假设未提供的上下文。如果信息不足，请明确指出。”
• 流程 ： “请先进行概要分析，再逐一详述。”

4.4 第四步：提供少样本示例

对于复杂或格式要求严格的任务，提供1-3个输入输出示例，效果立竿见影。

示例的力量 ：

用户输入示例1: “函数：`def get_user(id): return query(f\"SELECT * FROM users WHERE id={id}\")`”
AI输出示例1: {"vulnerabilities": [{"line": "1", "type": "SQL注入", "description": "使用字符串拼接构造SQL查询，攻击者可控制`id`参数注入恶意SQL。", "fix": "使用参数化查询：`query(\"SELECT * FROM users WHERE id=%s\", (id,))`"}]}

用户输入示例2: ...

AI 会严格模仿示例的输出结构和分析深度。

5. 完整示例与代码实现：构建一个代码审查AI助手

让我们将上述四步法整合，用 Python 和 OpenAI API 构建一个简易的“代码安全审查助手”。

项目目标 ： 创建一个AI助手，能自动分析给定的Python代码片段，识别安全漏洞并以结构化格式报告。

5.1 设计系统提示词（角色+约束）

首先，我们编写一个综合的系统提示词，融合角色、任务框架和约束。

# 文件：security_auditor_system_prompt.txt
"""
你是一个名为“SecAuditAI”的自动化代码安全审计助手。你的核心身份和规则如下：

## 身份与专业性
- 你是专注于Python和Web安全的顶尖专家，精通OWASP Top 10、CWE、以及常见的安全编码规范。
- 你以发现潜在风险、提供切实可行的修复方案为己任。

## 任务流程
1.  接收用户提供的一段Python代码。
2.  逐行分析代码，寻找安全漏洞（如SQL注入、命令注入、路径遍历、XSS、敏感信息泄露、不安全的反序列化、错误的权限校验等）。
3.  对每个发现的漏洞，按以下结构化格式输出：
    - **漏洞类型**： 标准名称。
    - **危险等级**： [高/中/低]。
    - **位置**： 代码行号（如 L5-L7）。
    - **描述**： 简明解释漏洞原理及潜在攻击场景。
    - **修复建议**： 提供具体的、可立即使用的代码修改建议。
4.  如果未发现漏洞，则输出：“本次审计未发现明显安全漏洞。”但仍可提供代码优化建议。

## 输出格式与风格
- **必须**以纯JSON格式输出，方便被其他程序解析。
- JSON根对象包含一个 `audit_report` 字段，其值是一个数组，每个元素是一个漏洞对象。
- 漏洞对象字段：`type`, `level`, `location`, `description`, `fix`。
- 使用中文撰写描述和建议。
- 保持客观、专业，避免使用夸张或恐吓性语言。
- 不讨论与代码安全无关的代码风格或性能问题（除非它们直接导致安全风险）。

## 示例（Few-Shot Learning）
用户输入：
```python
def download_file(request):
    filename = request.GET.get('file')
    with open('/var/www/uploads/' + filename, 'rb') as f:
        return HttpResponse(f.read())

你应输出：

{
  "audit_report": [
    {
      "type": "路径遍历",
      "level": "高",
      "location": "L2-L3",
      "description": "未对用户输入的`filename`进行净化，攻击者可通过输入`../../../etc/passwd`等路径遍历序列，读取服务器上的任意文件。",
      "fix": "使用`os.path.basename()`获取文件名，并拼接至安全的基础目录。或使用白名单验证文件后缀。示例：`safe_filename = os.path.basename(filename); path = os.path.join(BASE_UPLOAD_DIR, safe_filename)`"
    }
  ]
}

"""

### 5.2 编写客户端调用代码

接下来，我们编写 Python 代码来加载这个系统提示词，并与用户代码交互。

```python
# 文件：code_auditor_client.py
import os
import json
from openai import OpenAI
from pathlib import Path

# 初始化客户端，API Key从环境变量读取
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

def load_system_prompt(file_path):
    """加载系统提示词文件"""
    with open(file_path, 'r', encoding='utf-8') as f:
        return f.read().strip()

def audit_code(code_snippet, system_prompt_content):
    """调用AI进行代码审计"""
    try:
        response = client.chat.completions.create(
            model="gpt-4-turbo-preview", # 或使用 "gpt-3.5-turbo"
            messages=[
                {"role": "system", "content": system_prompt_content},
                {"role": "user", "content": f"请审计以下Python代码：\n```python\n{code_snippet}\n```"}
            ],
            temperature=0.1, # 低温度保证输出稳定、确定性高
            response_format={ "type": "json_object" } # 强制JSON输出，仅部分最新模型支持
        )
        # 解析响应
        result = response.choices[0].message.content
        # 尝试解析JSON，如果失败则返回原始文本
        try:
            return json.loads(result)
        except json.JSONDecodeError:
            print("警告：响应不是有效JSON，返回原始文本。")
            return {"raw_response": result}
    except Exception as e:
        return {"error": str(e)}

def main():
    # 1. 加载强大的系统提示词
    system_prompt = load_system_prompt("security_auditor_system_prompt.txt")
    
    # 2. 准备待审计的代码（这里是一个有漏洞的例子）
    vulnerable_code = """
import subprocess
import sys

def run_command(user_input):
    # 模拟一个管理接口
    command = f"ping -c 4 {user_input}"
    result = subprocess.run(command, shell=True, capture_output=True, text=True)
    return result.stdout

if __name__ == "__main__":
    data = sys.argv[1] if len(sys.argv) > 1 else "8.8.8.8"
    print(run_command(data))
    """
    
    # 3. 调用审计函数
    print("正在对代码进行安全审计...\n")
    audit_result = audit_code(vulnerable_code, system_prompt)
    
    # 4. 美化输出结果
    print("审计报告：")
    print(json.dumps(audit_result, indent=2, ensure_ascii=False))

if __name__ == "__main__":
    main()

5.3 扩展：处理非JSON响应和流式输出

上述代码假设模型始终返回完美JSON。现实中，我们需要更强的鲁棒性，并可能使用流式输出以处理长内容。

# 文件：code_auditor_client_advanced.py
import os
import json
import re
from openai import OpenAI

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

def audit_code_robust(code_snippet, system_prompt_content):
    """更健壮的审计函数，包含JSON解析回退和流式处理"""
    try:
        # 使用流式响应，便于处理长内容
        stream = client.chat.completions.create(
            model="gpt-4-turbo-preview",
            messages=[
                {"role": "system", "content": system_prompt_content},
                {"role": "user", "content": f"审计此代码：\n```python\n{code_snippet}\n```\n请务必输出纯JSON。"}
            ],
            temperature=0.1,
            stream=True
        )
        
        collected_content = ""
        print("AI 正在分析...")
        for chunk in stream:
            if chunk.choices[0].delta.content is not None:
                content = chunk.choices[0].delta.content
                print(content, end='', flush=True) # 实时显示
                collected_content += content
        
        # 后处理：尝试从响应中提取JSON
        json_match = re.search(r'\{.*\}', collected_content, re.DOTALL)
        if json_match:
            try:
                return json.loads(json_match.group())
            except json.JSONDecodeError as e:
                print(f"\nJSON解析失败: {e}")
                # 可以尝试更简单的提取或直接返回文本
                return {"error": "JSON解析失败", "raw_text": collected_content[:500]} # 截断部分文本
        else:
            return {"message": "未检测到JSON结构", "response": collected_content[:500]}
            
    except Exception as e:
        return {"error": f"API调用异常: {str(e)}"}

# 使用示例
if __name__ == "__main__":
    system_prompt = """你是一个代码安全审计AI。必须输出JSON，包含`issues`列表。"""
    test_code = "os.system('rm -rf /') # 危险命令"
    result = audit_code_robust(test_code, system_prompt)
    print("\n最终结果:", json.dumps(result, indent=2, ensure_ascii=False))

6. 运行结果与效果验证

运行 code_auditor_client.py ，针对我们提供的危险代码（使用 subprocess.run 并拼接用户输入到 shell 命令），AI 应该会输出一份结构化的审计报告。

预期输出示例 ：

{
  "audit_report": [
    {
      "type": "命令注入",
      "level": "高",
      "location": "L5-L6",
      "description": "代码直接将用户输入`user_input`拼接至shell命令字符串中，未做任何过滤。攻击者可输入如`8.8.8.8; cat /etc/passwd`的命令分隔符，从而执行任意系统命令。",
      "fix": "1. 避免使用`shell=True`。2. 使用参数列表形式调用命令，如`subprocess.run(['ping', '-c', '4', user_input], capture_output=True, text=True)`。3. 对`user_input`进行严格的白名单验证（如仅允许IP地址格式）。"
    },
    {
      "type": "潜在危险模块导入",
      "level": "低",
      "location": "L1-L2",
      "description": "导入了`subprocess`和`sys`模块，需确保其使用方式安全。",
      "fix": "确保所有对`subprocess`的调用都遵循安全实践，避免命令注入。"
    }
  ]
}

如何验证成功？

1. 结构化输出 ： 检查返回结果是否为有效的 JSON，并且包含 audit_report 字段。
2. 问题识别准确 ： AI 是否准确识别了 shell=True 和字符串拼接带来的命令注入风险。
3. 修复建议可行 ： 提供的修复建议（使用参数列表、避免 shell=True ）是否是行业标准的安全实践。
4. 符合约束 ： 描述和修复建议是否使用中文，风格是否专业。

如果运行失败或输出不符合预期，请按以下步骤排查：

1. API 密钥 ： 确认 OPENAI_API_KEY 环境变量已正确设置且有效。
2. 网络与权限 ： 确认网络通畅，API 密钥有足够的余额和权限调用所选模型（如 gpt-4-turbo-preview ）。
3. 提示词格式 ： 检查 system_prompt 内容是否被完整正确地加载，特别是其中的 JSON 示例格式。
4. 模型兼容性 ： response_format 参数可能不被 gpt-3.5-turbo 支持，如果使用该模型，可以移除此参数，依靠提示词中的强约束来引导 JSON 输出。
5. 温度参数 ： temperature 设置为 0.1 有助于输出稳定，如果结果随机性太大，可以尝试调至 0。

7. 常见问题与排查思路

在实践这种工程化 Prompt 模式时，你可能会遇到以下典型问题：

问题现象	可能原因	排查方式	解决方案
AI 不按指定格式（如JSON）输出	1. 系统提示词中格式指令不够强或模糊。 2. 未使用模型支持的 response_format 参数。 3. 温度( temperature )设置过高，导致输出随机。	1. 检查提示词，明确要求“必须输出JSON”。 2. 查阅官方文档，确认模型是否支持 response_format 。 3. 检查 temperature 参数值。	1. 在提示词中提供更清晰的格式示例（Few-Shot）。 2. 使用支持 JSON 模式的模型（如 gpt-4-turbo-preview ）。 3. 将 temperature 调低（如 0.1-0.3）。 4. 在代码中添加后处理，用正则表达式从文本中提取JSON。
AI 忽略了角色设定或任务要求	1. 系统提示词过于冗长，关键指令被淹没。 2. 用户提示词与系统提示词冲突。 3. 上下文过长，模型忘记了开头指令。	1. 精简系统提示词，将核心规则放在最前。 2. 检查用户消息是否无意中覆盖了系统设定。 3. 对于超长对话，尝试在关键节点重复核心指令。	1. 采用“角色-规则-示例”的清晰结构。 2. 避免在用户消息中发出与系统角色矛盾的指令。 3. 对于长会话，定期使用系统消息进行“提醒”。
AI 输出“抱歉，我无法…”或内容空洞	1. 提示词触发了模型的安全或内容过滤机制。 2. 任务描述过于宽泛或抽象。 3. 示例不足，AI不理解具体要做什么。	1. 检查提示词中是否有敏感词或可能被误解为恶意请求的描述。 2. 将抽象任务分解为更具体、可执行的步骤。	1. 用更中性、专业的语言重写提示词。 2. 使用“逐步思考”（Chain-of-Thought）技巧，引导AI拆解问题。 3. 增加更具体的 Few-Shot 示例。
处理长代码或文档时输出不完整	1. 模型有上下文长度限制（Token 数限制）。 2. 提示词本身占用过多 Token。	1. 计算输入 Token 数（可用 tiktoken 库）。 2. 查看模型的最大上下文长度。	1. 压缩提示词，移除冗余信息。 2. 将长输入分段处理，并设计好分段分析的逻辑。 3. 升级到上下文窗口更大的模型。
API 调用速度慢或超时	1. 网络延迟。 2. 模型本身响应慢（如复杂推理）。 3. 请求频率过高。	1. 检查网络连接。 2. 使用流式输出 ( stream=True ) 感知进度。 3. 监控 API 响应时间。	1. 设置合理的超时时间。 2. 对于非实时任务，使用异步调用。 3. 考虑使用更轻量的模型进行简单任务。

8. 最佳实践与工程建议

从“金矿”项目中提炼，并结合实际开发经验，以下是设计和使用工程化 Prompt 的最佳实践：

8.1 提示词设计原则

• 清晰明确优于聪明含蓄 ： AI 不是人，它按字面理解概率。直接说“输出JSON”，不要说“请结构化地呈现结果”。
• 角色扮演要具体 ：“资深工程师”比“专家”好，“有10年Java并发编程经验的架构师”比“资深工程师”更好。
• 任务分解 ： 对于复杂任务，在提示词中明确列出步骤。例如：“第一步，总结需求；第二步，生成大纲；第三步，撰写正文。”
• 负面约束 ： 明确告诉AI“不要”做什么，有时比告诉它“要”做什么更有效。例如：“不要生成Markdown格式以外的任何内容。”“不要对未提供的代码做假设。”
• 迭代优化 ： 没有一个提示词是生来完美的。将其视为代码，进行测试、评审和迭代。记录不同版本的效果。

8.2 代码集成与工程化

• 提示词模板化 ： 不要将提示词硬编码在业务逻辑中。像我们示例一样，将其存储在 .txt 、 .yaml 或 .json 文件中，便于管理和版本控制。
• 参数化 ： 将提示词中的可变部分（如语言、详细程度）参数化。可以使用 Python 的 str.format() 或模板引擎（如 Jinja2）。

  prompt_template = """你是一位{language}技术作家。请用{style}风格写一篇关于{topic}的短文。"""
  filled_prompt = prompt_template.format(language="中文", style="轻松幽默", topic="Python装饰器")
  

• 版本控制 ： 将重要的提示词文件纳入 Git 仓库，像管理源代码一样管理它们的变化。
• 测试与评估 ： 为你的 AI 应用建立测试集，用一批标准输入验证不同提示词版本输出的质量和稳定性。

8.3 安全与成本控制

• 输入净化 ： 如果用户输入会嵌入到你的提示词中，务必进行净化，防止“提示词注入”攻击（用户输入可能篡改你的系统指令）。
• 输出验证 ： 对 AI 的输出（尤其是 JSON、代码）进行格式和内容验证，不要盲目信任。
• 成本监控 ： 提示词越长，调用成本越高。优化提示词，在效果和长度间取得平衡。使用 tiktoken 库估算 Token 消耗。
• 设置限制 ： 在 API 调用时设置 max_tokens 参数，防止因意外生成长篇大论而产生高费用。

8.4 超越单次对话：思维链与智能体

真正的“顶级玩法”不止于此。当单个 Prompt 无法解决复杂问题时，需要组合多个步骤：

• 思维链（CoT） ： 在提示词中加入“让我们一步步思考”或直接要求 AI 先输出推理过程，再给出最终答案。这对于数学、逻辑问题至关重要。
• 智能体（Agent）模式 ： 让 AI 具备使用工具（搜索、计算、执行代码）、记忆和规划的能力。这通常需要框架（如 LangChain、AutoGen）支持，其核心依然是精心设计的系统提示词，来定义智能体的目标、工具使用规则和决策流程。

9. 总结与后续学习方向

通过拆解高星 Prompt 项目，我们完成了一次从“使用者”到“设计者”的思维升级。核心收获在于认识到： 强大的 AI 应用，其差距往往不在模型本身，而在与之对话的“编程”能力——即 Prompt 工程。

我们系统地学习了工程化 Prompt 的“角色-任务-约束-示例”四步法，并通过构建一个代码安全审查助手的完整案例，实践了从设计、编码到调试的全过程。你掌握了如何将模糊需求转化为 AI 可精确执行的指令，并学会了处理输出格式、提升鲁棒性的实用技巧。

下一步，你可以这样行动：

1. 深入研究那个“金矿” ： 去 GitHub 搜索 awesome-chatgpt-prompts ，仔细阅读其中高赞的 Prompt，分析它们的结构，并尝试在自己的项目中复现和修改。
2. 实践复杂任务设计 ： 尝试为你的工作流设计一个 AI 助手，比如：自动化生成数据库迁移文档、将产品需求转化为技术用户故事、审查 API 设计是否符合 RESTful 规范等。
3. 探索框架集成 ： 学习使用 LangChain、LlamaIndex 等框架，它们提供了更高级的模板、记忆管理和工具调用能力，能将你的 Prompt 工程能力放大。
4. 建立你的知识库 ： 将你验证有效的 Prompt 分类保存下来，形成团队或个人的“提示词手册”，这是未来人机协作时代最重要的资产之一。

记住，Prompt 工程是一门实践学科。最好的学习方式就是动手去写，去调试，去观察 AI 的反应，并持续优化。从今天开始，不要再向 AI 随意提问，而是开始为它“编程”。