上周用 Claude 赶一个数据处理的需求，结果生成的代码跑一半就报错，改了三版还是有问题。我一度怀疑是不是模型退化了，直到发现是我的配置方式有问题。

AI 写代码老是出 bug 的核心原因是：大部分人用的都是默认配置，没有针对编程场景做优化。 调整 5 个关键配置后，我的代码一次通过率从 60% 提升到了 90% 以上。

下面是我实测有效的完整配置方案。

配置 1：把 temperature 降到 0.2

temperature 控制输出的随机性，默认 1.0 适合写文章，但写代码需要确定性。我测了一周，0.2 是最佳值：

import openai

client = openai.OpenAI(
    base_url="https://api.ofox.ai/v1",
    api_key="sk-xxx"
)

response = client.chat.completions.create(
    model="claude-opus-4-6",
    messages=[
        {"role": "user", "content": "写一个快速排序"}
    ],
    temperature=0.2,  # 关键：降低随机性
    max_tokens=8000
)

print(response.choices[0].message.content)

实测对比（同一个需求跑 10 次）：
- temperature=1.0：每次生成的代码结构都不一样，有 3 次出现逻辑错误
- temperature=0.2：10 次生成的代码几乎一致，全部可运行

踩坑记录：temperature 设成 0 会导致输出过于死板，遇到开放性问题反而效果差。0.2 是平衡点。

配置 2：max_tokens 至少设 8000

默认 4096 tokens 对于复杂函数来说根本不够。我之前让 AI 写一个带异常处理的 API 调用函数，结果代码写到一半就截断了，后半部分直接没了。

response = client.chat.completions.create(
    model="claude-opus-4-6",
    messages=messages,
    temperature=0.2,
    max_tokens=8000,  # 给足输出空间
    stream=True  # 流式输出，实时看到生成过程
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

经验值：
- 简单函数（<50 行）：4096 够用
- 复杂逻辑（50-200 行）：8000
- 完整模块（200+ 行）：16000 或分批生成

配置 3：写一个专用的 system prompt

这个是提升最明显的配置。我给 AI 加了一个编程规范的 system prompt 后，生成的代码风格立刻统一了。

SYSTEM_PROMPT = """
你是一个 Python 专家，遵循以下规范：
1. 使用类型注解（typing）
2. 函数必须有 docstring
3. 异常处理用 try-except，不要裸 except
4. 变量命名用 snake_case
5. 优先使用标准库，避免引入不必要的依赖
6. 代码必须包含边界条件检查
"""

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": "写一个读取 JSON 文件的函数"}
]

response = client.chat.completions.create(
    model="claude-opus-4-6",
    messages=messages,
    temperature=0.2,
    max_tokens=8000
)

加了 system prompt 后生成的代码：

import json
from typing import Dict, Any
from pathlib import Path

def read_json_file(file_path: str) -> Dict[str, Any]:
    """
    读取 JSON 文件并返回字典

    Args:
        file_path: JSON 文件路径

    Returns:
        解析后的字典对象

    Raises:
        FileNotFoundError: 文件不存在
        json.JSONDecodeError: JSON 格式错误
    """
    path = Path(file_path)

    if not path.exists():
        raise FileNotFoundError(f"文件不存在: {file_path}")

    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        raise json.JSONDecodeError(
            f"JSON 格式错误: {e.msg}",
            e.doc,
            e.pos
        )

看到没，类型注解、docstring、异常处理全都有了，这才是能直接用的代码。

配置 4：只发送相关代码到 context

我之前犯过一个错误：把整个项目的代码都塞进 context，结果 AI 生成的代码风格乱七八糟，还引用了一些不存在的函数。

后来我改成只发送相关的代码片段：

def get_relevant_context(task: str, codebase: dict) -> str:
    """
    根据任务提取相关代码
    """
    # 简化版：实际项目中可以用向量检索
    relevant_files = []

    keywords = task.lower().split()

    for file_path, content in codebase.items():
        if any(keyword in content.lower() for keyword in keywords):
            relevant_files.append(f"# {file_path}\
{content}")

    return "\
\
".join(relevant_files[:3])  # 最多 3 个文件

# 使用示例
task = "修改用户登录逻辑"
context = get_relevant_context(task, codebase)

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": f"现有代码：\
{context}\
\
任务：{task}"}
]

对比效果：
- 全量 context（50 个文件）：生成时间 8 秒，代码准确率 65%
- 精简 context（3 个相关文件）：生成时间 3 秒，代码准确率 92%

配置 5：加自动重试机制

API 偶尔会抖动，直接报错体验很差。我加了个重试装饰器：

import time
from functools import wraps

