企业官网建设流程全解析

简介：本资源是一份面向AI初学者与提示工程实践者的GPT提示词系统性工具集，聚焦日常办公、学习写作、内容创作及技术开发等高频场景，解决用户面对大模型时“不知如何提问”的核心痛点。文档为单个160KB的Word文件（.docx），结构清晰、即开即用，涵盖常用指令、发散思维训练、专业写作辅助、故事生成、文本分析、SEO优化、编程支持等25大类共300+条可直接调用的提示模板，如论文式回答、周报生成器、Midjourney提示生成、代码释义器、情绪分析、FAQs生成等，兼顾实用性与延展性。内容预览显示其目录层级分明，每类下设细分功能（如“写作辅助”含Nature风格润色、小红书文案、口播稿等，“IT/编程”覆盖Vue3、微信小程序、SQL终端等），便于按需检索与快速迁移。目前已有223人下载学习，适合希望提升AI交互效率、构建个人提示词库或开展教学示范的用户直接落地使用。

1. 为什么你抄了100条“GPT提示词大全”，却连一句像样的代码注释都生成不出来？

你下载过《GPT 提示词大全 -基础版.docx》，打开后满屏“请用专业术语解释”“请分点作答”“请以JSON格式输出”——看着很全，用起来全废。不是模型不响应，就是输出跑题、漏逻辑、硬凑字数；更常见的是：你照着文档里“写一个Python函数计算斐波那契数列”的提示词发过去，GPT回你一段带语法错误的伪代码，还自信满满加了三行中文注释。这不是模型的问题，是提示词没经过工程化验证：它没对齐你的真实输入边界（比如你传的是带缩进的旧代码片段）、没约束输出结构（比如你只要docstring不要函数体）、更没做最小可行性闭环测试（比如不验证返回是否能被ast.parse()安全加载）。这份.docx本质是“提示词快照集”，不是“可执行提示词资产”。它适合当检索索引、灵感弹药库，但不能直接喂给生产脚本。本文只讲一件事：如何把这份.docx里的原始提示词，转化成你在VS Code里按Ctrl+Enter就能稳定调用、在CI流水线里能断言校验、在团队知识库中能版本化管理的提示词模块。不讲大模型原理，不画思维导图，只拆解从Word文档到可运行.py文件的5个硬核步骤——每一步都有命令、参数、失败日志和血泪经验。

2. 把.docx提示词转成结构化数据：用python-docx提取+正则清洗，不是复制粘贴

一份合格的提示词资产，必须能被程序读取、校验、组合、注入。而.docx是二进制容器，直接双击打开=人工阅读，无法自动化。我们必须把它变成.json或.yaml——但别急着写爬虫，先解决最痛的点：格式污染。你打开《GPT 提示词大全 -基础版.docx》，会发现标题混着编号（“1.1 基础指令”）、段落夹着空行、示例代码块裹着中文引号“”、甚至有手打的换行符↵。这些在Word里看不见，一转成纯文本就炸开。我试过用pandoc直转Markdown，结果所有代码块缩进错乱，JSON示例里的双引号全变成中文全角，导致后续json.loads()直接报JSONDecodeError。

2.1 用python-docx精准定位提示词区块，跳过页眉页脚和说明文字

我们不追求100%还原排版，只抓核心内容：每个提示词的角色定义（Role）、任务描述（Task）、输入约束（Input）、输出要求（Output）、示例（Example）。.docx里这些通常用不同样式区分（如“标题1”是分类名，“强调”是示例代码）。python-docx能读样式，比正则暴力匹配可靠得多：

from docx import Document import re def extract_prompts_from_docx(docx_path): doc = Document(docx_path) prompts = [] current_prompt = {"role": "", "task": "", "input": "", "output": "", "example": ""} for para in doc.paragraphs: text = para.text.strip() if not text: continue # 检测分类标题（如“一、编程类提示词”），重置当前prompt if re.match(r'^[一二三四五六七八九十]+、', text) or re.match(r'^\d+\.', text): if current_prompt["task"]: # 保存上一个完整prompt prompts.append(current_prompt.copy()) current_prompt = {"role": "", "task": "", "input": "", "output": "", "example": ""} continue # 根据样式判断字段类型（需提前在Word中统一设置样式名） style_name = para.style.name if "Role" in style_name: current_prompt["role"] = clean_text(text) elif "Task" in style_name: current_prompt["task"] = clean_text(text) elif "Input" in style_name: current_prompt["input"] = clean_text(text) elif "Output" in style_name: current_prompt["output"] = clean_text(text) elif "Example" in style_name: current_prompt["example"] = clean_text(text) # 保存最后一个 if current_prompt["task"]: prompts.append(current_prompt) return prompts def clean_text(text): # 移除Word自动插入的软回车、全角标点、多余空格 text = re.sub(r'[\u3000\u2000-\u200F\u2028\u2029]+', ' ', text) # 全角空格等 text = re.sub(r'[“”‘’]', '"', text) # 中文引号转英文 text = re.sub(r'\s+', ' ', text).strip() # 多空格变单空格 return text

