前言

在使用 GitHub Copilot、Claude、ChatGPT 等 AI 编程助手时,你是否遇到过这些问题:

  • ❌ 提示词一股脑输入,模型生成的代码混乱且难以控制
  • ❌ 想修改某个模块,却牵一发而动全身
  • ❌ 表结构设计不合理,但代码已经生成大半,改动成本巨大
  • ❌ 技术栈选择不当,中途发现不适合,但已经投入大量时间

核心问题:我们缺少一套结构化的 AI 协作开发流程,让 AI 的每次输出都可控、可回滚、可迭代。

本文将分享一套经过实践验证的六阶段 AI 驱动开发方法论,帮助你像指挥交响乐团一样精准控制 AI 的输出,从零到一高效构建完整项目。


核心理念:分阶段、模块化、可控化

三大原则

  1. 分阶段推进:设计在前,编码在后,每个阶段独立确认
  2. 模块化开发:按功能模块逐个实现,避免大爆炸式生成
  3. 输出可控:明确告诉 AI 输出什么、不输出什么

关键策略

  • 在设计阶段禁止 AI 生成代码,只输出设计文档
  • 使用检查点机制,每个阶段人工确认后再进入下一阶段
  • 采用增量式提示词,逐步细化需求

六阶段开发流程

阶段 0:项目规划与需求分析

目标:明确做什么,不做什么

提示词模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
我要开发一个 [项目类型] 项目,目标用户是 [用户画像]。

核心功能:
1. [功能1]
2. [功能2]
3. [功能3]

非功能性需求:
- 预期并发量:[数量]
- 数据规模:[规模]
- 性能要求:[响应时间等]

请帮我:
1. 梳理完整的功能清单
2. 识别技术难点
3. 评估开发优先级

⚠️ 注意:只输出需求分析文档,不要生成任何代码

输出示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
## 功能清单
### 核心功能
1. 用户认证系统
- 注册/登录
- JWT token 管理
- 权限控制

2. 内容管理
- 文章 CRUD
- 富文本编辑
- 图片上传

### 技术难点
- 高并发下的缓存策略
- 大文件上传的分片处理

### 开发优先级
P0: 用户认证 → P1: 基础 CRUD → P2: 高级功能

人工检查点 ✅

  • 功能列表是否完整?
  • 技术难点评估是否合理?
  • 优先级划分是否符合业务需求?

阶段 1:技术栈选型与架构设计

目标:确定用什么技术,怎么组织架构

提示词模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
基于以下项目需求:
[粘贴阶段0的需求文档]

技术约束:
- 团队技术栈:[熟悉的技术]
- 部署环境:[云平台/本地]
- 预算限制:[开源优先/商业可选]

请推荐:
1. 后端框架及理由
2. 数据库选型(关系型/NoSQL)
3. 缓存方案
4. 消息队列(如需要)
5. 项目目录结构

⚠️ 只输出技术选型文档和架构图(用 Mermaid),不生成项目代码

输出示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
## 技术栈推荐

### 后端
- **框架**: Django 5.0 + DRF
- **理由**:
- 内置强大的 ORM 和 Admin
- DRF 提供完善的 API 功能
- 团队熟悉 Python 生态

### 数据库
- **主库**: PostgreSQL 15
- **缓存**: Redis 7
- **搜索**: Elasticsearch(可选)

### 架构设计

```mermaid
graph TB
A[Nginx] --> B[Django Application]
B --> C[PostgreSQL]
B --> D[Redis]
B --> E[Celery Worker]
E --> F[Message Queue]
​```

## 项目目录结构
```
myproject/
├── apps/
│ ├── users/ # 用户模块
│ ├── posts/ # 文章模块
│ └── core/ # 核心公共模块
├── config/ # 配置文件
├── tests/ # 测试
└── requirements.txt
​```

人工检查点 ✅

  • 技术选型是否符合团队能力?
  • 架构设计能否满足性能要求?
  • 是否考虑了未来扩展性?

