一个让我思考了很久的问题
上个月和一个在大厂做技术总监的朋友聊天，他提到一个现象让我印象很深：他们团队现在招聘，有个岗位叫”AI工程师”，薪资比普通后端开发高30%，但JD里不要求你会写多少代码，更看重的是你怎么设计Prompt、怎么评估AI输出、怎么做AI工作流。
回来后我一直在想这个问题。AI时代，程序员的价值到底在哪里？
有人说AI会取代程序员，我觉得这话对了一半。AI确实能完成很多重复性的编码工作，但软件开发不只是写代码——它还包括理解需求、权衡取舍、架构设计、跨团队沟通、debug排查。这些短期内AI很难完全替代。
但转型是必然的。就像汽车出现后，马车夫要么学会开车，要么转行。程序员也得学会和AI协作，学会把AI变成自己的工具，而不是被AI工具替代。
这篇文章，我想聊聊我对这个转型的思考。不讲大道理，就从实际技能点出发，聊聊具体该学什么、怎么学。
技能一：Prompt Engineering——和AI对话的艺术
为什么这个技能越来越重要
先说个真实的经历。我让ChatGPT帮我写一个排序算法，给出的Prompt不同，效果差别巨大。
Prompt A：写个排序算法
Prompt B：用Python写一个高效的排序算法，需要满足：
- 时间复杂度O(n log n)
- 空间复杂度O(1)，原地排序
- 代码需要详细注释
- 附上测试用例验证正确性
结果呢？Prompt A给的是冒泡排序，Prompt B给的是原地堆排序，代码质量完全不在一个层次。
这就是Prompt Engineering的价值：同样的AI工具，用得好和用得差，产出能差好几倍。
核心原则：明确、具体、有上下文
我总结了一个”三明治法则”——给AI的指令就像做三明治，要有层次：
顶层：角色和目标。你想让AI扮演什么角色，要达成什么目标。
中间层：具体要求和约束。格式、风格、长度、限制条件等。
底层：上下文和背景信息。相关知识、历史对话、参考资料等。
python
# 不好的Prompt
"""
写个函数
"""
# 好的Prompt
"""
你是一个Python后端工程师，需要帮同事写一个用户登录验证的函数。
具体要求：
1. 函数名：verify_login(username, password)
2. 输入：用户名和密码（都是字符串）
3. 输出：布尔值，验证通过返回True
4. 业务逻辑：
- 用户名不能为空，密码不能少于6位
- 需要校验密码是否正确（假设有个hash_password函数）
- 连续失败3次，锁定账户15分钟
注意事项：
- 密码验证需要防止时序攻击
- 需要记录登录日志
- 假设有个check_account_locked和lock_account的辅助函数
请用Python实现这个函数，代码需要符合PEP8规范。
"""
进阶技巧：Few-shot Learning
有时候光描述还不够，直接给例子效果更好。
python
# 用例子来让AI理解你的需求
prompt = """
帮我润色技术文档。润色原则是：
1. 保持专业术语准确
2. 语言简洁，避免废话
3. 适当增加可读性
示例：
原文："该系统具有非常强大的功能"
润色："该系统支持高并发处理，具备以下核心能力：..."
原文："我们需要对数据进行处理和分析"
润色："数据处理流程包括ETL抽取、清洗转换、OLAP分析三个阶段"
现在请润色以下内容：
原文：我们在做项目的时候发现，这个功能还是有点问题的，需要修复一下
"""
技能二：AI输出评估——学会说”不对”
AI会犯错，而且犯错的姿势还很自信。你必须学会评估AI的输出，不能照单全收。
建立检查清单
python
"""
AI代码输出检查清单
每次拿到AI生成的代码，按这个清单过一遍
"""
CHECKLIST = {
"正确性": [
"逻辑是否符合需求？",
"边界条件处理了吗？（空输入、超大输入、特殊字符）",
"有没有潜在的无限循环？",
"变量命名是否清晰准确？",
],
"安全性": [
"有没有SQL注入风险？",
"有没有XSS漏洞？",
"敏感信息是否硬编码？",
"权限控制是否完整？",
],
"性能": [
"时间复杂度是否可接受？",
"有没有N+1查询问题？",
"内存使用是否合理？",
"需要加缓存吗？",
],
"可维护性": [
"代码结构清晰吗？",
"注释是否充分？",
"有没有重复代码？",
"是否符合团队代码规范？",
]
}
def evaluate_ai_code(code: str, checklist=CHECKLIST):
"""评估AI生成的代码"""
issues = []
for category, items in checklist.items():
for item in items:
# 实际项目中可以用AI来辅助检查
# 这里简化处理
print(f"检查 {category} - {item}")
# if has_issue(code, item):
# issues.append(f"[{category}] {item}")
return issues
建立测试验证习惯
AI生成的代码，必须自己跑测试验证。这是底线。
python
import unittest
# 假设AI生成了这个函数
def ai_generated_function(data: list, key: str) -> list:
"""筛选并排序列表"""
filtered = [item for item in data if item.get(key)]
return sorted(filtered, key=lambda x: x[key])
# 编写测试用例（必须覆盖边界情况）
class TestAiGeneratedFunction(unittest.TestCase):
def test_normal_case(self):
"""正常情况"""
data = [
{"name": "Alice", "score": 85},
{"name": "Bob", "score": 92},
{"name": "Charlie", "score": 78}
]
result = ai_generated_function(data, "score")
self.assertEqual(result[0]["name"], "Bob") # 最高分排第一
def test_empty_list(self):
"""空列表"""
result = ai_generated_function([], "score")
self.assertEqual(result, [])
def test_missing_key(self):
"""缺少指定key的项"""
data = [
{"name": "Alice", "score": 85},
{"name": "Bob"}, # 没有score
{"name": "Charlie", "score": 78}
]
result = ai_generated_function(data, "score")
self.assertEqual(len(result), 2) # 只有Alice和Charlie
def test_none_value(self):
"""key值为None"""
data = [
{"name": "Alice", "score": 85},
{"name": "Bob", "score": None},
{"name": "Charlie", "score": 78}
]
result = ai_generated_function(data, "score")
self.assertEqual(len(result), 2) # None值被过滤
if __name__ == "__main__":
unittest.main()
技能三：工作流设计——让AI做它擅长的事
AI不是万能的，它擅长：大量信息处理、模式识别、初稿生成、翻译解释。它不擅长：理解模糊需求、处理例外情况、保证长期稳定性。
所以设计AI工作流的核心是：人做判断，AI执行。
典型工作流：代码审查
python
"""
AI辅助代码审查工作流
流程：
1. 开发者提交代码
2. AI快速扫描，标记可疑点
3. 开发者复核AI标记
4. 人工决定是否修改
5. 通过审核
"""
class CodeReviewWorkflow:
def __init__(self, llm_client):
self.llm = llm_client
self.review_prompt = """
你是一个严格的代码审查专家。请审查以下代码，关注：
1. 正确性：逻辑错误、边界条件
2. 安全漏洞：注入、越权、敏感信息泄露
3. 性能问题：时间空间复杂度、数据库查询
4. 代码质量：命名、注释、可读性
输出格式（严格按这个格式）：
[严重] 描述 + 建议
[警告] 描述 + 建议
[建议] 描述 + 建议
[通过] 审查项
如果没有某级别的问题，写"无"。
"""
def review(self, code: str, context: str = "") -> dict:
"""执行代码审查"""
# AI初筛
prompt = f"{self.review_prompt}\n\n代码上下文：{context}\n\n待审查代码：\n{code}"
ai_output = self.llm.generate(prompt)
# 解析AI输出
findings = self._parse_findings(ai_output)
# 开发者复核（这里简化，实际可以是人工复核流程）
verified_findings = self._developer_review(findings)
return {
"ai_findings": findings,
"verified_findings": verified_findings,
"can_merge": len([f for f in verified_findings if f["severity"] == "严重"]) == 0
}
def _parse_findings(self, ai_output: str) -> list:
"""解析AI输出"""
findings = []
current_severity = None
for line in ai_output.split("\n"):
line = line.strip()
if line.startswith("[严重]"):
current_severity = "严重"
elif line.startswith("[警告]"):
current_severity = "警告"
elif line.startswith("[建议]"):
current_severity = "建议"
elif line.startswith("[通过]"):
current_severity = "通过"
if current_severity and line:
findings.append({
"severity": current_severity,
"content": line
})
return findings
def _developer_review(self, findings: list) -> list:
"""开发者复核（实际场景由人工执行）"""
# 简化处理：假设开发者确认所有AI发现
# 真实场景需要人工确认每个发现是否确实
return findings
典型工作流：需求文档生成
python
"""
AI辅助需求文档工作流
场景：产品经理给了一个粗糙的需求描述，需要AI帮忙扩展成详细PRD
流程：
1. 产品经理提供核心需求（口头或简单描述）
2. AI追问澄清问题
3. 产品经理回答
4. AI生成初稿
5. 产品经理修改确认
6. 最终文档
"""
class PRDAgent:
def __init__(self, llm_client):
self.llm = llm_client
self.state = "init"
self.clarification_questions = []
def start(self, rough_requirement: str):
"""开始PRD生成流程"""
self.state = "clarifying"
self.rough_requirement = rough_requirement
# AI追问澄清问题
questions = self._generate_clarification_questions(rough_requirement)
self.clarification_questions = questions
return {
"step": "clarification",
"questions": questions,
"message": "我需要澄清几个问题，以确保生成的PRD准确"
}
def _generate_clarification_questions(self, requirement: str) -> list:
"""生成澄清问题"""
prompt = f"""
根据以下粗糙需求，生成5-10个关键澄清问题。
需求：{requirement}
关注：
1. 用户是谁？他们的痛点是什么？
2. 核心功能是什么？优先级如何？
3. 非功能性需求？（性能、安全、兼容性）
4. 成功标准是什么？
5. 约束条件是什么？
输出格式：每行一个问题，简短清晰。
"""
response = self.llm.generate(prompt)
return [q.strip() for q in response.split("\n") if q.strip()]
def submit_answers(self, answers: list) -> dict:
"""提交澄清问题的答案"""
self.answers = answers
self.state = "drafting"
return {
"step": "drafting",
"message": "正在生成PRD初稿，请稍候..."
}
def generate_draft(self) -> str:
"""生成PRD初稿"""
prompt = f"""
基于以下信息生成完整PRD文档。
原始需求：{self.rough_requirement}
澄清问答：
{self._format_qa()}
PRD结构：
# 产品概述
# 用户分析
# 功能需求
# 非功能需求
# 交互设计
# 验收标准
# 排期建议
请生成详尽、专业、可执行的PRD文档。
"""
draft = self.llm.generate(prompt)
self.state = "review"
return draft
def _format_qa(self) -> str:
"""格式化问答"""
lines = []
for i, (q, a) in enumerate(zip(self.clarification_questions, self.answers)):
lines.append(f"Q{i+1}: {q}")
lines.append(f"A{i+1}: {a}")
lines.append("")
return "\n".join(lines)
技能四：工具链集成——让AI融入开发流程
学再多概念不如动手集成到日常工作流。下面展示如何把AI能力集成到常见的开发工具中。
集成到VS Code
VS Code是目前最流行的IDE，通过扩展机制可以很方便地集成AI能力。
javascript
// vscode-extension/example-ai-assistant/extension.js
// 一个简单的AI助手扩展示例
const vscode = require('vscode');
const { LLMClient } = require('./llm-client');
function activate(context) {
// 注册命令
let disposable = vscode.commands.registerCommand(
'extension.aiAssistant',
async () => {
// 获取当前选中的代码
const editor = vscode.activeTextEditor;
if (!editor) {
vscode.window.showInformationMessage('请先选中代码');
return;
}
const selection = editor.selection;
const selectedCode = editor.document.getText(selection);
// 弹出选择框
const action = await vscode.window.showQuickPick(
['解释代码', '优化性能', '添加注释', '修复bug', '生成测试'],
{ placeHolder: '选择AI操作' }
);
if (!action) return;
// 调用AI
const llm = new LLMClient();
let prompt;
switch (action) {
case '解释代码':
prompt = `请解释以下代码的功能和工作原理：\n\n${selectedCode}`;
break;
case '优化性能':
prompt = `请优化以下代码的性能，给出优化前后的对比：\n\n${selectedCode}`;
break;
case '添加注释':
prompt = `请为以下代码添加详细的中文注释：\n\n${selectedCode}`;
break;
case '修复bug':
prompt = `请检查以下代码是否有bug，如果有请修复并说明：\n\n${selectedCode}`;
break;
case '生成测试':
prompt = `请为以下代码生成单元测试用例：\n\n${selectedCode}`;
break;
}
// 显示进度
await vscode.window.withProgress({
location: vscode.ProgressLocation.Notification,
title: "AI处理中",
cancellable: false
}, async () => {
const result = await llm.generate(prompt);
// 创建新文档显示结果
const doc = await vscode.workspace.openTextDocument({
content: `# AI ${action}结果\n\n## 原代码\n\`\`\`\n${selectedCode}\n\`\`\`\n\n## AI输出\n${result}\n`,
language: 'markdown'
});
await vscode.window.showTextDocument(doc);
});
}
);
context.subscriptions.push(disposable);
}
function deactivate() {}
module.exports = { activate, deactivate };
集成到Git Hooks
bash
#!/bin/bash
# .git/hooks/pre-commit
# AI辅助代码检查
echo "🤖 正在运行AI预提交检查..."
# 获取暂存的代码变更
STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)
CHECK_FAILED=0
for file in $STAGED_FILES; do
# 只检查代码文件
if [[ "$file" == *.py || "$file" == *.js || "$file" == *.ts ]]; then
echo "检查文件: $file"
# 读取文件内容
CONTENT=$(cat "$file")
# 调用AI检查（这里用curl调用本地API）
RESPONSE=$(curl -s -X POST http://localhost:8000/review \
-H "Content-Type: application/json" \
-d "{\"code\": \"$CONTENT\", \"filename\": \"$file\"}")
# 检查是否有严重问题
if echo "$RESPONSE" | grep -q "严重"; then
echo "⚠️ AI发现严重问题在 $file:"
echo "$RESPONSE" | grep "严重"
CHECK_FAILED=1
fi
fi
done
if [ $CHECK_FAILED -eq 1 ]; then
echo ""
echo "❌ 预提交检查未通过，请修复严重问题后再提交"
exit 1
fi
echo "✅ AI预提交检查通过"
exit 0
技能五：持续学习——跟上AI发展的节奏
AI发展太快了，今天学的知识可能过几个月就过时。所以学习方法比知识本身更重要。
建立学习系统
python
"""
个人AI学习追踪系统
帮助追踪AI领域的最新动态和自己的学习进度
"""
from datetime import datetime, timedelta
from dataclasses import dataclass, field
from typing import List, Optional
import json
@dataclass
class LearningResource:
"""学习资源"""
title: str
url: str
source: str # 来源：论文、博客、视频、课程
difficulty: str # 入门、进阶、高级
tags: List[str]
status: str = "unread" # unread, reading, completed
notes: str = ""
@dataclass
class SkillProgress:
"""技能进展"""
skill_name: str
level: int # 1-5
last_practiced: Optional[datetime] = None
projects: List[str] = field(default_factory=list)
gaps: List[str] = field(default_factory=list)
class LearningTracker:
def __init__(self):
self.resources: List[LearningResource] = []
self.skills: List[SkillProgress] = []
self.learning_log: List[dict] = []
def add_resource(self, resource: LearningResource):
"""添加学习资源"""
self.resources.append(resource)
self._save()
def update_skill_level(self, skill_name: str, level: int, project: str = ""):
"""更新技能等级"""
for skill in self.skills:
if skill.skill_name == skill_name:
skill.level = level
skill.last_practiced = datetime.now()
if project:
skill.projects.append(project)
self._save()
return
# 新技能
self.skills.append(SkillProgress(
skill_name=skill_name,
level=level,
last_practiced=datetime.now(),
projects=[project] if project else []
))
self._save()
def get_learning_recommendations(self) -> dict:
"""获取学习建议"""
recommendations = {
"review_needed": [], # 需要复习的技能
"next_steps": [], # 下一步建议
"resources_to_read": []
}
# 找出需要复习的技能（两周以上没练）
two_weeks_ago = datetime.now() - timedelta(days=14)
for skill in self.skills:
if skill.last_practiced and skill.last_practiced < two_weeks_ago:
recommendations["review_needed"].append(skill.skill_name)
# 推荐未读资源
unread = [r for r in self.resources if r.status == "unread"]
# 按标签排序，优先推荐与当前技能相关的
current_skills = [s.skill_name for s in self.skills if s.level < 5]
recommendations["resources_to_read"] = [
r for r in unread
if any(tag in current_skills for tag in r.tags)
][:5]
return recommendations
def log_learning(self, topic: str, duration_minutes: int, notes: str = ""):
"""记录学习日志"""
self.learning_log.append({
"date": datetime.now().isoformat(),
"topic": topic,
"duration_minutes": duration_minutes,
"notes": notes
})
self._save()
def generate_weekly_report(self) -> str:
"""生成周报"""
# 统计本周学习时长
week_ago = datetime.now() - timedelta(days=7)
week_logs = [
log for log in self.learning_log
if datetime.fromisoformat(log["date"]) > week_ago
]
total_minutes = sum(log["duration_minutes"] for log in week_logs)
topics = [log["topic"] for log in week_logs]
report = f"""
## 📊 本周学习报告
**学习时长**: {total_minutes // 60}小时{total_minutes % 60}分钟
**学习主题**: {', '.join(set(topics)) if topics else '暂无'}
**技能进展**:
"""
for skill in self.skills:
bar = "▓" * skill.level + "░" * (5 - skill.level)
report += f"- {skill.skill_name}: {bar} (Level {skill.level})\n"
report += "\n**待复习**: " + ", ".join(self.get_learning_recommendations()["review_needed"]) or "无"
return report
def _save(self):
"""保存数据"""
data = {
"resources": [
{"title": r.title, "url": r.url, "source": r.source,
"difficulty": r.difficulty, "tags": r.tags,
"status": r.status, "notes": r.notes}
for r in self.resources
],
"skills": [
{"skill_name": s.skill_name, "level": s.level,
"last_practiced": s.last_practiced.isoformat() if s.last_practiced else None,
"projects": s.projects, "gaps": s.gaps}
for s in self.skills
],
"learning_log": self.learning_log
}
with open("learning_tracker.json", "w") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
# 使用示例
tracker = LearningTracker()
# 添加学习资源
tracker.add_resource(LearningResource(
title="Gemini API官方文档",
url="https://ai.google.dev/docs",
source="官方文档",
difficulty="入门",
tags=["Gemini", "API", "Python"]
))
# 更新技能等级
tracker.update_skill_level("Prompt Engineering", 3, "客服助手项目")
# 记录学习
tracker.log_learning("Prompt Engineering", 90, "学习了Few-shot技巧")
# 生成报告
print(tracker.generate_weekly_report())
实践建议：从小处着手
说了这么多，最后给几点实操建议：
1. 从本职工作切入
不要为了学AI而学AI，先从你现在的工作场景找突破口。比如你是后端开发，就先试着用AI帮你写单元测试、生成API文档、优化SQL。你能立刻看到价值，也更容易坚持。
2. 每天半小时，胜过周末突击
学习是个持续的过程。我见过很多人周末猛学两天，然后一周不碰，最后全忘光。建议每天固定半小时，哪怕只是看两篇技术文章、跑一个小例子。持续比强度重要。
3. 建立自己的知识库
学过的知识不用，很快就忘。建议用Notion、Obsidian或者简单Markdown，记下学到的东西、加深理解的过程、实际应用的心得。这个知识库会成为你最重要的资产。
4. 加入社区，互相学习
一个人闷头学容易走偏，也容易放弃。找到志同道合的学习群体，可以是微信群、Slack频道、技术论坛。分享你的学习心得，也看看别人在关注什么。
5. 接受不完美，先跑起来
很多人追求完美，等把所有知识都学齐了再动手，结果永远迈不出第一步。我的经验是：先做，遇到问题再查缺补漏。学以致用，用中促学。
写在最后
转型不是一蹴而就的事，也不是非此即彼的选择。我们这一代程序员，既要保持对底层技术的理解，又要学会和AI协作。这不是被淘汰，而是升级。
关键是保持开放的心态，愿意学新东西。不要觉得自己写了几年代码就不需要改变了。技术行业，从来都是活到老学到老。
希望这篇文章能给你一些启发。如果有什么想法，欢迎交流。
发表回复