提示：这段代码依赖你在Word中提前为不同字段设置样式名（如“PromptRole”“PromptTask”）。别嫌麻烦——这是避免正则误杀的关键。如果文档没设样式，就用para.style.font.bold或para.style.font.size等属性做粗筛，但准确率会掉20%。我试过，最后还是手动补了17处。

2.2 用正则修复典型污染：中文引号、全角数字、隐藏控制符

即使用了样式筛选，.docx导出的文本仍有顽固污染。最常翻车的是这三类：

把这些修复逻辑塞进clean_text()函数里，再跑一遍。我拿《基础版.docx》实测：原始213条提示词，清洗后剩198条有效条目，15条因格式混乱（如示例代码跨多段、无明确字段标记）被丢弃——宁可少，不可错。

2.3 导出为JSON Schema校验的结构化文件，带版本和来源标记

清洗完的数据不能直接当配置用。要加两层防护：一是用JSON Schema强制字段存在性，二是加元数据方便追溯。建一个prompt_schema.json：

{ "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "properties": { "id": {"type": "string"}, "source_file": {"type": "string"}, "version": {"type": "string"}, "role": {"type": "string", "minLength": 1}, "task": {"type": "string", "minLength": 1}, "input": {"type": "string"}, "output": {"type": "string", "minLength": 1}, "example": {"type": "string"} }, "required": ["id", "source_file", "version", "role", "task", "output"] }

导出脚本：

import json import uuid from datetime import datetime def save_prompts_as_json(prompts, output_path): structured = [] for i, p in enumerate(prompts): # 生成唯一ID（非UUID，用语义ID便于调试） prompt_id = f"base_{i+1:03d}_{p['role'].lower().replace(' ', '_')[:8]}" structured.append({ "id": prompt_id, "source_file": "GPT 提示词大全 -基础版.docx", "version": "20240520", # 文档修改日期 "role": p["role"], "task": p["task"], "input": p.get("input", ""), "output": p["output"], "example": p.get("example", "") }) with open(output_path, 'w', encoding='utf-8') as f: json.dump(structured, f, ensure_ascii=False, indent=2) # 验证Schema import jsonschema from jsonschema import validate with open("prompt_schema.json") as schema_f: schema = json.load(schema_f) try: validate(instance=structured, schema=schema) print(f"✅ {len(structured)}条提示词通过Schema校验") except jsonschema.exceptions.ValidationError as e: print(f"❌ Schema校验失败：{e.message}") # 调用 prompts = extract_prompts_from_docx("GPT 提示词大全 -基础版.docx") save_prompts_as_json(prompts, "prompts_base.json")

运行后得到prompts_base.json——这才是能进Git仓库、能被CI检查、能被其他服务引用的提示词资产。下一步，让它活起来。

3. 用Jinja2模板引擎组装提示词：动态注入变量，告别硬编码字符串拼接

拿到prompts_base.json，你以为就能直接requests.post()发给API？错。真实场景中，你的提示词永远需要动态变量：用户提交的代码片段、数据库表结构、当前时间、甚至上一轮对话的摘要。硬编码f"请分析以下代码：{code}"有三大缺陷：1）变量未转义，SQL注入式风险（如code="xxx"; DROP TABLE users;）；2）长度失控，超模型上下文窗口；3）无法复用同一提示词模板处理不同输入。解决方案：Jinja2模板——它专为安全、可控、可继承的文本组装而生。

3.1 把JSON提示词转成Jinja2模板文件，保留原始语义

别在Python里用str.format()拼接。把每条提示词存为独立.j2文件，路径按role/task组织。例如prompts/programming/fibonacci.j2：

{% set role = "Python开发工程师" %} {% set task = "为用户提供高效、无错误的斐波那契数列计算函数" %} {% set input_constraints = "输入n为正整数，且n ≤ 1000" %} {% set output_requirements = "返回标准Python函数，包含完整类型注解、Google风格docstring，并附带单元测试用例" %} 你是一名{{ role }}。{{ task }}。 【输入约束】 {{ input_constraints }} 【输出要求】 {{ output_requirements }} 【示例输入】 n = 10 【示例输出】 ```python def fibonacci(n: int) -> int: """计算第n项斐波那契数。 Args: n: 正整数，表示要计算的项数 Returns: 第n项斐波那契数 Raises: ValueError: 当n小于1时抛出 """ if n < 1: raise ValueError("n must be positive integer") if n == 1 or n == 2: return 1 a, b = 1, 1 for _ in range(3, n + 1): a, b = b, a + b return b # 单元测试 assert fibonacci(1) == 1 assert fibonacci(10) == 55

注意三点：1）用`{% set %}`预定义变量，保持模板干净；2）示例用```python```包裹，明确代码块边界；3）所有用户变量（如`n`）必须在`【示例输入】`中标明，这是后续自动化测试的锚点。 ### 3.2 编写安全渲染器：自动转义、长度截断、上下文感知 直接`template.render(n=10)`不安全。必须加中间层： ```python from jinja2 import Environment, FileSystemLoader import re class SafePromptRenderer: def __init__(self, templates_dir="prompts"): self.env = Environment(loader=FileSystemLoader(templates_dir)) # 注册过滤器 self.env.filters['truncate_code'] = self._truncate_code self.env.filters['escape_sql'] = self._escape_sql def _truncate_code(self, code: str, max_lines: int = 50) -> str: """安全截断代码，保留语法完整性""" lines = code.split('\n') if len(lines) <= max_lines: return code # 截断到max_lines，但确保不切断多行字符串或注释 truncated = '\n'.join(lines[:max_lines]) # 补全未闭合的引号/括号（简化版） if truncated.count('"') % 2 != 0: truncated += '"' return truncated def _escape_sql(self, text: str) -> str: """基础SQL转义（防注入）""" return text.replace("'", "''").replace('"', '""') def render(self, template_path: str, **kwargs) -> str: """主渲染方法，带安全防护""" try: template = self.env.get_template(template_path) # 对所有字符串参数做基础清理 safe_kwargs = {} for k, v in kwargs.items(): if isinstance(v, str): # 移除控制字符，限制长度 cleaned = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', v) safe_kwargs[k] = cleaned[:5000] # 硬截断防OOM else: safe_kwargs[k] = v rendered = template.render(**safe_kwargs) # 最终校验：确保代码块语法正确（用ast试探） if '```python' in rendered: code_block = self._extract_python_code(rendered) if code_block and not self._is_valid_python(code_block): raise ValueError("渲染后Python代码语法错误") return rendered except Exception as e: raise RuntimeError(f"渲染模板{template_path}失败：{e}") def _extract_python_code(self, text: str) -> str: """从渲染文本中提取第一个```python```块""" match = re.search(r'```python\s*([\s\S]*?)\s*```', text) return match.group(1) if match else "" def _is_valid_python(self, code: str) -> bool: """用ast验证Python语法（轻量级）""" try: import ast ast.parse(code) return True except SyntaxError: return False # 使用示例 renderer = SafePromptRenderer() prompt = renderer.render("programming/fibonacci.j2", n=10) print(prompt)

注意：这个渲染器做了四重防护——变量长度硬截断、控制字符清除、代码语法校验、SQL基础转义。它不保证100%防攻击（真要防得严，得上AST重写），但能拦住95%的低级翻车。

3.3 模板继承与组合：用父模板统一角色设定，子模板专注任务

《基础版.docx》里大量提示词重复“你是一名资深Python工程师”。与其每条都写，不如用Jinja2继承：

prompts/base/role_engineer.j2（父模板）：

{% set role = "资深Python工程师" %} {% set expertise = "精通Python 3.8+、PEP 8、类型系统、性能优化" %} {% set constraints = "输出必须严格遵循Google Docstring规范，代码必须通过mypy --strict校验" %} 你是一名{{ role }}，{{ expertise }}。请严格遵守以下约束： {{ constraints }} {% block content %}{% endblock %}

prompts/programming/fibonacci.j2（子模板）：

{% extends "base/role_engineer.j2" %} {% block content %} 【任务】 {{ task }} 【输入】 {{ input }} 【输出】 {{ output }} 【示例】 {{ example }} {% endblock %}

这样，改角色设定只需动父模板，所有子模板自动同步。我在团队落地时，把role_engineer.j2设为公司级标准，新来的实习生写提示词，只要继承它，就天然符合代码规范——省去80%的Code Review。

4. 在VS Code中一键调用：用Python插件封装提示词，Ctrl+Enter即执行

有了结构化JSON和Jinja2模板，下一步是让开发者零学习成本使用。不能指望大家记python render.py --template programming/fibonacci.j2 --n 10。最佳实践：集成到VS Code编辑器中，选中代码→右键→“用GPT分析”→自动填充提示词→发送API→插入结果。这需要写一个VS Code Python插件。

4.1 创建最小可行插件：prompt-runner，只做三件事

VS Code插件本质是Node.js写的，但我们用Python后端处理核心逻辑。架构分三层：

• 前端（TypeScript）：VS Code侧，监听右键菜单、获取选中文本、调用命令
• 通信层（HTTP）：前端通过fetch调用本地Python服务
• 后端（Python FastAPI）：接收请求、渲染模板、调用GPT API、返回结果

先写后端（backend/main.py）：

from fastapi import FastAPI, HTTPException, Body from pydantic import BaseModel import os from safe_renderer import SafePromptRenderer # 上节写的渲染器 app = FastAPI() # 初始化渲染器（全局单例，避免重复加载模板） renderer = SafePromptRenderer(templates_dir=os.path.join(os.path.dirname(__file__), "../prompts")) class PromptRequest(BaseModel): template_path: str variables: dict = {} @app.post("/render") async def render_prompt(req: PromptRequest): try: # 渲染提示词 prompt = renderer.render(req.template_path, **req.variables) # 调用GPT（此处用mock，实际替换为openai.ChatCompletion.create） # 为演示，返回固定响应 gpt_response = f"✅ 已根据模板 `{req.template_path}` 生成响应。\n\n```python\nprint('Hello from GPT!')\n```\n\n> 提示词长度：{len(prompt)} 字符" return {"prompt": prompt, "response": gpt_response} except Exception as e: raise HTTPException(status_code=400, detail=str(e)) # 启动命令：uvicorn backend.main:app --reload --port 8000

启动后端：uvicorn backend.main:app --reload --port 8000

4.2 VS Code前端：用Webview注入Python服务调用

在VS Code插件extension.ts中：

import * as vscode from 'vscode'; export function activate(context: vscode.ExtensionContext) { let disposable = vscode.commands.registerCommand('prompt-runner.run', async () => { const editor = vscode.window.activeTextEditor; if (!editor) return; // 获取选中文本 const selection = editor.selection; const selectedText = editor.document.getText(selection); // 构造请求 const payload = { template_path: "programming/fibonacci.j2", variables: { n: parseInt(selectedText) || 10 } }; try { // 调用本地Python服务 const response = await fetch('http://localhost:8000/render', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) }); const data = await response.json(); if (response.ok) { // 插入结果到编辑器 await editor.edit(editBuilder => { editBuilder.insert( editor.selection.end, `\n\n<!-- GPT分析结果 -->\n${data.response}\n` ); }); } else { vscode.window.showErrorMessage(`GPT调用失败：${data.detail}`); } } catch (err) { vscode.window.showErrorMessage(`连接本地服务失败：${err}`); } }); context.subscriptions.push(disposable); }

package.json中注册命令：

"contributes": { "commands": [{ "command": "prompt-runner.run", "title": "用GPT分析选中内容" }], "menus": { "editor/context": [{ "when": "editorTextFocus", "command": "prompt-runner.run", "group": "navigation" }] } }

安装插件后，在Python文件中选中数字10，右键→“用GPT分析选中内容”，立刻在光标后插入渲染结果。整个流程无需离开编辑器，不记命令，不切终端。

4.3 配置GPT API密钥与模型选择：环境变量+VS Code设置面板

硬编码API Key是反模式。用VS Code的settings.json管理：

// .vscode/settings.json { "prompt-runner.apiKey": "${env:OPENAI_API_KEY}", "prompt-runner.model": "gpt-4-turbo", "prompt-runner.maxTokens": 2048 }

后端读取：

import os from fastapi import Depends def get_api_key(): key = os.getenv("OPENAI_API_KEY") or os.getenv("OPENAI_API_KEY_VSCODE") if not key: raise HTTPException(status_code=400, detail="Missing OPENAI_API_KEY") return key

这样，团队成员只需在自己机器上设环境变量，或在VS Code设置里填Key，就能用——密钥不进Git，不进插件包，完全隔离。

5. 避坑指南：从.docx到VS Code插件，我踩过的5个血泪坑

把提示词从Word文档变成可执行资产，表面是技术流程，实则是认知重构。以下是我在三个项目中反复验证的5个高频翻车点，每一条都配真实日志和后悔药：

5.1 坑：Word样式名不一致导致提取失败，日志显示KeyError: 'StyleName'

现象：extract_prompts_from_docx()运行时报KeyError: 'StyleName'，但你在Word里明明看到标题用了“标题1”样式。
原因：Word中“标题1”样式名实际是Heading 1（英文），而中文版Word界面显示“标题1”是翻译名。python-docx读取的是底层样式名，不是界面名。
解决：用doc.styles打印所有样式名：

for style in doc.styles: print(f"'{style.name}' -> {style.type}") # 找到真正的'Heading 1'

然后在代码中用para.style.name == "Heading 1"而非"标题1"。血泪经验：第一次我花3小时手动改了200+段落样式，第二次直接用脚本批量修正样式名。

5.2 坑：Jinja2模板中{{ n }}被GPT当成变量名，生成def fibonacci(n: int) -> int:后又补一句“n是输入参数”

现象：渲染出的提示词里，n既在代码中出现，又在自然语言描述中被重复解释，导致GPT输出冗余。
原因：模板里写了【输入】n为正整数，而n又是变量名，GPT混淆了“占位符”和“概念”。
解决：在模板中用{{ input_var }}代替裸n，并在调用时传{"input_var": "n"}：

【输入】 {{ input_var }}为正整数，且{{ input_var }} ≤ 1000

这样GPT看到的是“param_name为正整数”，不会和代码中的n耦合。玄学结论：GPT对符号的语义绑定极强，变量名必须和上下文解耦。

5.3 坑：VS Code插件调用Python服务超时，报fetch failed: TypeError: Failed to fetch

现象：右键菜单点了没反应，DevTools Network标签页显示Failed to fetch。
原因：VS Code插件默认不允许跨域请求，而fetch('http://localhost:8000')被浏览器策略拦截。
解决：在FastAPI后端加CORS中间件：

from fastapi.middleware.cors import CORSMiddleware app.add_middleware( CORSMiddleware, allow_origins=["*"], # 开发期允许所有源 allow_credentials=True, allow_methods=["*"], allow_headers=["*"], )

注意：生产环境必须限制allow_origins为VS Code插件ID，不能用*。

5.4 坑：GPT返回的代码块含中文注释，ast.parse()校验失败报SyntaxError: Non-UTF-8 code starting with '\xe4'

现象：_is_valid_python()校验失败，但代码明明能运行。
原因：GPT生成的中文注释用了GBK编码，而Python 3默认UTF-8，ast.parse()拒绝解析。
解决：不在校验阶段处理编码，改为在渲染后、发送前做编码标准化：

def normalize_encoding(text: str) -> str: # 强制转UTF-8，中文注释也能parse return text.encode('utf-8', errors='ignore').decode('utf-8')

然后在校验前调用它。后悔药：别在ast.parse()前做复杂清洗，先保底转UTF-8。

5.5 坑：.docx里示例代码用Tab缩进，转成JSON后变成\\t，Jinja2渲染时Tab被转义成空格

现象：渲染出的代码块缩进全乱，if和else不对齐。
原因：python-docx读取段落时，para.text会把Tab转成空格；而Jinja2默认开启autoescape，\\t被当字符串渲染。
解决：在模板中用{% raw %}包裹代码块，或关闭该段落的转义：

{% autoescape false %} ```python def fib(n): if n < 1: return 0

{% endautoescape %}

**关键点**：代码块必须`autoescape false`，否则`<` `>`会被转成`&lt;` `&gt;`，彻底报废。 --- ## 6. 进阶技巧：用Git Hooks自动校验提示词质量，把“好提示词”变成团队红线 提示词资产一旦进Git，就必须有质量门禁。不能靠人Review，要靠机器卡点。我在线上项目中落地了一套**Git Pre-Commit Hook + 自动化评分**方案，把“提示词好不好”变成`git commit`时的红绿灯。 ### 6.1 定义可量化的提示词质量指标（不是主观感受） 好提示词不是“写得漂亮”，而是**可预测、可验证、可维护**。我们定义4个硬指标，全部可脚本化： | 指标 | 计算方式 | 合格线 | 为什么重要 | |--------|------------|----------|----------------| | **结构完整性** | `len(prompt["role"]) > 0 and len(prompt["task"]) > 0 and len(prompt["output"]) > 0` | ✅ 必须满足 | 缺任一字段，GPT易自由发挥 | | **示例有效性** | `prompt["example"]`中是否含```代码块，且代码块能`ast.parse()` | ✅ 必须满足 | 示例是GPT的锚点，无效示例=无效提示 | | **长度健康度** | `len(prompt["task"]) < 200 and len(prompt["output"]) < 150` | ⚠️ 警告（非阻断） | 过长任务描述易让GPT抓不住重点 | | **变量安全性** | 模板文件中`{{.*?}}`出现次数 ≤ 5，且无`{{ request.* }}`等危险变量 | ✅ 必须满足 | 变量过多=失控，`request`类变量可能泄露上下文 | ### 6.2 编写Pre-Commit Hook脚本：`check_prompts.py` ```python #!/usr/bin/env python3 import json import sys import re import ast from pathlib import Path def check_prompt_quality(prompt_file: Path): with open(prompt_file) as f: prompts = json.load(f) errors = [] warnings = [] for i, p in enumerate(prompts): # 结构完整性 if not (p.get("role") and p.get("task") and p.get("output")): errors.append(f"第{i+1}条：缺少role/task/output字段") # 示例有效性 example = p.get("example", "") code_match = re.search(r'```python\s*([\s\S]*?)\s*```', example) if code_match: try: ast.parse(code_match.group(1)) except SyntaxError as e: errors.append(f"第{i+1}条：示例代码语法错误 - {e}") # 长度健康度 if len(p.get("task", "")) > 200: warnings.append(f"第{i+1}条：task过长({len(p['task'])}字符)") if len(p.get("output", "")) > 150: warnings.append(f"第{i+1}条：output过长({len(p['output'])}字符)") # 模板变量安全（扫描.j2文件） template_path = Path("prompts") / f"{p['id'].split('_')[0]}/{p['id'].split('_')[1]}.j2" if template_path.exists(): with open(template_path) as t: content = t.read() var_count = len(re.findall(r'\{\{.*?\}\}', content)) if var_count > 5: errors.append(f"第{i+1}条：模板变量过多({var_count}个)") if re.search(r'\{\{ *request\.', content): errors.append(f"第{i+1}条：模板含危险变量`{{ request.`") return errors, warnings def main(): # 检查所有prompts/*.json prompt_files = list(Path(".").glob("prompts/*.json")) all_errors = [] all_warnings = [] for f in prompt_files: errors, warnings = check_prompt_quality(f) all_errors.extend([f"{f.name}: {e}" for e in errors]) all_warnings.extend([f"{f.name}: {w}" for w in warnings]) if all_errors: print("❌ 提示词质量检查失败：") for e in all_errors: print(f" • {e}") sys.exit(1) if all_warnings: print("⚠️ 提示词质量警告：") for w in all_warnings: print(f" • {w}") print("✅ 提示词质量检查通过") if __name__ == "__main__": main()

6.3 集成到Git Hooks：commit前自动运行

在项目根目录建.githooks/pre-commit：

#!/bin/bash echo "🔍 正在检查提示词质量..." python check_prompts.py if [ $? -ne 0 ]; then echo "💥 提示词质量不达标，commit被拒绝" exit 1 fi

然后启用Hook：

git config core.hooksPath .githooks

现在，任何人git add prompts_base.json && git commit，都会先跑质量检查。错误直接阻断commit，警告会打印但不阻断——既保底线，又不卡脖子。

6.4 进阶：用GitHub Actions做CI级校验，失败自动Comment

把check_prompts.py放进CI流程，.github/workflows/prompt-check.yml：

name: Prompt Quality Check on: [pull_request] jobs: check: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Set up Python uses: actions/setup-python@v4 with: python-version: '3.11' - name: Run prompt quality check run: python check_prompts.py - name: Comment on PR if warnings if: always() && contains(steps.check.outcome, 'warning') uses: unsplash/comment-on-pr@1.3.0 with: msg: "⚠️ 提示词质量警告：${{ steps.check.outputs.warnings }}" github_token: ${{ secrets.GITHUB_TOKEN }}

这样，PR提交时，GitHub自动跑检查，失败就Comment提醒——提示词质量从此不是口头约定，而是代码级契约。

我坚持这套流程两年，团队提示词复用率从32%升到89%，GPT生成代码一次通过率从41%升到76%。最深的体会是：提示词工程不是写文案，是写接口；不是雕琢句子，是设计契约。那份《GPT 提示词大全 -基础版.docx》不是终点，是你构建提示词工厂的第一块砖。希望帮到你。

本文还有配套的精品资源，点击获取