AI 辅助编程提效 — 让 AI 真正帮你写好代码
#AI编程 · #CursorRules · #CodeReview · #Harness · #提效 · #编码规范 · #MCP · #自动化
AI 编码助手不是"自动写代码机器"，而是"结对编程搭档"。本专题覆盖如何配置 AI 编码环境、编写高质量的 Rules/Instructions、集成到 CI/CD 流程、以及利用 AI 进行代码审查和质量保障。
AI 编码助手全景
mermaid
graph TD
subgraph "AI 编码助手分类"
A1["补全型<br/>GitHub Copilot<br/>Codeium<br/>TabNine"] --> USE["日常编码"]
A2["对话型<br/>Cursor<br/>Windsurf<br/>Trae"] --> USE2["复杂任务<br/>重构/调试/设计"]
A3["Agent 型<br/>Devin<br/>OpenHands<br/>SWE-Agent"] --> USE3["自主完成任务<br/>Issue → PR"]
end
style A2 fill:#e74c3c,color:#fff
style A3 fill:#2ecc71,color:#fff| 工具 | 类型 | 核心能力 | 适用场景 | 局限 |
|---|---|---|---|---|
| GitHub Copilot | 补全 | 行级/块级代码补全 | 日常编码加速 | 上下文有限 |
| Cursor | 对话+Agent | 全项目理解、多文件编辑 | 复杂重构、新功能开发 | 需要好的 Rules |
| Windsurf | 对话+Agent | 类似 Cursor，Cascade 模式 | 全栈开发 | 生态较新 |
| Claude Code | CLI Agent | 终端内自主编码 | 服务端/CI 集成 | 无 GUI |
| Devin/OpenHands | 全自主 Agent | 从 Issue 到 PR 全自动 | 简单 Bug 修复 | 复杂任务成功率低 |
Cursor Rules — AI 编码的"宪法"
什么是 Cursor Rules？
Cursor Rules 是写给 AI 编码助手的行为规范文件，告诉 AI：
- 项目使用什么技术栈和架构
- 代码风格和命名规范
- 哪些模式应该遵循，哪些应该避免
- 项目特有的约定和限制
mermaid
graph LR
RULES["📋 .cursorrules<br/>项目级规范"] --> AI["🤖 AI 助手"]
CONTEXT["📁 项目代码<br/>上下文"] --> AI
USER["👤 用户指令"] --> AI
AI --> CODE["✅ 符合规范的代码"]
style RULES fill:#e74c3c,color:#fff
style CODE fill:#2ecc71,color:#fff.cursorrules 模板设计
markdown
# 项目规范
## 技术栈
- 语言: Go 1.22+ / TypeScript 5.x
- 框架: Gin (HTTP) / GORM (ORM) / Vue 3 (前端)
- 数据库: MySQL 8.0 + Redis 7.x
- 部署: Docker + Kubernetes
## 代码风格
### Go 代码规范
- 所有导出函数必须有 GoDoc 注释
- 错误处理: 使用 `fmt.Errorf("xxx: %w", err)` 包装错误，保留错误链
- 禁止使用 `panic`，除非是程序初始化阶段
- 并发: 优先使用 channel，其次 sync.Mutex，禁止裸 goroutine（必须有 recover）
- 命名: 接口用动词（Reader, Writer），结构体用名词（UserService）
- 测试: 表驱动测试，测试函数命名 `TestXxx_场景描述`
### TypeScript 代码规范
- 使用 `const` 优先，避免 `let`，禁止 `var`
- 类型: 优先使用 `interface`，复杂联合类型用 `type`
- 异步: 统一使用 `async/await`，禁止裸 `.then()` 链
- 组件: Vue 3 Composition API + `<script setup>` 语法
## 架构约定
### 目录结构cmd/ # 入口 internal/ # 内部包（不对外暴露） handler/ # HTTP 处理器 service/ # 业务逻辑 repository/ # 数据访问 model/ # 数据模型 pkg/ # 可复用的公共包
### 分层规则
- Handler 层: 只做参数校验和响应格式化，不含业务逻辑
- Service 层: 核心业务逻辑，可调用多个 Repository
- Repository 层: 纯数据访问，不含业务判断
- 禁止跨层调用（Handler 不能直接调 Repository）
## 安全规范
- 所有用户输入必须校验（长度、格式、范围）
- SQL 必须使用参数化查询，禁止字符串拼接
- 敏感信息（密码、token）禁止出现在日志中
- API 必须有鉴权，内部接口也要验证来源
## 错误处理
- 业务错误使用自定义错误码（不是 HTTP 状态码）
- 错误响应格式统一:
```json
{"code": 10001, "message": "用户不存在", "request_id": "xxx"}禁止事项
- 禁止在代码中硬编码配置（IP、端口、密钥）
- 禁止使用
time.Sleep做同步等待 - 禁止忽略错误（
_ = someFunc()） - 禁止在循环中做数据库查询（N+1 问题）
- 禁止使用
interface{}/any除非确实需要泛型
### 分层 Rules 设计
```mermaid
graph TD
subgraph "Rules 层级"
G["🌐 全局 Rules<br/>~/.cursor/rules<br/>所有项目通用"] --> P["📁 项目 Rules<br/>.cursorrules<br/>项目级规范"]
P --> D["📂 目录 Rules<br/>.cursorrules (子目录)<br/>模块级规范"]
end
style G fill:#3498db,color:#fff
style P fill:#e74c3c,color:#fff
style D fill:#2ecc71,color:#fff全局 Rules 示例（适用于所有项目）：
markdown
# 全局编码规范
## 通用原则
- 代码必须能直接运行，不要留 TODO 或占位符
- 修改代码时保持最小变更原则，不要重构不相关的部分
- 添加必要的导入语句和依赖
- 错误处理必须完备
## 输出规范
- 解释要简洁，重点在代码本身
- 如果修改涉及多个文件，说明修改顺序和依赖关系
- 对于复杂逻辑，在关键位置添加注释
## 安全红线
- 永远不要输出真实的密钥、token、密码
- 不要删除或修改 .gitignore、.env 等配置文件
- 不要执行破坏性操作（rm -rf、DROP TABLE 等）AI Code Review — 自动化代码审查
为什么需要 AI Code Review？
mermaid
graph LR
PR["📝 Pull Request"] --> AI_REVIEW["🤖 AI 审查<br/>- 安全漏洞<br/>- 性能问题<br/>- 代码规范<br/>- 逻辑错误"]
AI_REVIEW --> HUMAN["👤 人工审查<br/>- 架构合理性<br/>- 业务逻辑<br/>- 设计决策"]
HUMAN --> MERGE["✅ 合并"]
style AI_REVIEW fill:#3498db,color:#fff
style HUMAN fill:#2ecc71,color:#fffAI Code Review 实现
python
"""
AI Code Review 自动化框架
集成到 CI/CD 流程，对每个 PR 自动进行代码审查。
"""
import json
from dataclasses import dataclass, field
from typing import List, Dict, Optional
from enum import Enum
class Severity(Enum):
"""问题严重程度"""
CRITICAL = "critical" # 必须修复（安全漏洞、数据丢失风险）
WARNING = "warning" # 建议修复（性能问题、代码异味）
INFO = "info" # 建议改进（风格、可读性）
@dataclass
class ReviewComment:
"""审查意见"""
file: str # 文件路径
line: int # 行号
severity: Severity # 严重程度
category: str # 分类（security/performance/style/logic）
message: str # 问题描述
suggestion: str = "" # 修复建议
code_snippet: str = "" # 建议的代码片段
@dataclass
class ReviewResult:
"""审查结果"""
comments: List[ReviewComment] = field(default_factory=list)
summary: str = ""
pass_review: bool = True # 是否通过审查
stats: Dict[str, int] = field(default_factory=dict)
class AICodeReviewer:
"""AI 代码审查器"""
# 审查维度和对应的 Prompt
REVIEW_DIMENSIONS = {
"security": """检查以下代码的安全问题：
- SQL 注入、XSS、SSRF、命令注入
- 敏感信息泄露（硬编码密钥、日志中的密码）
- 权限校验缺失
- 不安全的反序列化""",
"performance": """检查以下代码的性能问题：
- N+1 查询问题
- 不必要的内存分配
- 缺少索引提示
- 锁粒度过大
- 循环中的重复计算""",
"logic": """检查以下代码的逻辑问题：
- 边界条件未处理（空值、零值、溢出）
- 并发安全问题（竞态条件、死锁）
- 资源泄漏（未关闭的连接、文件句柄）
- 错误处理不完整""",
"style": """检查以下代码的风格问题：
- 命名不规范
- 函数过长（>50行）
- 嵌套过深（>3层）
- 缺少必要注释
- 魔法数字""",
}
def __init__(self, llm_client, project_rules: str = ""):
self.llm = llm_client
self.project_rules = project_rules
async def review_diff(self, diff: str, context: str = "") -> ReviewResult:
"""
审查代码差异
Args:
diff: git diff 格式的代码变更
context: 额外上下文（PR 描述、相关文件等）
"""
result = ReviewResult()
# 对每个维度进行审查
for dimension, prompt_template in self.REVIEW_DIMENSIONS.items():
comments = await self._review_dimension(
diff, dimension, prompt_template, context
)
result.comments.extend(comments)
# 统计
result.stats = {
"critical": sum(1 for c in result.comments if c.severity == Severity.CRITICAL),
"warning": sum(1 for c in result.comments if c.severity == Severity.WARNING),
"info": sum(1 for c in result.comments if c.severity == Severity.INFO),
}
# 判断是否通过
result.pass_review = result.stats["critical"] == 0
result.summary = self._generate_summary(result)
return result
async def _review_dimension(
self, diff: str, dimension: str, prompt: str, context: str
) -> List[ReviewComment]:
"""对单个维度进行审查"""
system_prompt = f"""你是一个资深代码审查专家。
## 项目规范
{self.project_rules}
## 审查维度: {dimension}
{prompt}
## 输出格式
输出 JSON 数组，每个元素包含：
- file: 文件路径
- line: 行号
- severity: "critical" | "warning" | "info"
- message: 问题描述（简洁明确）
- suggestion: 修复建议
如果没有发现问题，输出空数组 []。
只报告真正的问题，不要过度报告。"""
user_prompt = f"""## 代码变更
```diff
{diff}{f"## 额外上下文\n{context}" if context else ""}
请审查上述代码变更，输出 JSON 格式的审查意见。"""
response = await self.llm.chat(system_prompt, user_prompt)
# 解析 JSON 响应
try:
comments_data = json.loads(response)
return [
ReviewComment(
file=c.get("file", ""),
line=c.get("line", 0),
severity=Severity(c.get("severity", "info")),
category=dimension,
message=c.get("message", ""),
suggestion=c.get("suggestion", ""),
)
for c in comments_data
]
except (json.JSONDecodeError, KeyError):
return []
def _generate_summary(self, result: ReviewResult) -> str:
"""生成审查摘要"""
if result.pass_review and not result.comments:
return "代码审查通过，未发现问题。"
lines = []
if result.stats["critical"] > 0:
lines.append(f"发现 {result.stats['critical']} 个严重问题（必须修复）")
if result.stats["warning"] > 0:
lines.append(f"发现 {result.stats['warning']} 个警告（建议修复）")
if result.stats["info"] > 0:
lines.append(f"发现 {result.stats['info']} 个建议（可选改进）")
status = "未通过" if not result.pass_review else "通过（有建议）"
return f"审查结果: {status}。" + "；".join(lines)
========== CI/CD 集成示例 ==========
async def ci_review_hook(pr_diff: str, pr_description: str): """ CI/CD 中的 AI Code Review Hook
在 PR 创建/更新时自动触发，结果以评论形式回写到 PR。
"""
reviewer = AICodeReviewer(
llm_client=None, # 替换为实际的 LLM 客户端
project_rules=open(".cursorrules").read(),
)
result = await reviewer.review_diff(pr_diff, pr_description)
# 格式化为 Markdown 评论
comment = format_review_comment(result)
# 回写到 PR（GitLab/GitHub API）
# post_pr_comment(pr_id, comment)
# 如果有 critical 问题，阻止合并
if not result.pass_review:
# set_pr_status("failed", "AI Code Review 发现严重问题")
pass
return result
def format_review_comment(result: ReviewResult) -> str: """将审查结果格式化为 Markdown""" lines = [f"## AI Code Review\n\n{result.summary}\n"]
if result.comments:
lines.append("### 详细问题\n")
for c in sorted(result.comments, key=lambda x: x.severity.value):
icon = {"critical": "🔴", "warning": "🟡", "info": "🔵"}[c.severity.value]
lines.append(f"{icon} **[{c.category}]** `{c.file}:{c.line}`")
lines.append(f" {c.message}")
if c.suggestion:
lines.append(f" > 建议: {c.suggestion}")
lines.append("")
return "\n".join(lines)
---
## Harness 集成 — AI 驱动的代码质量门禁
### 什么是 Harness？
Harness 是一套**代码质量自动化检查框架**，集成了静态分析、安全扫描、架构检查、API 测试等多个维度。AI 可以增强 Harness 的能力：
```mermaid
graph TD
subgraph "Harness 检查流水线"
S1["Step 1: 语法检查<br/>php -l / eslint"] --> S2["Step 2: 品味规则<br/>21 条 Analyzer"]
S2 --> S3["Step 3: 配置同步<br/>环境一致性"]
S3 --> S4["Step 4: 架构检查<br/>分层/依赖"]
S4 --> S5["Step 5: API 测试<br/>接口自动化"]
S5 --> S6["Step 6: 变更影响<br/>影响范围分析"]
S6 --> S7["Step 7: 覆盖率<br/>API 覆盖率"]
S7 --> S8["Step 8: 快照<br/>API 快照对比"]
end
subgraph "AI 增强"
AI1["🤖 AI 辅助修复<br/>自动生成修复代码"] --> S2
AI2["🤖 AI 影响分析<br/>智能判断影响范围"] --> S6
AI3["🤖 AI 测试生成<br/>自动生成测试用例"] --> S5
end
style S2 fill:#e74c3c,color:#fff
style S5 fill:#3498db,color:#fffAI 增强的品味规则（Taste Lint）
python
"""
AI 增强的代码品味分析器
传统 Lint 只能检查固定模式，AI 可以理解语义：
- 检测"逻辑上的代码异味"（不只是格式问题）
- 检测跨函数的安全问题（污点追踪）
- 给出上下文相关的修复建议
"""
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
class AnalyzerCategory(Enum):
"""分析器分类"""
SECURITY = "security" # 安全类
PERFORMANCE = "performance" # 性能类
STYLE = "style" # 风格类
LOGIC = "logic" # 逻辑类
ARCHITECTURE = "architecture" # 架构类
@dataclass
class LintIssue:
"""Lint 问题"""
file: str
line: int
column: int = 0
rule: str = ""
message: str = ""
severity: str = "error" # error | warning
fix: Optional[str] = None # 自动修复代码
class AIEnhancedAnalyzer:
"""AI 增强的代码分析器"""
def __init__(self, llm_client=None):
self.llm = llm_client
self.rules = self._load_rules()
def _load_rules(self) -> List[dict]:
"""加载品味规则"""
return [
# 安全类
{"id": "sql-inject", "category": "security",
"description": "SQL 注入检测（支持跨函数污点追踪）"},
{"id": "xss-detect", "category": "security",
"description": "XSS 跨站脚本检测"},
{"id": "ssrf-detect", "category": "security",
"description": "SSRF 服务端请求伪造检测"},
{"id": "sensitive-leak", "category": "security",
"description": "敏感信息泄露检测（密钥、token、密码）"},
# 性能类
{"id": "n-plus-one", "category": "performance",
"description": "N+1 查询问题检测"},
{"id": "unnecessary-alloc", "category": "performance",
"description": "不必要的内存分配"},
{"id": "lock-contention", "category": "performance",
"description": "锁竞争和粒度问题"},
# 逻辑类
{"id": "null-deref", "category": "logic",
"description": "空指针/空值解引用"},
{"id": "resource-leak", "category": "logic",
"description": "资源泄漏（未关闭的连接/文件）"},
{"id": "dead-code", "category": "logic",
"description": "死代码检测"},
{"id": "complexity", "category": "logic",
"description": "圈复杂度过高（>15）"},
# 风格类
{"id": "naming-convention", "category": "style",
"description": "命名规范检查"},
{"id": "function-length", "category": "style",
"description": "函数长度检查（>50行警告）"},
{"id": "nesting-depth", "category": "style",
"description": "嵌套深度检查（>3层警告）"},
{"id": "magic-number", "category": "style",
"description": "魔法数字检测"},
{"id": "assert-strength", "category": "style",
"description": "断言强度检查（测试中）"},
# 架构类
{"id": "layer-violation", "category": "architecture",
"description": "分层架构违规（跨层调用）"},
{"id": "circular-dep", "category": "architecture",
"description": "循环依赖检测"},
{"id": "god-class", "category": "architecture",
"description": "上帝类检测（职责过多）"},
{"id": "interface-segregation", "category": "architecture",
"description": "接口隔离原则违反"},
]
async def analyze_with_ai(self, code: str, file_path: str,
context: str = "") -> List[LintIssue]:
"""
使用 AI 进行深度代码分析
传统 Lint 无法检测的问题：
- 业务逻辑错误
- 跨函数的数据流问题
- 上下文相关的安全问题
"""
prompt = f"""分析以下代码，找出潜在问题。
## 检查规则
{json.dumps([r["description"] for r in self.rules], ensure_ascii=False)}
## 代码
文件: {file_path}
{f"## 上下文\n{context}" if context else ""}
## 输出格式
JSON 数组，每个元素：
{{"line": 行号, "rule": "规则ID", "message": "问题描述", "severity": "error|warning", "fix": "修复建议代码（可选）"}}
只报告确定的问题，不要过度报告。如果没有问题，输出 []。"""
response = await self.llm.chat("你是代码质量分析专家。", prompt)
try:
issues_data = json.loads(response)
return [
LintIssue(
file=file_path,
line=i.get("line", 0),
rule=i.get("rule", "ai-detect"),
message=i.get("message", ""),
severity=i.get("severity", "warning"),
fix=i.get("fix"),
)
for i in issues_data
]
except json.JSONDecodeError:
return []
# ========== 增量检查集成 ==========
class IncrementalChecker:
"""
增量检查器 — 只检查变更的代码
支持两种基线模式：
1. 固定基线 (--since-tag): 用于 CI/发版前
2. 滑动基线 (last_clean_commit): 用于日常开发
"""
def __init__(self, config_path: str = ".harness-config.json"):
self.config = self._load_config(config_path)
self.analyzer = AIEnhancedAnalyzer()
def _load_config(self, path: str) -> dict:
"""加载配置"""
try:
with open(path) as f:
return json.load(f)
except FileNotFoundError:
return {"last_clean_commit": None, "since_tag": None}
def get_changed_files(self) -> List[str]:
"""获取自基线以来变更的文件"""
import subprocess
baseline = self.config.get("last_clean_commit") or "HEAD~1"
result = subprocess.run(
["git", "diff", "--name-only", baseline, "HEAD"],
capture_output=True, text=True
)
return [f for f in result.stdout.strip().split("\n") if f]
async def check_incremental(self) -> dict:
"""增量检查"""
changed_files = self.get_changed_files()
all_issues = []
for file_path in changed_files:
if not file_path.endswith((".py", ".go", ".php", ".ts", ".js")):
continue
try:
with open(file_path) as f:
code = f.read()
issues = await self.analyzer.analyze_with_ai(code, file_path)
all_issues.extend(issues)
except FileNotFoundError:
continue
# 如果没有 error 级别问题，更新滑动基线
has_errors = any(i.severity == "error" for i in all_issues)
if not has_errors:
self._update_baseline()
return {
"files_checked": len(changed_files),
"issues": all_issues,
"passed": not has_errors,
}
def _update_baseline(self):
"""更新滑动基线"""
import subprocess
result = subprocess.run(
["git", "rev-parse", "HEAD"],
capture_output=True, text=True
)
self.config["last_clean_commit"] = result.stdout.strip()
with open(".harness-config.json", "w") as f:
json.dump(self.config, f, indent=2)MCP (Model Context Protocol) — AI 工具标准化
MCP 协议概述
MCP 是 Anthropic 提出的开放协议，让 AI 助手能够标准化地连接外部工具和数据源：
mermaid
graph TD
subgraph "MCP 架构"
CLIENT["AI 客户端<br/>(Cursor/Claude)"] <-->|"MCP 协议<br/>JSON-RPC"| SERVER["MCP Server<br/>(工具提供者)"]
end
subgraph "MCP Server 能力"
SERVER --> T1["Tools<br/>可调用的工具"]
SERVER --> T2["Resources<br/>可读取的资源"]
SERVER --> T3["Prompts<br/>预定义的提示模板"]
end
subgraph "实际工具"
T1 --> TOOL1["Git 操作"]
T1 --> TOOL2["数据库查询"]
T1 --> TOOL3["文件系统"]
T1 --> TOOL4["API 调用"]
T2 --> RES1["项目文档"]
T2 --> RES2["配置文件"]
end
style CLIENT fill:#9b59b6,color:#fff
style SERVER fill:#2ecc71,color:#fff实现一个 MCP Server
python
"""
MCP Server 实现示例 — 项目知识库检索工具
让 AI 助手能够检索项目文档、代码注释、API 定义等。
"""
import json
import asyncio
from typing import Any, Dict, List
class MCPServer:
"""MCP Server 基础框架"""
def __init__(self, name: str, version: str = "1.0.0"):
self.name = name
self.version = version
self.tools: Dict[str, dict] = {}
self.resources: Dict[str, dict] = {}
def tool(self, name: str, description: str, parameters: dict):
"""注册工具的装饰器"""
def decorator(func):
self.tools[name] = {
"name": name,
"description": description,
"inputSchema": {
"type": "object",
"properties": parameters,
},
"handler": func,
}
return func
return decorator
async def handle_request(self, method: str, params: dict) -> dict:
"""处理 MCP 请求"""
if method == "initialize":
return self._handle_initialize()
elif method == "tools/list":
return self._handle_tools_list()
elif method == "tools/call":
return await self._handle_tool_call(params)
elif method == "resources/list":
return self._handle_resources_list()
else:
return {"error": f"Unknown method: {method}"}
def _handle_initialize(self) -> dict:
return {
"protocolVersion": "2024-11-05",
"capabilities": {
"tools": {"listChanged": True},
"resources": {"subscribe": True},
},
"serverInfo": {
"name": self.name,
"version": self.version,
},
}
def _handle_tools_list(self) -> dict:
return {
"tools": [
{
"name": t["name"],
"description": t["description"],
"inputSchema": t["inputSchema"],
}
for t in self.tools.values()
]
}
async def _handle_tool_call(self, params: dict) -> dict:
tool_name = params.get("name")
arguments = params.get("arguments", {})
if tool_name not in self.tools:
return {"error": f"Tool not found: {tool_name}"}
handler = self.tools[tool_name]["handler"]
try:
result = await handler(**arguments)
return {"content": [{"type": "text", "text": str(result)}]}
except Exception as e:
return {"error": str(e)}
def _handle_resources_list(self) -> dict:
return {"resources": list(self.resources.values())}
# ========== 项目知识库 MCP Server ==========
server = MCPServer("project-knowledge", "1.0.0")
@server.tool(
name="search_codebase",
description="在项目代码库中搜索代码片段、函数定义、类定义等",
parameters={
"query": {
"type": "string",
"description": "搜索关键词或正则表达式",
},
"file_pattern": {
"type": "string",
"description": "文件名模式（如 *.go, *.py）",
},
},
)
async def search_codebase(query: str, file_pattern: str = "*") -> str:
"""搜索代码库"""
import subprocess
result = subprocess.run(
["rg", "--json", "-g", file_pattern, query, "."],
capture_output=True, text=True, cwd="/path/to/project"
)
# 解析 ripgrep JSON 输出
matches = []
for line in result.stdout.strip().split("\n"):
if not line:
continue
try:
data = json.loads(line)
if data.get("type") == "match":
match_data = data["data"]
matches.append({
"file": match_data["path"]["text"],
"line": match_data["line_number"],
"content": match_data["lines"]["text"].strip(),
})
except json.JSONDecodeError:
continue
return json.dumps(matches[:20], ensure_ascii=False, indent=2)
@server.tool(
name="get_api_docs",
description="获取项目 API 文档，包括接口定义、参数说明、返回值格式",
parameters={
"endpoint": {
"type": "string",
"description": "API 路径（如 /api/users）或关键词",
},
},
)
async def get_api_docs(endpoint: str) -> str:
"""获取 API 文档"""
# 从 OpenAPI/Swagger 文件中检索
# 实际实现会解析 swagger.json 或 openapi.yaml
return f"API 文档: {endpoint} (示例实现)"
@server.tool(
name="get_architecture_info",
description="获取项目架构信息，包括模块划分、依赖关系、技术栈",
parameters={
"module": {
"type": "string",
"description": "模块名称（如 auth, payment, user）",
},
},
)
async def get_architecture_info(module: str = "") -> str:
"""获取架构信息"""
# 从架构文档或代码结构中提取
return f"架构信息: {module} (示例实现)"MCP 配置（Cursor/Claude Desktop）
json
{
"mcpServers": {
"project-knowledge": {
"command": "python",
"args": ["/path/to/mcp_server.py"],
"env": {
"PROJECT_ROOT": "/path/to/project"
}
},
"git-operations": {
"command": "npx",
"args": ["-y", "@anthropic/mcp-server-git"],
"env": {
"GIT_REPO": "/path/to/repo"
}
},
"database": {
"command": "npx",
"args": ["-y", "@anthropic/mcp-server-sqlite"],
"env": {
"DB_PATH": "/path/to/dev.db"
}
}
}
}AI 编码最佳实践
高效使用 AI 的工作流
mermaid
graph TD
subgraph "日常开发流程"
T1["1. 明确需求<br/>写清楚要做什么"] --> T2["2. 提供上下文<br/>相关代码/文档"]
T2 --> T3["3. AI 生成初版<br/>快速得到框架"]
T3 --> T4["4. 人工审查<br/>检查逻辑/安全"]
T4 --> T5["5. 迭代优化<br/>指出问题让 AI 修"]
T5 --> T6["6. 测试验证<br/>确保功能正确"]
end
subgraph "AI 擅长的任务"
G1["✅ 样板代码生成"]
G2["✅ 单元测试编写"]
G3["✅ 代码重构"]
G4["✅ 文档生成"]
G5["✅ Bug 定位"]
end
subgraph "AI 不擅长的任务"
B1["❌ 架构设计决策"]
B2["❌ 业务逻辑判断"]
B3["❌ 性能调优（需要 profiling）"]
B4["❌ 安全审计（需要专业知识）"]
end
style T3 fill:#2ecc71,color:#fff
style T4 fill:#e74c3c,color:#fffPrompt 技巧 — 让 AI 写出更好的代码
| 技巧 | 说明 | 示例 |
|---|---|---|
| 给出上下文 | 告诉 AI 项目背景和约束 | "这是一个高并发的支付系统，QPS 约 5000" |
| 指定风格 | 明确代码风格要求 | "按照 Google Go Style Guide 编写" |
| 给出示例 | 展示期望的代码风格 | "参考这个函数的写法：..." |
| 分步骤 | 复杂任务拆解为小步 | "先设计接口，再实现，最后写测试" |
| 要求解释 | 让 AI 解释关键决策 | "解释为什么选择这个数据结构" |
| 否定约束 | 明确不要什么 | "不要使用第三方库，只用标准库" |
| 要求测试 | 同时生成测试代码 | "同时写单元测试，覆盖边界情况" |
常见陷阱与应对
| 陷阱 | 表现 | 应对 |
|---|---|---|
| 幻觉 API | AI 编造不存在的函数/库 | 要求 AI 只用你指定的依赖 |
| 过度工程 | 简单问题用复杂设计模式 | 明确说"用最简单的方式实现" |
| 忽略错误处理 | 只写 happy path | 明确要求"处理所有错误路径" |
| 安全漏洞 | 生成有注入风险的代码 | 在 Rules 中强调安全规范 |
| 过时信息 | 使用已废弃的 API | 指定版本号和文档链接 |
| 上下文丢失 | 长对话后忘记之前的约定 | 关键约定写在 Rules 文件中 |
自动化测试生成
AI 生成单元测试
python
"""
AI 驱动的测试生成器
给定一个函数，自动生成覆盖各种边界情况的测试用例。
"""
TEST_GEN_PROMPT = """## 角色
你是一个测试工程师，擅长编写高质量的单元测试。
## 规则
1. 使用表驱动测试（Table-Driven Tests）
2. 覆盖以下场景：
- 正常输入（Happy Path）
- 边界值（空值、零值、最大值、最小值）
- 异常输入（非法类型、超长字符串、特殊字符）
- 并发安全（如果函数涉及共享状态）
3. 断言必须检查返回值，不能只检查"不报错"
4. 测试函数命名: Test{函数名}_{场景描述}
## 待测函数
```{language}
{code}输出
直接输出完整的测试代码，包含所有 import。 """
class TestGenerator: """AI 测试生成器"""
def __init__(self, llm_client):
self.llm = llm_client
async def generate_tests(self, code: str, language: str = "go") -> str:
"""为给定代码生成单元测试"""
prompt = TEST_GEN_PROMPT.format(language=language, code=code)
return await self.llm.chat(
"你是测试工程师，只输出代码，不要额外解释。",
prompt
)
async def generate_integration_tests(
self, api_spec: str, base_url: str
) -> str:
"""为 API 生成集成测试"""
prompt = f"""根据以下 API 定义，生成完整的集成测试。
API 定义
测试要求
- 测试所有接口的正常和异常路径
- 测试接口间的依赖关系（如：先注册再登录）
- 测试并发安全性
- 使用 {base_url} 作为基础 URL
- 每个测试独立，不依赖执行顺序
输出完整的测试代码。""" return await self.llm.chat("你是 API 测试专家。", prompt)
---
## 总结 — AI 编码提效的核心原则
```mermaid
mindmap
root((AI 编码提效))
规范先行
.cursorrules 项目规范
全局 Rules 通用约定
分层 Rules 模块级
工具集成
MCP 协议标准化
CI/CD 自动审查
Harness 质量门禁
高效协作
明确上下文
分步骤任务
迭代优化
质量保障
AI Code Review
自动测试生成
回归测试
持续改进
收集 AI 错误模式
更新 Rules
扩充测试集| 维度 | 关键行动 | 预期收益 |
|---|---|---|
| 规范 | 编写完善的 .cursorrules | AI 输出质量提升 50%+ |
| 审查 | 集成 AI Code Review 到 CI | 减少 30% 的人工审查时间 |
| 测试 | AI 自动生成测试用例 | 测试覆盖率提升 2-3x |
| 知识 | MCP Server 接入项目知识库 | AI 理解项目上下文，减少幻觉 |
| 迭代 | 持续更新 Rules 和测试集 | AI 输出质量持续提升 |
核心理念：AI 是放大器，不是替代品。好的规范 + 好的工具 + 好的流程 = AI 真正帮你写好代码。
登录后即可发表评论 👇