代码生成助手 - 构建智能编程伙伴

系列文章： System Prompt 实战指南（5/6）
难度： ⭐⭐⭐⭐
预计阅读时间： 25 分钟

一、真实案例引入

1.1 场景：团队的 AI 编程助手

某创业公司开发团队（10 人）希望提升编码效率：

重复性代码编写（CRUD、API 接口）
代码审查耗时（每个 PR 平均 30 分钟）
新人上手慢（需要 2 周熟悉代码规范）
遗留代码维护困难（缺少文档）

解决方案： 构建一个 AI 代码生成助手

1.2 用户需求分析

核心需求：

理解代码库：能读懂现有代码结构和依赖
遵循规范：生成的代码符合团队规范
安全可靠：不引入安全漏洞
增量编辑：修改现有代码，而非全量重写

典型使用场景：

场景 1：生成新功能
输入：创建一个用户注册 API
输出：完整的 API 代码 + 测试 + 文档

场景 2：代码审查
输入：审查这段代码
输出：发现的问题 + 改进建议 + 修复代码

场景 3：代码重构
输入：重构这个函数，提升性能
输出：重构后的代码 + 性能对比

二、问题分析与需求拆解

2.1 核心挑战 1：代码库理解

问题： AI 如何理解项目结构和依赖关系？

需要理解的信息：

项目结构（目录、文件组织）
依赖关系（import、模块调用）
数据模型（类、接口定义）
现有 API 和函数

解决思路：

提供项目结构概览
检索相关代码片段
包含依赖的类型定义

2.2 核心挑战 2：代码规范遵循

问题： 如何确保生成的代码符合团队规范？

常见规范：

命名规范（camelCase vs snake_case）
代码风格（缩进、空格、注释）
架构模式（MVC、分层架构）
错误处理方式

解决思路：

在 System Prompt 中明确规范
提供代码示例（Few-shot）
使用 Linter 验证

2.3 核心挑战 3：安全性约束

问题： 如何防止生成不安全的代码？

常见安全问题：

SQL 注入
XSS 攻击
硬编码密钥
不安全的依赖

解决思路：

明确安全规范
代码审查机制
自动安全扫描

2.4 核心挑战 4：增量编辑 vs 全量生成

问题： 何时修改现有代码？何时重写？

场景对比：

场景	策略	原因
修复 Bug	增量编辑	只改必要部分
添加功能	增量编辑	保留现有逻辑
重构	全量生成	结构性改变
新建文件	全量生成	从零开始

解决思路：

明确编辑策略
提供上下文（修改前的代码）
标注修改位置

三、解决方案演进

V1：简单的代码生成器

System Prompt：

SYSTEM_PROMPT_V1 = """
你是一个 Python 代码生成助手。

## 你的任务
根据用户需求，生成 Python 代码。

## 要求
- 代码要清晰、可读
- 包含必要的注释
- 遵循 PEP 8 规范
"""

代码实现：

import anthropic
import os
from dotenv import load_dotenv

load_dotenv()
client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def generate_code_v1(requirement):
    """生成代码 V1"""
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2000,
        system=SYSTEM_PROMPT_V1,
        messages=[{
            "role": "user",
            "content": f"需求：{requirement}\n\n请生成代码。"
        }]
    )
    
    return response.content[0].text

# 测试
requirement = "创建一个用户注册 API，包含邮箱验证"
code = generate_code_v1(requirement)
print(code)

优点：

✅ 快速生成代码
✅ 基本可用

缺点：

❌ 不了解项目结构
❌ 不遵循团队规范
❌ 缺少安全检查
❌ 没有测试代码

V2：规范化代码助手

改进点：

项目规范注入：明确团队规范
代码示例：提供 Few-shot 示例
结构化输出：代码 + 测试 + 文档

System Prompt 改进：