阶段 2:数据库设计

目标:设计完善的表结构和关系

提示词模板

1
2
3
4
5
6
7
8
9
10
11
12
基于以下需求和技术栈:
[粘贴前两个阶段的文档]

请设计数据库表结构:

要求:
1. 只输出 SQL DDL 语句或 ORM Model 定义
2. 说明表之间的关系(一对多、多对多等)
3. 标注字段的索引、唯一约束
4. 考虑软删除、时间戳等通用字段

⚠️ 不要生成 views/serializers/业务逻辑代码

输出示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# apps/users/models.py
from django.contrib.auth.models import AbstractUser
from django.db import models

class User(AbstractUser):
"""用户表"""
avatar = models.URLField(max_length=500, blank=True)
bio = models.TextField(blank=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
is_deleted = models.BooleanField(default=False)

class Meta:
db_table = 'users'
indexes = [
models.Index(fields=['email']),
]

# apps/posts/models.py
class Post(models.Model):
"""文章表"""
title = models.CharField(max_length=200, db_index=True)
content = models.TextField()
author = models.ForeignKey(
'users.User',
on_delete=models.CASCADE,
related_name='posts'
)
status = models.CharField(
max_length=20,
choices=[('draft', '草稿'), ('published', '已发布')],
default='draft'
)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
is_deleted = models.BooleanField(default=False)

class Meta:
db_table = 'posts'
indexes = [
models.Index(fields=['author', 'status']),
models.Index(fields=['-created_at']),
]

人工检查点 ✅

  • 表关系设计是否合理?
  • 索引是否覆盖常用查询?
  • 是否考虑了数据完整性约束?
  • 字段类型和长度是否合适?

关键提示:这个阶段确认后再往下走!表结构改动成本极高。


阶段 3:API 接口设计

目标:定义清晰的 API 契约

提示词模板

1
2
3
4
5
6
7
8
9
10
11
12
基于以下数据库设计:
[粘贴阶段2的 Model 定义]

请设计 RESTful API 接口:

要求:
1. 列出所有端点(URL、HTTP Method)
2. 定义请求参数和响应格式(JSON Schema)
3. 说明状态码和错误处理
4. 标注需要认证的接口

⚠️ 只输出 API 文档,不生成 views/serializers 代码

输出示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
## API 接口文档

### 用户模块

#### 1. 用户注册
- **URL**: `POST /api/v1/users/register/`
- **认证**: 不需要
- **请求体**:
```json
{
"username": "string",
"email": "string",
"password": "string"
}
​```
- **响应**: `201 Created`
```json
{
"id": 1,
"username": "john",
"email": "john@example.com",
"created_at": "2025-11-04T10:00:00Z"
}
​```
- **错误码**:
- `400`: 参数校验失败
- `409`: 用户名或邮箱已存在

#### 2. 用户登录
- **URL**: `POST /api/v1/users/login/`
- **认证**: 不需要
- **请求体**:
```json
{
"username": "string",
"password": "string"
}
​```
- **响应**: `200 OK`
```json
{
"access_token": "eyJ0eXAiOiJKV1QiLCJhbG...",
"refresh_token": "eyJ0eXAiOiJKV1QiLCJhbG...",
"user": {
"id": 1,
"username": "john"
}
}
​```

### 文章模块

#### 3. 创建文章
- **URL**: `POST /api/v1/posts/`
- **认证**: 需要(JWT Token)
- **请求头**: `Authorization: Bearer <token>`
- **请求体**:
```json
{
"title": "string",
"content": "string",
"status": "draft"
}
​```
- **响应**: `201 Created`

#### 4. 文章列表
- **URL**: `GET /api/v1/posts/`
- **认证**: 不需要
- **查询参数**:
- `page`: 页码(默认1)
- `page_size`: 每页数量(默认20)
- `status`: 过滤状态(draft/published)
- **响应**: `200 OK`
```json
{
"count": 100,
"next": "http://api.example.com/posts/?page=2",
"previous": null,
"results": [
{
"id": 1,
"title": "标题",
"author": {
"id": 1,
"username": "john"
},
"created_at": "2025-11-04T10:00:00Z"
}
]
}
​```

人工检查点 ✅

  • API 设计是否符合 RESTful 规范?
  • 响应格式是否统一?
  • 是否覆盖了所有业务场景?
  • 权限控制是否合理?

阶段 4:模块化开发

目标:按功能模块逐个实现,精确控制代码生成

关键策略:单模块单轮对话

❌ 错误做法

1
帮我实现用户模块和文章模块的所有功能

→ 结果:一次性生成大量代码,难以审查和修改

✅ 正确做法

1
2
3
4
第一轮:只实现用户注册功能
第二轮:只实现用户登录功能
第三轮:实现文章创建功能
...

提示词模板(以用户注册为例)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
基于以下设计:
- 数据库 Model: [粘贴 User Model]
- API 接口: [粘贴注册接口文档]

请实现用户注册功能:

要求:
1. 创建 DRF Serializer 进行参数校验
2. 创建 ViewSet 处理注册逻辑
3. 密码加密存储
4. 邮箱和用户名唯一性校验
5. 添加必要的异常处理

只生成以下文件的代码:
- apps/users/serializers.py(只包含 RegisterSerializer)
- apps/users/views.py(只包含注册相关的 View)
- apps/users/urls.py(只包含注册路由)

⚠️ 不要生成其他功能的代码

输出示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# apps/users/serializers.py
from rest_framework import serializers
from django.contrib.auth import get_user_model

User = get_user_model()

class RegisterSerializer(serializers.ModelSerializer):
password = serializers.CharField(write_only=True, min_length=8)
password_confirm = serializers.CharField(write_only=True)

class Meta:
model = User
fields = ['username', 'email', 'password', 'password_confirm']

def validate(self, attrs):
if attrs['password'] != attrs['password_confirm']:
raise serializers.ValidationError("两次密码不一致")
return attrs

def create(self, validated_data):
validated_data.pop('password_confirm')
user = User.objects.create_user(**validated_data)
return user

# apps/users/views.py
from rest_framework import status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.viewsets import GenericViewSet
from .serializers import RegisterSerializer

class UserViewSet(GenericViewSet):
@action(detail=False, methods=['post'])
def register(self, request):
serializer = RegisterSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.save()
return Response({
'id': user.id,
'username': user.username,
'email': user.email
}, status=status.HTTP_201_CREATED)

# apps/users/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import UserViewSet

router = DefaultRouter()
router.register('users', UserViewSet, basename='user')

urlpatterns = [
path('', include(router.urls)),
]

迭代式开发流程

1
2
3
4
1. 实现功能 A → 测试 → 确认
2. 实现功能 B → 测试 → 确认
3. 实现功能 C → 测试 → 确认
...

人工检查点 ✅(每个功能)

  • 代码是否符合 API 设计?
  • 异常处理是否完善?
  • 是否遵循框架最佳实践?
  • 是否有安全隐患?

阶段 5:测试与优化

目标:确保代码质量和性能

提示词模板

1
2
3
4
5
6
7
8
9
10
为以下代码编写单元测试:
[粘贴需要测试的代码]

要求:
1. 使用 pytest 或 Django TestCase
2. 覆盖正常流程和异常场景
3. 测试覆盖率 > 80%
4. 包含边界值测试

只生成测试代码,不修改业务代码

性能优化提示词

1
2
3
4
5
6
7
8
9
分析以下代码的性能瓶颈:
[粘贴代码]

优化方向:
1. 数据库查询优化(N+1问题)
2. 缓存策略
3. 异步任务处理

只输出优化建议和关键代码修改,不重写整个模块

高级技巧:如何控制 AI 的输出边界

技巧 1:明确禁止清单

在每个阶段的提示词中加入:

1
2
3
4
5
⚠️ 不要生成:
- ❌ 其他模块的代码
- ❌ 配置文件(除非明确要求)
- ❌ 前端代码
- ❌ 部署脚本

技巧 2:使用输出格式约束

1
2
3
4
5
6
7
8
9
10
11
12
13
14
请严格按照以下格式输出:

## 设计说明
[设计思路]

## 代码实现
​```python
# 只包含以下文件
# file: apps/users/models.py
...
​```

## 使用示例
...

技巧 3:增量式提示词

1
2
3
4
5
第一步:只输出 Model 定义
确认后 →
第二步:基于 Model 生成 Serializer
确认后 →
第三步:生成 View 逻辑

技巧 4:版本回滚机制

1
2
3
4
5
基于以下代码的 v1 版本:
[粘贴代码]

现在发现问题:[具体问题]
请修改为 v2 版本,只修改 [具体部分],其他保持不变

实战案例:使用 AI 开发一个博客系统

完整流程演示

第 1 天:规划与设计(无代码)

  • 阶段 0:梳理需求(1小时)
  • 阶段 1:技术选型(30分钟)
  • 阶段 2:数据库设计(1小时)
  • 阶段 3:API 设计(1小时)

产出:4份设计文档,0行代码

第 2-3 天:核心功能开发

  • Day2:用户模块(注册、登录、JWT)
  • Day3:文章模块(CRUD、权限)

每个功能迭代流程

1
2
3
4
5
1. 提示 AI 生成代码
2. 人工 Review
3. 本地测试
4. 提示 AI 修改(如有问题)
5. 确认无误,进入下一功能

第 4 天:测试与优化

  • 编写单元测试
  • 性能优化
  • 安全加固

常见问题与解决方案

Q1: AI 生成的代码不符合团队规范怎么办?

A: 在提示词中加入规范要求:

1
2
3
4
5
代码规范要求:
- 遵循 PEP 8
- 使用 Type Hints
- 文档字符串使用 Google 风格
- 变量命名使用下划线命名法

Q2: 中途想更换技术栈怎么办?

A: 这就是分阶段的优势!如果在阶段1确认后再改,只需:

1
2
3
保留阶段0的需求文档,
重新执行阶段1-2,
之前生成的代码全部丢弃(因为还没写多少)

Q3: AI 总是生成我不想要的额外代码?

A: 使用精确文件路径约束

1
2
3
4
5
6
只修改以下文件:
- apps/users/views.py 的第 23-45 行
不要修改:
- models.py
- serializers.py
- 其他任何文件

Q4: 如何处理复杂的业务逻辑?

A: 分解为伪代码 + 逐步实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
第一轮:
写出伪代码逻辑:
1. 校验参数
2. 查询数据库
3. 业务计算
4. 返回结果

第二轮:
将伪代码第1步实现为真实代码

第三轮:
实现第2步
...

工具推荐

AI 编程助手

  • GitHub Copilot: 适合代码补全和小函数生成
  • Cursor: 适合整个项目的上下文理解
  • Claude/ChatGPT: 适合架构设计和复杂逻辑讨论

辅助工具

  • Mermaid: 画架构图和流程图
  • Postman: API 测试
  • DB Diagram: 数据库设计可视化

最佳实践总结

✅ Do(推荐做法)

  1. 设计先行:先用 AI 生成设计文档,人工确认后再生成代码
  2. 小步快跑:一次只让 AI 实现一个小功能
  3. 版本控制:每完成一个模块立即 commit
  4. 持续测试:每个功能开发完立即测试
  5. 文档驱动:保持需求文档、API文档的及时更新

❌ Don’t(避免做法)

  1. 大爆炸生成:一次性要求 AI 生成整个项目
  2. 跳过设计:直接让 AI 写代码,不做前期规划
  3. 盲目信任:AI 生成的代码不经审查直接使用
  4. 缺乏测试:等所有功能开发完再统一测试
  5. 混乱提示:提示词模糊不清,导致输出不可控

进阶:自定义你的 AI 开发工作流

基于本文的六阶段框架,你可以根据项目类型定制:

微服务项目

1
2
3
4
阶段0: 领域建模(DDD)
阶段1: 服务拆分与边界划分
阶段2: 每个服务独立走完阶段2-5
阶段6: 服务间通信设计(gRPC/REST)

前端项目

1
2
3
4
5
6
阶段0: 需求与原型
阶段1: 组件库选型(Ant Design/MUI)
阶段2: 状态管理设计(Redux/Zustand)
阶段3: 路由与页面结构
阶段4: 按页面模块开发
阶段5: 性能优化与适配

数据分析项目

1
2
3
4
5
6
阶段0: 业务问题定义
阶段1: 数据源与工具选型
阶段2: 数据模型设计
阶段3: ETL 流程设计
阶段4: 分析脚本开发
阶段5: 可视化与报表

结语

AI 编程助手是强大的工具,但工具的威力取决于使用者的方法

通过分阶段、模块化、可控化的开发流程,我们可以:

  • ✅ 将 AI 的输出从”不可控的黑盒”变为”可预测的工具”
  • ✅ 大幅提高开发效率,同时保证代码质量
  • ✅ 随时回滚和调整,避免返工成本

这套方法论不仅适用于新项目开发,也适用于重构旧项目学习新技术技术选型决策等场景。

记住:AI 是你的助手,不是替代品。保持对项目的掌控力,才能真正发挥 AI 的价值。


附录:提示词模板库

为了方便使用,我整理了一套可直接复用的提示词模板,你可以根据项目实际情况修改:

模板1:需求分析

1
2
3
4
5
6
7
8
9
10
11
12
我要开发一个 [项目类型],目标是 [核心目标]。

用户场景:
1. [场景1]
2. [场景2]

请帮我:
1. 细化功能清单
2. 识别技术风险
3. 建议MVP范围

只输出需求分析文档,不生成代码。

模板2:技术选型

1
2
3
4
5
6
7
8
9
10
11
项目需求:[简要描述]
团队技术栈:[列出熟悉的技术]
约束条件:[预算/时间/性能要求]

请推荐:
1. 后端技术栈
2. 前端技术栈(如适用)
3. 数据库方案
4. 第三方服务

要求:说明每个选择的理由,只输出方案对比,不生成项目代码。

模板3:数据库设计

1
2
3
4
5
6
7
8
9
基于需求 [需求描述],设计数据库表结构。

要求:
1. 使用 [Django ORM/SQLAlchemy/Prisma] 语法
2. 包含字段注释
3. 标注索引和约束
4. 说明表关系

只输出 Model 定义,不生成 CRUD 代码。

模板4:单功能实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
基于以下设计:
- Model: [粘贴 Model 代码]
- API: [粘贴接口文档]

实现 [具体功能名称] 功能。

要求:
1. 完整的参数校验
2. 异常处理
3. 遵循 [框架] 最佳实践

只生成以下文件:
- [文件1]
- [文件2]

不要生成其他文件。

模板5:代码审查

1
2
3
4
5
6
7
8
9
10
请审查以下代码:
[粘贴代码]

审查维度:
1. 安全性(SQL注入/XSS等)
2. 性能(N+1查询/内存泄漏)
3. 代码规范
4. 潜在Bug

只输出问题清单和修改建议,不重写代码。

模板6:性能优化

1
2
3
4
5
6
7
8
9
10
11
以下代码存在性能问题:
[粘贴代码]

场景:[并发量/数据规模]

请提供优化方案:
1. 数据库查询优化
2. 缓存策略
3. 异步处理

只输出优化后的关键代码片段。

希望这套方法论能帮助你更高效地使用 AI 进行项目开发!

如果你有更好的实践经验,欢迎在评论区分享交流 🚀