AI Agent代码助手：让AI帮你写代码、改Bug
一、开场：程序员的好帮手
大家好，我是老金。
作为程序员，我每天都在做这些事：
- 写代码（30%）
- 改Bug（30%）
- 读别人的代码（20%）
- 查文档、Stack Overflow（15%）
- 真正思考架构设计（5%）
如果能用AI解决前四项，我就能专注于真正重要的事情。
去年开始，我把AI代码助手集成到开发流程中。效果：
- 写代码速度提升50%
- Bug修复时间减少40%
- 不再被重复性问题困扰
今天分享AI代码助手的实战经验。
二、AI代码助手能做什么？
能力边界
┌─────────────────────────────────────────────────────────┐
│ AI代码助手能力图谱 │
├─────────────────────────────────────────────────────────┤
│ │
│ ✅ 擅长的 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ • 代码生成：根据描述生成代码 │ │
│ │ • 代码补全：智能续写代码 │ │
│ │ • Bug修复：定位问题并修复 │ │
│ │ • 代码解释：解读复杂代码 │ │
│ │ • 文档生成：自动写注释和文档 │ │
│ │ • 单元测试：生成测试用例 │ │
│ │ • 代码重构：优化代码结构 │ │
│ │ • 语言转换：一种语言转另一种 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ ⚠️ 需要人类监督的 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ • 架构设计：需要全局视角 │ │
│ │ • 安全审查：涉及敏感逻辑 │ │
│ │ • 性能优化：需要实际测试 │ │
│ │ • 复杂Bug：需要理解业务上下文 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ ❌ 不擅长的 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ • 了解你的项目特定约定 │ │
│ │ • 理解复杂的业务逻辑 │ │
│ │ • 处理超大型代码库 │ │
│ │ • 最新API（训练数据之后发布的） │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘三、代码生成实践
好的Prompt设计
# ❌ 糟糕的Prompt
prompt = "写一个排序函数"
# ✅ 好的Prompt
prompt = """
写一个Python排序函数，要求：
1. 功能：对列表进行排序
2. 支持升序和降序
3. 支持自定义比较函数
4. 时间复杂度O(n log n)
5. 包含类型注解和docstring
6. 包含单元测试
示例用法：
sort_list([3, 1, 2], reverse=True) # 返回 [3, 2, 1]
"""生成的代码示例
from typing import List, Callable, TypeVar, Optional
T = TypeVar('T')
def sort_list(
items: List[T],
reverse: bool = False,
key: Optional[Callable[[T], any]] = None
) -> List[T]:
"""
对列表进行排序。
Args:
items: 要排序的列表
reverse: 是否降序，默认False（升序）
key: 自定义排序函数
Returns:
排序后的新列表
Examples:
>>> sort_list([3, 1, 2])
[1, 2, 3]
>>> sort_list([3, 1, 2], reverse=True)
[3, 2, 1]
>>> sort_list(['apple', 'pie'], key=len)
['pie', 'apple']
"""
return sorted(items, reverse=reverse, key=key)
# 单元测试
import unittest
class TestSortList(unittest.TestCase):
def test_ascending_order(self):
self.assertEqual(sort_list([3, 1, 2]), [1, 2, 3])
def test_descending_order(self):
self.assertEqual(sort_list([3, 1, 2], reverse=True), [3, 2, 1])
def test_custom_key(self):
result = sort_list(['apple', 'pie', 'banana'], key=len)
self.assertEqual(result, ['pie', 'apple', 'banana'])
def test_empty_list(self):
self.assertEqual(sort_list([]), [])
def test_single_element(self):
self.assertEqual(sort_list([1]), [1])
if __name__ == '__main__':
unittest.main()代码生成Agent
class CodeGeneratorAgent:
"""代码生成Agent"""
def __init__(self, llm, context_manager):
self.llm = llm
self.context_manager = context_manager
async def generate_code(self, requirement: str,
context: dict = None) -> dict:
"""生成代码"""
# 构建Prompt
prompt = self._build_prompt(requirement, context)
# 生成代码
response = await self.llm.generate(prompt)
# 解析结果
code, explanation = self._parse_response(response)
# 验证代码
validation = await self._validate_code(code)
return {
"code": code,
"explanation": explanation,
"validation": validation,
"suggestions": await self._get_improvement_suggestions(code)
}
def _build_prompt(self, requirement: str, context: dict) -> str:
"""构建生成Prompt"""
prompt = f"""
你是一个专业的程序员。根据以下要求生成代码：
## 需求
{requirement}
## 编码规范
- 使用类型注解
- 添加详细的docstring
- 遵循PEP 8规范
- 包含错误处理
## 输出格式
1. 先给出代码
2. 然后解释关键设计决策
3. 最后提供使用示例
"""
# 添加上下文
if context and context.get("related_code"):
prompt += f"""
## 相关代码（供参考）{context[“related_code”]}
"""
return prompt
async def _validate_code(self, code: str) -> dict:
"""验证代码"""
try:
# 语法检查
compile(code, '', 'exec')
# 静态分析
issues = self._static_analyze(code)
return {
"valid": len(issues) == 0,
"issues": issues
}
except SyntaxError as e:
return {
"valid": False,
"issues": [f"语法错误: {e}"]
}四、Bug修复实践
Bug诊断流程
class BugFixAgent:
"""Bug修复Agent"""
async def diagnose_and_fix(self, error_info: dict) -> dict:
"""诊断并修复Bug"""
# 1. 分析错误信息
diagnosis = await self._analyze_error(error_info)
# 2. 定位问题代码
problem_code = await self._locate_problem(
error_info["code"],
diagnosis
)
# 3. 生成修复方案
fix = await self._generate_fix(problem_code, diagnosis)
# 4. 验证修复
verification = await self._verify_fix(
error_info["code"],
fix["patched_code"]
)
return {
"diagnosis": diagnosis,
"problem_location": problem_code,
"fix": fix,
"verification": verification
}
async def _analyze_error(self, error_info: dict) -> dict:
"""分析错误"""
prompt = f"""
分析以下错误，找出根本原因：
## 错误类型
{error_info.get('error_type')}
## 错误信息
{error_info.get('error_message')}
## 堆栈跟踪
{error_info.get('traceback')}
## 相关代码{error_info.get(‘code’)}
请分析：
1. 错误的根本原因是什么？
2. 哪一行代码有问题？
3. 如何修复？
"""
response = await self.llm.generate(prompt)
return self._parse_diagnosis(response)常见Bug修复示例
# Bug: 空指针异常
# ❌ 原代码
def get_user_name(user_dict, user_id):
return user_dict[user_id].name
# ✅ AI修复后
def get_user_name(user_dict: dict, user_id: str) -> Optional[str]:
"""
获取用户名称，处理各种边界情况。
Args:
user_dict: 用户字典
user_id: 用户ID
Returns:
用户名称，如果用户不存在返回None
"""
if user_dict is None:
return None
user = user_dict.get(user_id)
if user is None:
return None
return getattr(user, 'name', None)
# Bug: 并发问题
# ❌ 原代码
counter = 0
def increment():
global counter
counter += 1
# ✅ AI修复后
import threading
class ThreadSafeCounter:
"""线程安全的计数器"""
def __init__(self):
self._value = 0
self._lock = threading.Lock()
def increment(self) -> int:
"""递增并返回新值"""
with self._lock:
self._value += 1
return self._value
@property
def value(self) -> int:
"""获取当前值"""
with self._lock:
return self._value
counter = ThreadSafeCounter()五、代码解释与文档
代码解释Agent
class CodeExplainerAgent:
"""代码解释Agent"""
async def explain(self, code: str, level: str = "detailed") -> str:
"""解释代码"""
if level == "brief":
prompt = f"""
用1-2句话解释以下代码的功能：
{code}
"""
elif level == "detailed":
prompt = f"""
详细解释以下代码：
{code}
请包含：
1. 整体功能说明
2. 关键变量和函数的作用
3. 算法逻辑解释
4. 可能的边界情况
"""
else: # line_by_line
prompt = f"""
逐行解释以下代码：
{code}
对每一行代码给出注释，解释其作用。
"""
return await self.llm.generate(prompt)
async def generate_docstring(self, code: str, style: str = "google") -> str:
"""生成docstring"""
prompt = f"""
为以下函数生成{style}风格的docstring：
{code}
包含：
- 功能描述
- 参数说明
- 返回值说明
- 使用示例
- 可能的异常
"""
return await self.llm.generate(prompt)六、单元测试生成
测试生成Agent
class TestGeneratorAgent:
"""测试生成Agent"""
async def generate_tests(self, code: str,
framework: str = "pytest") -> str:
"""生成单元测试"""
prompt = f"""
为以下代码生成{framework}单元测试：
{code}
要求：
1. 测试正常情况
2. 测试边界情况
3. 测试异常情况
4. 覆盖率目标：90%+
5. 使用参数化测试减少重复
"""
return await self.llm.generate(prompt)
async def improve_coverage(self, code: str,
existing_tests: str,
coverage_report: dict) -> str:
"""提高测试覆盖率"""
prompt = f"""
当前测试覆盖率：{coverage_report['coverage']}%
未覆盖的行：{coverage_report['missing_lines']}
代码：{code}
现有测试：{existing_tests}
请补充测试用例，覆盖缺失的代码行。
"""
return await self.llm.generate(prompt)生成的测试示例
import pytest
from calculator import Calculator
class TestCalculator:
"""Calculator类的单元测试"""
@pytest.fixture
def calc(self):
"""创建Calculator实例"""
return Calculator()
@pytest.mark.parametrize("a,b,expected", [
(1, 2, 3),
(0, 0, 0),
(-1, 1, 0),
(100, 200, 300),
(0.1, 0.2, 0.3), # 浮点数
])
def test_add(self, calc, a, b, expected):
"""测试加法"""
assert calc.add(a, b) == pytest.approx(expected)
@pytest.mark.parametrize("a,b,expected", [
(5, 3, 2),
(0, 0, 0),
(-1, -1, 0),
])
def test_subtract(self, calc, a, b, expected):
"""测试减法"""
assert calc.subtract(a, b) == expected
def test_divide_by_zero(self, calc):
"""测试除零异常"""
with pytest.raises(ValueError, match="除数不能为零"):
calc.divide(10, 0)
@pytest.mark.parametrize("a,b", [
(10**100, 1), # 大数
(1, 10**100), # 大数作除数
(float('inf'), 1), # 无穷大
])
def test_edge_cases(self, calc, a, b):
"""测试边界情况"""
# 不应该崩溃
result = calc.add(a, b)
assert isinstance(result, (int, float))七、代码重构
重构建议Agent
class RefactorAgent:
"""代码重构Agent"""
async def analyze_and_refactor(self, code: str) -> dict:
"""分析并提供重构建议"""
# 分析代码质量
quality_analysis = await self._analyze_quality(code)
# 生成重构建议
suggestions = await self._generate_suggestions(code, quality_analysis)
# 应用重构
refactored_code = await self._apply_refactoring(code, suggestions)
return {
"original_code": code,
"quality_analysis": quality_analysis,
"suggestions": suggestions,
"refactored_code": refactored_code,
"improvements": self._calculate_improvements(code, refactored_code)
}
async def _analyze_quality(self, code: str) -> dict:
"""分析代码质量"""
prompt = f"""
分析以下代码的质量问题：
{code}
从以下维度分析：
1. 可读性
2. 可维护性
3. 性能
4. 安全性
5. 测试性
列出具体问题和改进建议。
"""
response = await self.llm.generate(prompt)
return self._parse_quality_analysis(response)重构示例
# ❌ 原代码：长函数、重复逻辑
def process_order(order):
# 验证订单
if not order.get('items'):
return {'error': '订单无商品'}
if not order.get('user_id'):
return {'error': '缺少用户ID'}
if not order.get('address'):
return {'error': '缺少地址'}
# 计算价格
total = 0
for item in order['items']:
price = get_price(item['product_id'])
total += price * item['quantity']
# 计算折扣
if order.get('coupon'):
discount = get_discount(order['coupon'])
total = total * (1 - discount)
# 创建订单
order_id = create_order(
user_id=order['user_id'],
items=order['items'],
total=total,
address=order['address']
)
# 发送通知
user = get_user(order['user_id'])
send_email(user['email'], f"订单{order_id}创建成功")
send_sms(user['phone'], f"您的订单{order_id}已创建")
return {'order_id': order_id}
# ✅ 重构后：职责分离
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
class OrderStatus(Enum):
PENDING = "pending"
CONFIRMED = "confirmed"
SHIPPED = "shipped"
@dataclass
class OrderItem:
product_id: str
quantity: int
price: float = None
@dataclass
class Order:
user_id: str
items: List[OrderItem]
address: str
coupon: Optional[str] = None
status: OrderStatus = OrderStatus.PENDING
class OrderValidator:
"""订单验证器"""
def validate(self, order: Order) -> None:
"""验证订单，失败抛出异常"""
if not order.items:
raise ValueError("订单无商品")
if not order.user_id:
raise ValueError("缺少用户ID")
if not order.address:
raise ValueError("缺少地址")
class PriceCalculator:
"""价格计算器"""
def calculate(self, order: Order) -> float:
"""计算订单总价"""
total = sum(
self._get_item_price(item)
for item in order.items
)
return self._apply_discount(total, order.coupon)
def _get_item_price(self, item: OrderItem) -> float:
return get_price(item.product_id) * item.quantity
def _apply_discount(self, total: float, coupon: str) -> float:
if not coupon:
return total
discount = get_discount(coupon)
return total * (1 - discount)
class NotificationService:
"""通知服务"""
def notify_order_created(self, user_id: str, order_id: str) -> None:
"""发送订单创建通知"""
user = get_user(user_id)
self._send_email(user.email, order_id)
self._send_sms(user.phone, order_id)
def _send_email(self, email: str, order_id: str) -> None:
send_email(email, f"订单{order_id}创建成功")
def _send_sms(self, phone: str, order_id: str) -> None:
send_sms(phone, f"您的订单{order_id}已创建")
class OrderService:
"""订单服务"""
def __init__(self):
self.validator = OrderValidator()
self.price_calculator = PriceCalculator()
self.notifier = NotificationService()
def process_order(self, order: Order) -> dict:
"""处理订单"""
# 验证
self.validator.validate(order)
# 计算价格
total = self.price_calculator.calculate(order)
# 创建订单
order_id = create_order(
user_id=order.user_id,
items=order.items,
total=total,
address=order.address
)
# 通知
self.notifier.notify_order_created(order.user_id, order_id)
return {'order_id': order_id}八、IDE集成
VSCode插件集成
# 插件主逻辑
import vscode
class AIAssistantExtension:
"""VSCode AI助手扩展"""
def __init__(self):
self.agent = CodeGeneratorAgent(llm, context)
@vscode.command('aiAssist.generateCode')
async def generate_code(self):
"""生成代码命令"""
# 获取选中的文本或光标位置
editor = vscode.window.activeTextEditor
selection = editor.selection
document = editor.document
# 获取需求描述
requirement = await vscode.window.showInputBox(
prompt="描述你想生成的代码"
)
if not requirement:
return
# 获取上下文
context = self._get_context(document, selection)
# 生成代码
result = await self.agent.generate_code(requirement, context)
# 插入代码
await editor.edit(edit_builder => {
edit_builder.insert(selection.active, result.code)
})
@vscode.command('aiAssist.explainCode')
async def explain_code(self):
"""解释代码命令"""
editor = vscode.window.activeTextEditor
selected_code = editor.document.getText(editor.selection)
explanation = await self.agent.explain(selected_code)
# 显示解释
panel = vscode.window.createWebviewPanel(
'codeExplanation',
'代码解释',
vscode.ViewColumn.Beside
)
panel.webview.html = self._format_explanation(explanation)九、最佳实践
使用技巧
| 场景 | 技巧 | 示例 |
|---|---|---|
| 代码生成 | 提供完整上下文 | 包含相关函数、类型定义 |
| Bug修复 | 提供完整错误信息 | 错误类型、堆栈、相关代码 |
| 重构 | 指明重构目标 | “提高可读性”、”减少重复” |
| 文档 | 指定风格 | Google风格、NumPy风格 |
避免的坑
# ❌ 不要盲目信任AI生成的代码
# 始终进行Code Review和测试
# ❌ 不要复制粘贴不理解
# 理解每行代码的作用
# ❌ 不要忽略安全性
# AI可能生成有漏洞的代码
# ✅ 好的工作流
# 1. AI生成初稿
# 2. 人工Review
# 3. 运行测试
# 4. 安全审查
# 5. 性能测试十、总结
效率提升
| 任务 | 传统方式 | AI辅助 | 提升 |
|---|---|---|---|
| 写函数 | 30分钟 | 10分钟 | 67% |
| 改Bug | 2小时 | 30分钟 | 75% |
| 写测试 | 1小时 | 15分钟 | 75% |
| 写文档 | 30分钟 | 5分钟 | 83% |
下期预告
明天聊聊AI Agent数据分析——自动生成报表和洞察！
往期回顾
正文完
我们为何放弃了CrewAI：一个关于AI框架选型的深度复盘 - 技术老金 […] AI写不出“干净架构”：从代码生成到软件匠艺的进阶之路 […]