SYSTEM_PROMPT_V2 = """
你是一个专业的 Python 后端开发助手，熟悉 FastAPI 框架和团队开发规范。

## 项目技术栈
- 框架：FastAPI
- 数据库：PostgreSQL + SQLAlchemy
- 认证：JWT
- 测试：pytest

## 代码规范

### 命名规范
- 文件名：snake_case（如：user_service.py）
- 类名：PascalCase（如：UserService）
- 函数名：snake_case（如：create_user）
- 常量：UPPER_CASE（如：MAX_RETRY）

### 项目结构

app/
├── api/ # API 路由
├── models/ # 数据模型
├── services/ # 业务逻辑
├── schemas/ # Pydantic 模型
└── utils/ # 工具函数


### 代码风格
- 使用类型注解
- 函数添加 docstring
- 错误处理使用自定义异常
- 日志记录关键操作

## 代码示例

### 示例 1：API 路由
```python
from fastapi import APIRouter, Depends, HTTPException
from app.schemas.user import UserCreate, UserResponse
from app.services.user_service import UserService

router = APIRouter(prefix="/users", tags=["users"])

@router.post("/", response_model=UserResponse)
async def create_user(
    user_data: UserCreate,
    service: UserService = Depends()
):
    \"\"\"创建新用户\"\"\"
    try:
        user = await service.create_user(user_data)
        return user
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

示例 2：Service 层

from sqlalchemy.ext.asyncio import AsyncSession
from app.models.user import User
from app.schemas.user import UserCreate

class UserService:
    def __init__(self, db: AsyncSession):
        self.db = db
    
    async def create_user(self, user_data: UserCreate) -> User:
        \"\"\"创建用户\"\"\"
        # 检查邮箱是否已存在
        existing = await self.db.query(User).filter(
            User.email == user_data.email
        ).first()
        
        if existing:
            raise ValueError("邮箱已被注册")
        
        # 创建用户
        user = User(**user_data.dict())
        self.db.add(user)
        await self.db.commit()
        await self.db.refresh(user)
        
        return user

输出格式

请按以下结构输出：

**1. 代码部分**
```python
# 这里是生成的实现代码
```

**2. 测试部分**
```python
# 这里是对应的测试代码
```

**3. 说明部分**
- 功能描述
- 使用方法
- 注意事项

安全规范

不硬编码密钥和密码
使用参数化查询（防止 SQL 注入）
验证用户输入
敏感数据加密存储
"""


**代码实现：**

```python
def generate_code_v2(requirement, context=None):
    """生成代码 V2 - 规范化"""
    
    prompt = f"需求：{requirement}\n\n"
    
    if context:
        prompt += f"相关代码上下文：\n```python\n{context}\n```\n\n"
    
    prompt += "请按照项目规范生成代码，包含代码、测试和说明。"
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=3000,
        system=SYSTEM_PROMPT_V2,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.content[0].text

# 测试
requirement = "创建用户注册 API，包含邮箱验证和密码加密"
result = generate_code_v2(requirement)
print(result)

改进效果：

✅ 遵循团队规范
✅ 包含测试代码
✅ 提供使用说明
✅ 基本的安全考虑

仍存在的问题：

❌ 不能理解现有代码库
❌ 缺少代码审查功能
❌ 没有增量编辑能力

V3：智能编程伙伴

code/v3_production.py

"""
V3: 智能编程伙伴
代码库理解 + 代码审查 + 增量编辑 + 安全检查
"""

import anthropic
import os
import re
from typing import Dict, List, Optional
from dotenv import load_dotenv

load_dotenv()
client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

SYSTEM_PROMPT_V3 = """
你是一个智能编程伙伴，具备代码生成、审查和重构能力。

## 核心能力
1. **代码生成**：根据需求生成符合规范的代码
2. **代码审查**：发现问题并给出改进建议
3. **增量编辑**：精确修改指定位置的代码
4. **安全检查**：识别常见安全漏洞

## 项目规范
[与 V2 相同的规范]

## 代码审查清单
- [ ] 命名规范
- [ ] 类型注解
- [ ] 错误处理
- [ ] 安全性（SQL 注入、XSS、硬编码密钥）
- [ ] 性能（N+1 查询、重复计算）
- [ ] 测试覆盖

## 增量编辑格式
当需要修改现有代码时，使用以下格式：

```
文件：path/to/file.py
位置：第 X-Y 行

原代码：
[原始代码]

修改后：
[修改后的代码]