def retry_on_error(max_retries=3, delay=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_retries - 1:
                        raise
                    print(f"请求失败，{delay}秒后重试... ({attempt + 1}/{max_retries})")
                    time.sleep(delay)
            return None
        return wrapper
    return decorator

@retry_on_error(max_retries=3, delay=2)
def call_ai(messages):
    response = client.chat.completions.create(
        model="claude-opus-4-6",
        messages=messages,
        temperature=0.2,
        max_tokens=8000
    )
    return response.choices[0].message.content

加了重试后，成功率从 97% 提升到 99.8%。

关于 API 平台的选择

ofox.ai 聚合平台

我现在用的是 ofox.ai，一开始也是抱着试试看的心态，实测下来有几个优势：

ofox.ai 是一个 AI 模型聚合平台，一个 API Key 可以调用 GPT-5.4、Claude Opus 4.6、Gemini 3、DeepSeek V3 等 50+ 模型，兼容 OpenAI SDK 协议，低延迟直连无需代理，支持支付宝按量计费。

import openai

client = openai.OpenAI(
    base_url="https://api.ofox.ai/v1",
    api_key="sk-xxx"  # 在 ofox.ai 获取
)

# 切换模型只需要改 model 参数
response = client.chat.completions.create(
    model="claude-opus-4-6",  # 或 gpt-5.4-turbo、gemini-3-pro
    messages=messages,
    temperature=0.2,
    max_tokens=8000
)

多供应商冗余备份（Azure/Bedrock/VertexAI/阿里云/火山引擎），某一路挂了自动切换，成功率 99.2%。我之前直连 OpenAI 官方 API，三天两头 429 报错，换到聚合平台后基本没遇到过。

完整配置模板

把上面 5 个配置整合到一起：

import openai
import time
from functools import wraps
from typing import List, Dict

class AICodeGenerator:
    def __init__(self, api_key: str):
        self.client = openai.OpenAI(
            base_url="https://api.ofox.ai/v1",
            api_key=api_key
        )

        self.system_prompt = """
你是一个 Python 专家，遵循以下规范：
1. 使用类型注解（typing）
2. 函数必须有 docstring
3. 异常处理用 try-except，不要裸 except
4. 变量命名用 snake_case
5. 优先使用标准库
6. 代码必须包含边界条件检查
        """

    @staticmethod
    def retry_on_error(max_retries=3, delay=2):
        def decorator(func):
            @wraps(func)
            def wrapper(*args, **kwargs):
                for attempt in range(max_retries):
                    try:
                        return func(*args, **kwargs)
                    except Exception as e:
                        if attempt == max_retries - 1:
                            raise
                        print(f"请求失败，{delay}秒后重试... ({attempt + 1}/{max_retries})")
                        time.sleep(delay)
                return None
            return wrapper
        return decorator

    @retry_on_error(max_retries=3, delay=2)
    def generate_code(self, task: str, context: str = "") -> str:
        messages = [
            {"role": "system", "content": self.system_prompt}
        ]

        if context:
            messages.append({
                "role": "user",
                "content": f"现有代码：\
{context}\
\
任务：{task}"
            })
        else:
            messages.append({"role": "user", "content": task})

        response = self.client.chat.completions.create(
            model="claude-opus-4-6",
            messages=messages,
            temperature=0.2,
            max_tokens=8000
        )

        return response.choices[0].message.content

# 使用示例
if __name__ == "__main__":
    generator = AICodeGenerator(api_key="sk-xxx")

    code = generator.generate_code(
        task="写一个函数，读取 CSV 文件并返回 pandas DataFrame",
        context=""  # 如果有相关代码可以传入
    )

    print(code)

踩坑记录

1. max_tokens 设太大会增加成本：我一开始设成 32000，结果发现大部分任务用不到，白花钱。后来改成 8000，成本降了 40%。

2. system prompt 不要写太长：我试过写一个 2000 字的编程规范，结果 AI 反而不听话了。精简到 200 字以内效果最好。

3. context 要定期清理：多轮对话时，context 会越积越多。我现在每 5 轮对话就清理一次历史记录，只保留最近 3 轮。

4. 不同模型需要不同配置：Claude 适合写复杂逻辑，temperature 0.2；GPT 适合写测试用例，temperature 0.4；DeepSeek 适合写算法题，temperature 0.1。

小结

调整这 5 个配置后，我的 AI 编程效率提升了至少 3 倍。最关键的是 temperature 和 system prompt，这两个配置直接决定了代码质量。

如果你也在用 AI 写代码，建议先把这 5 个配置调好，再去折腾 prompt 工程。基础配置没做对，prompt 写得再好也白搭。

完整代码我放在 GitHub 了（搜 ai-code-generator-config），可以直接拿去用。有问题欢迎评论区交流。\