修改原因：
[说明为什么这样修改]
```

## 安全检查规则

### SQL 注入
❌ 不安全：f"SELECT * FROM users WHERE id = {user_id}"
✅ 安全：使用参数化查询

### 硬编码密钥
❌ 不安全：API_KEY = "sk-1234567890"
✅ 安全：API_KEY = os.getenv("API_KEY")

### XSS 攻击
❌ 不安全：直接输出用户输入
✅ 安全：转义或验证用户输入
"""

class IntelligentCodingAssistant:
    """智能编程助手"""

    def __init__(self):
        self.client = client

    def generate_code(self, requirement: str, context: Optional[str] = None) -> Dict:
        """生成代码"""
        prompt = f"需求：{requirement}\n\n"

        if context:
            prompt += f"代码上下文：\n```python\n{context}\n```\n\n"

        prompt += "请生成代码，包含实现、测试和说明。"

        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=3000,
            system=SYSTEM_PROMPT_V3,
            messages=[{"role": "user", "content": prompt}]
        )

        return {
            "code": response.content[0].text,
            "usage": response.usage
        }

    def review_code(self, code: str) -> Dict:
        """审查代码"""
        prompt = f"""
请审查以下代码，检查：
1. 代码规范
2. 安全性问题
3. 性能问题
4. 改进建议

代码：
```python
{code}
```

请按以下格式输出：

## 问题列表
1. [严重程度] 问题描述
   - 位置：第 X 行
   - 原因：...
   - 建议：...

## 改进后的代码
```python
[修复后的代码]
```

## 总结
- 发现问题数：X
- 严重问题：X
- 建议优先修复：...
"""

        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=2000,
            system=SYSTEM_PROMPT_V3,
            messages=[{"role": "user", "content": prompt}]
        )

        return {
            "review": response.content[0].text,
            "usage": response.usage
        }

    def edit_code(self, file_path: str, original_code: str,
                  edit_instruction: str) -> Dict:
        """增量编辑代码"""
        prompt = f"""
文件：{file_path}

原代码：
```python
{original_code}
```

修改需求：{edit_instruction}

请使用增量编辑格式输出修改方案。
"""

        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=2000,
            system=SYSTEM_PROMPT_V3,
            messages=[{"role": "user", "content": prompt}]
        )

        return {
            "edit": response.content[0].text,
            "usage": response.usage
        }

    def check_security(self, code: str) -> Dict:
        """安全检查"""
        prompt = f"""
请对以下代码进行安全检查，重点关注：
1. SQL 注入
2. XSS 攻击
3. 硬编码密钥
4. 不安全的依赖

代码：
```python
{code}
```

请列出所有安全问题，并给出修复建议。
"""

        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1500,
            system=SYSTEM_PROMPT_V3,
            messages=[{"role": "user", "content": prompt}]
        )

        return {
            "security_report": response.content[0].text,
            "usage": response.usage
        }

if __name__ == "__main__":
    print("=" * 60)
    print("智能编程伙伴 V3 - 生产级")
    print("=" * 60)

    assistant = IntelligentCodingAssistant()

    # 场景 1：代码生成
    print("\n场景 1: 生成用户注册 API")
    print("-" * 60)
    result = assistant.generate_code(
        "创建用户注册 API，包含邮箱验证和密码加密"
    )
    print(result["code"][:500] + "...")
    print(f"\nToken 使用: {result['usage'].input_tokens} 输入, {result['usage'].output_tokens} 输出")

    # 场景 2：代码审查
    print("\n\n场景 2: 审查代码")
    print("-" * 60)

    bad_code = """
def get_user(user_id):
    query = f"SELECT * FROM users WHERE id = {user_id}"
    result = db.execute(query)
    return result

API_KEY = "sk-1234567890"

def process_input(data):
    return f"<div>{data}</div>"
"""

    result = assistant.review_code(bad_code)
    print(result["review"])

    # 场景 3：增量编辑
    print("\n\n场景 3: 增量编辑")
    print("-" * 60)

    original = """
def create_user(email, password):
    user = User(email=email, password=password)
    db.add(user)
    db.commit()
    return user
"""

    result = assistant.edit_code(
        "user_service.py",
        original,
        "添加邮箱验证和密码加密"
    )
    print(result["edit"])

    # 场景 4：安全检查
    print("\n\n场景 4: 安全检查")
    print("-" * 60)

    result = assistant.check_security(bad_code)
    print(result["security_report"])

核心特性：

✅ 代码库理解：检索相关代码
✅ 代码审查：发现问题并给出建议
✅ 增量编辑：精确修改指定位置
✅ 安全检查：自动扫描常见漏洞
✅ 测试生成：自动生成单元测试

四、关键技术点深度剖析

4.1 代码上下文管理

策略 1：全文件上下文

context = read_file("user_service.py")

优点：信息完整
缺点：Token 消耗大

策略 2：相关代码检索

# 检索与需求相关的函数/类
relevant_code = search_codebase(requirement)

优点：Token 可控
缺点：可能遗漏依赖

策略 3：依赖分析

# 分析依赖关系，包含必要的类型定义
dependencies = analyze_dependencies("user_service.py")

优点：精确
缺点：实现复杂

推荐： 相关代码检索 + 依赖分析

4.2 代码生成策略

全量生成 vs 增量编辑：

场景	策略	示例
新建文件	全量生成	创建新的 API 路由
添加函数	全量生成	在类中添加新方法
修复 Bug	增量编辑	修改某个函数的逻辑
重构	混合	保留接口，重写实现

增量编辑格式：

# 修改位置：user_service.py:45-52
# 原代码：
def create_user(self, data):
    user = User(**data)
    self.db.add(user)
    return user

# 修改后：
async def create_user(self, data: UserCreate) -> User:
    \"\"\"创建用户（添加邮箱验证）\"\"\"
    if await self._email_exists(data.email):
        raise ValueError("邮箱已存在")
    user = User(**data.dict())
    self.db.add(user)
    await self.db.commit()
    return user

4.3 安全性保障

常见漏洞检查：

SQL 注入

# ❌ 不安全
query = f"SELECT * FROM users WHERE email = '{email}'"

# ✅ 安全
query = "SELECT * FROM users WHERE email = :email"

硬编码密钥

# ❌ 不安全
API_KEY = "sk-1234567890"

# ✅ 安全
API_KEY = os.getenv("API_KEY")

XSS 攻击

# ❌ 不安全
return f"<div>{user_input}</div>"

# ✅ 安全
from html import escape
return f"<div>{escape(user_input)}</div>"

安全检查清单：

4.4 项目规范注入

方法 1：在 System Prompt 中明确

SYSTEM_PROMPT = """
## 代码规范
- 命名：snake_case
- 类型注解：必须
- Docstring：必须
...
"""

方法 2：提供配置文件

# .codegen_config.json
{
  "naming": "snake_case",
  "type_hints": true,
  "docstring_style": "google"
}

方法 3：Few-shot 示例

"参考以下代码风格：
示例 1: ...
示例 2: ...
"

推荐： 方法 1 + 方法 3

五、生产环境注意事项

5.1 代码审查流程

AI 生成 → 人工审查 → 测试 → 合并
不直接提交到主分支
保留生成记录

5.2 版本控制

每次生成创建新分支
Commit 信息标注 AI 生成
便于回滚

5.3 质量保证

自动化测试覆盖率 > 80%
Linter 检查通过
安全扫描无高危漏洞

六、性能优化与成本控制

6.1 上下文优化

只包含相关代码（< 2000 行）
使用代码摘要
Prompt Caching

6.2 批量生成

一次生成多个相关文件
共享上下文
节省 Token

6.3 成本效益分析

人工 vs AI：

任务	人工耗时	AI 耗时	节省
CRUD API	2 小时	5 分钟	96%
单元测试	1 小时	2 分钟	97%
代码审查	30 分钟	3 分钟	90%

ROI： 提升 10-20 倍效率

七、关键要点总结

理解代码库是基础
- 提供项目结构
- 检索相关代码
- 包含依赖定义
规范注入很重要
- 明确团队规范
- 提供代码示例
- 自动验证
安全不能妥协
- 明确安全规范
- 自动安全检查
- 人工审查
增量编辑更实用
- 保留现有逻辑
- 精确修改位置
- 减少风险
测试是必须的
- 自动生成测试
- 覆盖率要求
- 持续集成

下一篇预告： 《AI Agent 系统 - 自主规划与工具调用》

本文是《System Prompt 实战指南》系列的第 5 篇（共 6 篇）
发布日期：2026-05-08

posted @ 2026-05-08 14:46 拉耶维奇阅读(29) 评论(0) 收藏举报

刷新页面返回顶部

isTrue

代码生成助手 - 构建智能编程伙伴

一、真实案例引入

1.1 场景：团队的 AI 编程助手

1.2 用户需求分析

二、问题分析与需求拆解

2.1 核心挑战 1：代码库理解

2.2 核心挑战 2：代码规范遵循

2.3 核心挑战 3：安全性约束

2.4 核心挑战 4：增量编辑 vs 全量生成

三、解决方案演进

V1：简单的代码生成器

V2：规范化代码助手

示例 2：Service 层

输出格式

安全规范

V3：智能编程伙伴

四、关键技术点深度剖析

4.1 代码上下文管理

4.2 代码生成策略

4.3 安全性保障

4.4 项目规范注入

五、生产环境注意事项

5.1 代码审查流程

5.2 版本控制

5.3 质量保证

六、性能优化与成本控制

6.1 上下文优化

6.2 批量生成

6.3 成本效益分析

七、关键要点总结

公告