解码 Claude Code(六)— 实战技巧:从 Boris 和团队偷师的 30 条黄金法则

不是官方文档,不是营销话术。这是一个每天用 AI 写 100% 代码的人,用半年时间摸索出来的真实经验。

写在前面

前五期我们聊了 Claude Code 的起源、架构、记忆系统、技能和多代理协作。这一期换个节奏——不讲理论,只讲实操。

这篇文章的素材来自 Boris Cherny(Claude Code 创造者)在 2026 年 1-4 月发布的四组技巧分享,以及 Anthropic 团队成员 Thariq 关于会话管理的深度指南。我把它们重新组织成 6 个主题,30 条具体可执行的建议。

每一条都有出处,每一条都经过 Anthropic 内部团队的日常验证。

Coding Tips

一、并行是一切的起点

Boris 反复强调:并行是最大的生产力提升,没有之一。

1. 同时跑 5 个 Claude

Boris 的日常:5 个终端窗口,每个运行一个独立的 Claude Code 实例。一个重构代码,一个写测试,一个搜索依赖,一个审查 PR,一个处理 bug 报告。

具体操作:用 git worktree 创建 5 个独立的工作树,每个窗口一个。这样 5 个 Claude 互不干扰,各自操作各自的代码副本。

# 创建 worktree
git worktree add ../feature-a feature-a
git worktree add ../feature-b feature-b

# 在每个 worktree 里启动 Claude
cd ../feature-a && claude
cd ../feature-b && claude

或者用更简单的方式:claude -w 一键在 worktree 中启动。

2. 本地 + 云端双线作战

5 个本地 Claude 还不够?再开 5-10 个云端实例。claude.ai/code 支持在浏览器里运行 Claude Code,用 /teleport 可以在本地终端和云端之间无缝切换。

Boris 的组合拳:5 个本地 + 10 个云端 = 同时 15 个 Claude 在干活。

3. 把”每天做两次的事”变成斜杠命令

如果某个操作你一天要做两次以上,把它变成一条斜杠命令。

---
name: commit-push-pr
description: "提交代码、推送、创建 PR"
---

执行以下步骤:
1. 运行测试
2. git add 所有变更
3. 根据变更内容生成 commit message
4. git push
5. 创建 Pull Request

Boris 的 /commit-push-pr 命令可能是他用得最多的一条——每天执行几十次。

4. 用 /loop 把重复工作自动化

/loop 是 Boris 最喜欢的"隐藏功能"之一。它可以让 Claude 按固定间隔自动执行任务,最长持续一周。

他的日常配置:

/loop 5m /babysit          → 每5分钟自动处理PR review
/loop 30m /slack-feedback  → 每30分钟把Slack反馈变成PR
/loop 1h /pr-pruner        → 每小时清理过期PR

把技能和 loop 组合起来,就变成了一个 7x24 小时工作的 AI 助手。

二、验证闭环:最重要的一条

Boris 说过一句话,被整个社区反复引用:

给 Claude 验证自己工作的方式,效果提升 2-3 倍。这是获得高质量输出的最重要单一因素。

5. Claude 测试每一次变更

Boris 每次让 Claude 写完代码后,都会让它自己测试。不是"帮我看看有没有问题"——而是"运行测试,确保通过"。

这是他从 Meta 带来的习惯:代码质量不是审查出来的,是验证出来的。

6. 前端必须给 Claude 浏览器

让 Claude 写前端代码但不给它浏览器,就像让设计师蒙着眼睛画画。

Chrome 扩展是 Boris 做前端时的标配。Claude 写完代码后自动打开浏览器截图,对比设计稿,发现差异后自动修复。这个循环一直持续到页面看起来"对了"为止。

7. 用”挑战式提示”逼迫 Claude 自审

不要只说"帮我写这个功能"。试试这样说:

"审查这段代码,不要创建 PR,直到我通过你的测试。"

或者:

"向我证明这个方案有效。对比 main 分支和当前分支的行为差异。"

Boris 把这叫做"让 Claude 当你的审查者"——反向利用 AI 的能力来提升输出质量。

8. 失败后不要纠正,要重写

当一个修复方案"勉强能用"时,Boris 会说:

"基于你现在知道的一切,扔掉这个方案,实现那个优雅的解法。"

这个技巧的底层逻辑是:Claude 在尝试过程中学到了很多关于代码库的上下文,但它当前的实现可能只是在最初的错误假设上打补丁。让它带着新知识重新来过,往往能得到更好的结果。

9. 让 Claude 修复大多数 bug

不需要手把手教。直接说"修复失败的 CI 测试",或者把 Slack 里的 bug 线程贴给 Claude,只说一个字:"修。"

Claude 可以读日志、分析堆栈、定位代码、提出修复方案、运行测试验证。整个过程你只需要审查最终结果。

三、会话管理:对抗”上下文腐烂”

这一节的素材来自 Thariq(Anthropic 团队成员),他给出了目前最系统的会话管理指南。

10. 理解 Context Rot

即使有 1M token 的上下文窗口,模型性能也不是线性的。大约在 300-400k token 时,模型开始被无关信息干扰——注意力被分散到越来越多的 token 上,旧的不相关内容开始影响当前的判断。

这就是 Context Rot(上下文腐烂)。

11. 每个回合结束都是一个决策点

Claude 完成一个回合后,你有 5 个选择:

选项 上下文保留 适用场景
Continue 保留全部 同一任务,上下文仍然相关
Rewind 保留前半,丢弃后半 Claude 走错方向了
/compact 有损摘要 中期任务,需要清理冗余
/clear 只保留你写的 brief 全新任务
Subagent 主上下文 + 最终结果 会产生大量中间输出的任务

12. Rewind > 纠正

这是 Thariq 最推荐的习惯。

当 Claude 尝试方案 A 失败了,你的直觉可能是说"不对,试方案 B"。但这会把失败的方案 A 和你的纠正都留在上下文里。

更好的做法是 Rewind(双击 Esc):回退到失败尝试之前,用你学到的信息重新提示。

纠正后:上下文 = 5个文件读取 + 2次失败尝试 + 2次纠正 + 最终修复
回退后:上下文 = 5个文件读取 + 1个有经验的提示 + 最终修复

上下文更干净,模型的注意力更集中。

13. Compact 是中期任务的救星

当会话变长但你不想从头来过,/compact 是最好的选择。它会要求 Claude 摘要当前对话,然后用摘要替换历史。

关键技巧:用提示词引导 compact 的方向

/compact 保留认证重构的细节,丢弃测试调试的过程

不引导的 compact 可能会丢失重要信息——因为模型在做 compact 时处于"最不聪明"的状态(上下文已经很满了)。

14. 主动 compact,不要等到自动触发

等到自动 compact 触发时,模型已经处于 Context Rot 状态,摘要质量会下降。

正确做法:在你觉得上下文开始膨胀但模型还没变笨的时候,主动执行 /compact,带上方向提示。

四、CLAUDE.md:投资回报率最高的 5 分钟

15. 每次纠错后更新 CLAUDE.md

Boris 的原话:

每次你纠正 Claude 后,以这句话结尾:"更新你的 CLAUDE.md,确保你不再犯这个错误。"

Claude 非常擅长为自己写规则。它会精确地提取错误的模式,写成可执行的指令。

16. 团队共享,通过 PR 协作更新

CLAUDE.md 不应该是某个人的私有文件。Boris 的团队把它检入 git,通过 PR 协作更新。

一个更有趣的做法:在同事的 PR 上 @claude,让 Claude 在 review 过程中自动更新 CLAUDE.md。Boris 把这叫做"复利工程"——每次代码审查都在为未来的 AI 辅助投资。

17. 持续迭代直到错误率可测量地下降

CLAUDE.md 不是写一次就完事的。Boris 建议:

  1. 用一周时间记录 Claude 犯的所有错误
  2. 为每类错误添加一条规则
  3. 再用一周观察错误率是否下降
  4. 重复直到效果显著

这个过程可能需要几轮迭代,但每一轮都在让 Claude 变得更好。

18. 用 notes 目录积累项目知识

一个 Anthropic 工程师的做法:让 Claude 为每个任务/项目维护一个 notes 目录,每次 PR 后更新。然后在 CLAUDE.md 里指向这个目录。

这样 CLAUDE.md 本身保持简洁(只放规则和约定),而详细的项目知识存在 notes 里,按需加载。

五、工具和环境优化

19. 用 Opus + Thinking 处理一切

这听起来违反直觉——Opus 比 Sonnet 慢,为什么还要用?

Boris 的解释:虽然单次响应更慢,但因为 Opus 犯错更少、工具使用更准确,你需要纠错的次数大幅减少。总耗时反而更短。

这就像开车走高速 vs 走小路:高速看起来绕远了,但因为不用等红灯,总时间更短。

20. 用 PostToolUse Hook 自动格式化代码

Claude 生成的代码通常格式良好,但最后 10% 可能和项目的 lint 规则不一致。一个简单的 Hook 就能解决:

"PostToolUse": [{
  "matcher": "Write|Edit",
  "hooks": [{
    "type": "command",
    "command": "bun run format || true"
  }]
}]

每次 Claude 写入或编辑文件后自动格式化,CI 再也不会因为格式问题失败。

21. 预授权权限,不要跳过权限检查

--dangerously-skip-permissions 看起来很方便,但 Boris 坚决反对。正确做法是用 /permissions 预先授权已知的安全操作:

{
  "permissions": {
    "allow": [
      "Bash(npm test*)",
      "Bash(npm run lint*)",
      "Bash(git status*)",
      "Bash(git diff*)"
    ]
  }
}

把这些规则检入 settings.json,整个团队共享。

22. 给 Claude 接入你所有的工具

通过 MCP,Claude 可以访问 Slack、BigQuery、Sentry、GitHub 等所有团队工具。Boris 已经 6 个月没写过一行 SQL 了——所有数据查询都通过 Claude + BigQuery 完成。

配置方法:在 .mcp.json 中定义 MCP 服务器,检入 git 共享。

23. 语音输入:说得比打得快 3 倍

Boris 大部分代码是"说"出来的,不是"打"出来的。

语音输入的好处不只是速度——它让你的 prompt 自然变得更详细。打字时你会下意识压缩信息,说话时你会自然补充更多上下文。而 prompt 越详细,Claude 的输出越好。

终端里运行 /voice,然后按住空格键说话。macOS 上也可以双击 fn 键触发系统听写。

24. --bare 让 SDK 启动快 10 倍

用 Claude Code 做 CI/CD 或自动化时,默认会搜索所有 CLAUDE.md、settings 和 MCP 配置。加上 --bare 跳过这些搜索,启动速度提升 10 倍:

claude -p "总结这个代码库" \
  --output-format=stream-json \
  --bare

Boris 透露,未来的版本会把 --bare 变成默认行为——因为它在非交互场景下几乎总是更好的选择。

六、高级工作流

25. /batch:大规模变更的核武器

需要把一个重构应用到几十甚至几百个文件?/batch 会先和你确认方案,然后自动分发到数十/数百个 worktree agent 并行执行。

每个 agent 在独立的代码副本上工作,完成后自动合并。这是 Claude Code 处理大规模代码迁移的终极工具。

26. 用 Hooks 挂载到 Agent 生命周期

Hooks 让你在 Claude 的关键节点执行自定义逻辑:

  • SessionStart:每次启动时动态加载上下文
  • PreToolUse:记录模型执行的所有 bash 命令
  • Stop:Claude 停止时"戳"它一下让它继续

第三个特别有用——长时间运行的任务中,Claude 有时会过早停止。用 Stop Hook 自动推送它继续,直到任务真正完成。

27. 子代理不只是”分工”,更是”上下文隔离”

子代理最大的价值不是并行执行——而是上下文隔离。

当你知道接下来的一块工作会产生大量中间输出(20 次文件读取、12 次 grep、3 条死路),而这些输出你之后不再需要——把它交给子代理。只有最终结论会返回主上下文。

判断标准很简单:我之后还需要这些工具输出吗?不需要就丢给子代理。

28. 会话分支:探索不同方向的安全网

/branch 从当前会话分叉出一个新方向。原来的会话完好无损,你可以随时切回来。

适用场景:一个方案不确定能不能走通?先 branch 一下,在分支里试。失败了切回来,零损失。

29. 跨仓库工作:--add-dir

当你需要同时操作多个代码仓库时,用 --add-dir 把其他目录加入 Claude 的工作范围:

claude --add-dir ../shared-libs --add-dir ../api-gateway

这不仅让 Claude "看到"这些仓库,还自动授予了操作权限。

30. 用 Explanatory 模式学新东西

Claude Code 不只是写代码的工具,也是学习工具。在 /config 里切换到 "Explanatory" 或 "Learning" 输出风格,Claude 会在每次变更时解释"为什么这么做"。

还可以让它:
- 生成 HTML 幻灯片解释不熟悉的代码
- 画 ASCII 图描述新协议和代码架构
- 构建间隔重复学习技能——你解释理解,Claude 提问补漏洞


总结:30 条法则的底层逻辑

把 30 条技巧摊开看,你会发现它们都围绕三个核心原则:

原则一:给 AI 反馈闭环。 验证工作(5-9)是最重要的一组技巧。没有反馈的 AI 就像没有方向盘的车——动力再强也没用。

原则二:管理上下文就是管理 AI 的"智商"。 会话管理(10-14)、CLAUDE.md(15-18)、子代理(27)都在做同一件事——确保模型的注意力集中在正确的事情上。

原则三:自动化一切重复操作。 斜杠命令(3)、/loop(4)、Hooks(26)、权限预授权(21)——把人类从重复劳动中解放出来,让 AI 处理 AI 最擅长的事。

这三条原则不只适用于 Claude Code。它们是 2026 年"AI 辅助开发"这个领域的通用方法论。不管你用什么工具,只要你记住这三条,就能显著提升 AI 编程的效率和质量。


系列导航

下期预告:真正的项目是怎么用 Claude Code 完成的?从天气应用到大规模重构,从个人 side project 到 Anthropic 内部的生产系统。第七期,我们走进真实案例。

Views: 6

Views: 26

交互式需求发现:从模糊想法到具体规范

交互式需求发现:从模糊想法到具体规范

让 AI 成为你最好的需求分析师

前言

在实际项目中,很多需求一开始都是模糊的:

  • "我想做一个 AI 驱动的项目管理工具"
  • "需要加一个实时协作功能"
  • "我们要做一个数据分析平台"

传统的需求分析依赖人工,耗时长、易遗漏。而 AI 辅助的交互式需求发现,可以把这个过程从"几天"缩短到"几小时"。

本文将建立一套标准化的 AI 需求发现工作流,让你的需求分析从"碰运气"变成"可工程化"。


一、什么是交互式需求发现?

1.1 传统需求分析 vs AI 辅助需求发现

对比维度 传统需求分析 AI 辅助需求发现
时间 数天到数周 数小时到一天
成本 高(人力密集) 低(AI 自动化)
质量 依赖经验 系统性覆盖
一致性 因人而异 标准化流程
迭代 困难 快速迭代

1.2 核心理念:苏格拉底式对话

原则

  • 不直接给答案,而是问问题
  • 通过系统性提问引导用户思考
  • 渐进式发现隐藏需求

示例

用户:我想做一个项目管理工具

AI(❌ 错误):好的,我来设计一个项目管理工具...
   [直接跳到实现]

AI(✅ 正确):明白了。让我问几个问题帮助理清需求:
   1. 这个工具主要解决什么问题?
   2. 目标用户是谁?(个人、小团队、企业)
   3. 需要管理什么类型的项目?(软件开发、市场营销、通用)
   4. 是否需要实时协作功能?
   5. 数据安全性要求如何?

1.3 工作流程总览

模糊想法
   ↓
[探索阶段] 苏格拉底式对话
   ↓
[分析阶段] 多角色专业分析
   ↓
[验证阶段] 可行性评估
   ↓
[规范生成] 需求文档
   ↓
[移交阶段] 可执行简报
   ↓
具体规范

二、实际操作指南

2.1 触发方式

方式1:命令行触发

/sc:brainstorm "AI 驱动的项目管理工具" --strategy systematic --depth deep

参数说明

  • --strategy systematic|agile|enterprise:策略模式

    • systematic:系统性探索(适合复杂项目)
    • agile:敏捷探索(快速迭代)
    • enterprise:企业级探索(强调安全、合规)
  • --depth shallow|normal|deep:探索深度

    • shallow:浅层探索(1-2 轮对话)
    • normal:正常探索(3-5 轮对话)
    • deep:深度探索(5+ 轮对话)
  • --parallel:并行探索(多角色同时分析)


方式2:自然语言触发

用户:我想做一个项目管理工具,但不确定具体功能
AI:好的,让我们一起来探索这个想法...

[自动进入 brainstorm 模式]

2.2 分阶段操作指南

阶段1:探索阶段(Explore)

目标:通过系统性提问理清需求

操作步骤

  1. 启动探索

    用户:/sc:brainstorm "AI 驱动的项目管理工具"
    
    AI:好的,让我们开始探索这个想法。首先,我需要了解:
    
    【核心问题】
    1. 这个工具主要解决什么问题?
      - 任务跟踪混乱?
      - 团队协作困难?
      - 进度可视性差?
    
    2. 目标用户是谁?
      - 个人开发者
      - 小团队(5-20 人)
      - 中型企业(20-200 人)
      - 大型企业(200+ 人)
    
    请选择或补充你的想法。
  2. 用户回答

    用户:主要解决团队协作困难,目标用户是小团队(5-20 人)
  3. 渐进式深入

    AI:明白了。针对小团队的协作问题,让我进一步了解:
    
    【协作场景】
    1. 团队成员如何分配任务?
      - 手动分配
      - 自动匹配技能
      - AI 智能推荐
    
    2. 需要哪些协作功能?
      - 实时聊天
      - 文件共享
      - 任务评论
      - 视频会议
    
    3. 是否需要移动端支持?
    
    请告诉我你的偏好。
  4. 记录关键信息

    # 探索记录
    
    ## 核心需求
    - 解决团队协作困难
    - 目标用户:小团队(5-20 人)
    
    ## 协作需求
    - 任务分配:AI 智能推荐
    - 协作功能:实时聊天、任务评论
    - 移动端:需要
    
    ## 待确认
    - 视频会议是否需要?
    - 文件共享的具体需求?

阶段2:分析阶段(Analyze)

目标:多角色专业分析

角色分工

角色 职责 关注点
架构师 系统设计 技术可行性、架构模式
分析师 可行性研究 成本效益、市场分析
前端 UI/UX 分析 用户体验、交互设计
后端 技术实现 数据结构、API 设计
安全 安全合规 数据安全、权限管理

操作示例

AI:基于你的需求,我协调了多个角色进行分析:

【架构师分析】
- 推荐架构:前后端分离 + WebSocket 实时通信
- 技术栈建议:React + Node.js + PostgreSQL
- 理由:成熟稳定、开发效率高、适合小团队

【前端分析】
- UI 风格:简洁现代、移动端优先
- 关键页面:任务看板、团队聊天、日程视图
- 交互重点:实时更新、拖拽操作

【后端分析】
- 数据模型:用户、任务、团队、消息
- API 设计:RESTful + GraphQL(可选)
- 性能要求:支持 100 并发用户

【安全分析】
- 认证方式:JWT + Refresh Token
- 权限控制:基于角色的访问控制(RBAC)
- 数据加密:传输层 TLS + 存储层加密

【分析师建议】
- 市场定位:小型敏捷团队
- 竞品分析:Notion、Trello、Asana
- 差异化:AI 智能任务分配 + 实时协作

你觉得这个分析方向对吗?有需要调整的地方吗?

阶段3:验证阶段(Validate)

目标:可行性评估和需求验证

验证清单

# 可行性验证清单

## 技术可行性
- [ ] 技术栈成熟稳定?✅
- [ ] 开发团队有相关经验?✅
- [ ] 第三方依赖可控?✅
- [ ] 性能要求可达成?✅

## 业务可行性
- [ ] 市场需求真实存在?✅
- [ ] 差异化竞争力明显?⚠️(需要强化 AI 功能)
- [ ] 商业模式可行?✅
- [ ] ROI 预期合理?✅

## 资源可行性
- [ ] 开发时间充足?✅(3 个月)
- [ ] 人力资源足够?⚠️(需要 1 个前端 + 1 个后端)
- [ ] 预算可控?✅

## 风险评估
| 风险项 | 影响 | 概率 | 缓解措施 |
|--------|------|------|----------|
| AI 功能不达预期 | 高 | 中 | 先做 MVP,逐步优化 |
| 竞品快速跟进 | 中 | 高 | 持续迭代,强化差异化 |
| 团队协作复杂 | 中 | 低 | 采用敏捷开发 |

操作示例

AI:我整理了可行性验证报告:

✅ 技术可行:技术栈成熟,风险可控
⚠️ 竞争激烈:需要强化 AI 功能差异化
⚠️ 人力需求:需要 2 个全职开发人员

【建议】
1. 先做 MVP(最小可行产品),验证市场需求
2. 重点打磨 AI 任务分配功能
3. 采用敏捷开发,2 周一个迭代

你觉得这个方向可行吗?还是需要调整?

阶段4:规范生成(Generate)

目标:生成完整的需求文档

需求文档模板

# 项目需求文档

## 1. 项目概述

### 1.1 项目背景
- **问题**:小团队协作困难,任务分配低效
- **目标**:构建 AI 驱动的项目管理工具
- **价值**:提升团队协作效率 30%

### 1.2 目标用户
- **主要用户**:小型敏捷团队(5-20 人)
- **次要用户**:中型团队(20-50 人)
- **用户画像**:
  - 项目经理:需要实时查看进度
  - 团队成员:需要接收任务、更新状态
  - 团队领导:需要数据分析、团队管理

---

## 2. 功能需求

### 2.1 核心功能

#### 功能1:AI 智能任务分配
**优先级**:P0  
**描述**:基于成员技能、工作负载、历史表现智能分配任务

**用户故事**:

作为一个项目经理,
我想要系统自动推荐最佳的任务分配方案,
以便提高团队效率,减少人工决策。


**验收标准**:
- ✅ 系统能识别成员技能标签
- ✅ 能计算成员当前工作负载
- ✅ 能推荐 Top 3 候选人
- ✅ 支持人工调整

---

#### 功能2:实时协作
**优先级**:P0  
**描述**:团队成员实时聊天、任务评论、文件共享

**用户故事**:

作为一个团队成员,
我想要在任务下直接评论和讨论,
以便快速沟通,避免信息分散。


**验收标准**:
- ✅ 支持实时消息推送(< 1 秒延迟)
- ✅ 支持富文本、表情、@提及
- ✅ 支持文件附件(≤ 10MB)
- ✅ 历史消息可检索

---

### 2.2 辅助功能

#### 功能3:看板视图
**优先级**:P1  
**描述**:可视化任务流转

**用户故事**:

作为一个项目经理,
我想要在看板视图中拖拽任务卡片,
以便直观管理任务状态。


---

## 3. 非功能需求

### 3.1 性能需求
- **响应时间**:页面加载 < 2 秒,操作响应 < 500ms
- **并发能力**:支持 100 并发用户
- **数据处理**:单团队支持 1000+ 任务

### 3.2 安全需求
- **认证**:JWT + Refresh Token
- **授权**:基于角色的访问控制(RBAC)
- **数据加密**:传输层 TLS 1.3,存储层 AES-256
- **合规**:符合 GDPR(如有欧洲用户)

### 3.3 可用性需求
- **可用性**:99.5% SLA
- **备份**:每日自动备份
- **恢复**:RTO < 4 小时,RPO < 1 小时

### 3.4 兼容性需求
- **浏览器**:Chrome 90+, Firefox 88+, Safari 14+
- **移动端**:iOS 14+, Android 10+
- **屏幕**:响应式设计,支持 320px-1920px

---

## 4. 用户故事

### 故事1:任务创建与分配

作为项目经理,
我想要快速创建任务并分配给团队成员,
以便推进项目进度。

验收标准:
✅ 能设置任务标题、描述、截止时间
✅ 能指定负责人、协作者
✅ 能设置优先级、标签
✅ 能附加文件、链接


### 故事2:进度追踪

作为项目经理,
我想要查看团队整体进度和个人工作负载,
以便及时调整资源分配。

验收标准:
✅ 看板视图显示任务流转
✅ 燃尽图显示项目进度
✅ 成员工作负载可视化
✅ 支持导出报告


---

## 5. 开放问题

### 待确认问题
1. **视频会议功能**:是否需要集成?(建议:第二期)
2. **第三方集成**:需要集成哪些工具?(Slack、GitHub、Jira?)
3. **离线支持**:是否需要离线模式?(技术复杂度高)
4. **AI 模型选择**:自研还是使用第三方 API?
5. **定价策略**:免费版功能范围?付费版定价?

### 风险项
1. **AI 功能效果**:智能分配是否真的有效?(建议:先做 MVP 验证)
2. **竞品压力**:Notion、Trello 功能已经很强大
3. **用户习惯**:团队是否愿意改变现有工具?

---

## 6. 下一步计划

### 6.1 立即行动
- [ ] 确认核心功能优先级
- [ ] 选择技术栈(React + Node.js + PostgreSQL)
- [ ] 设计数据库 Schema
- [ ] 绘制 UI 原型

### 6.2 后续工作
- [ ] 使用 <code>/sc:design 进行架构设计
- [ ] 使用 /sc:workflow 制定实施计划
- [ ] 使用 /sc:implement 开始编码

---

**文档版本**:v1.0  
**创建日期**:2026-03-31  
**作者**:AI 辅助需求发现

阶段5:移交阶段(Handover)

目标:创建可执行的简报,为实施做准备

移交清单

# 项目移交清单

## ✅ 已完成
- [x] 需求探索完成
- [x] 多角色分析完成
- [x] 可行性验证通过
- [x] 需求文档生成
- [x] 开放问题记录

## 📋 交付物
- [x] 需求文档(REQ-20260331-001.md)
- [x] 用户故事清单(USER-STORIES.md)
- [x] 风险评估报告(RISK-ASSESSMENT.md)
- [x] 技术栈建议(TECH-STACK.md)

## 🔄 下一步
- [ ] 使用 <code>/sc:design 进行架构设计
- [ ] 使用 /sc:workflow 制定实施计划
- [ ] 使用 /sc:implement 开始编码

## 👥 相关人员
- **需求负责人**:张三
- **技术负责人**:李四
- **项目经理**:王五

## 📅 时间线
- **需求冻结**:2026-04-07
- **架构设计完成**:2026-04-14
- **开发启动**:2026-04-21

三、MCP 工具集成

3.1 核心工具

1. Sequential Thinking MCP

用途:系统性探索和复杂推理

应用场景

  • 多步骤需求分析
  • 复杂业务逻辑推理
  • 风险评估和决策

使用示例

// 使用 Sequential Thinking 进行需求分析
const analysis = await sequentialThinking.analyze({
  problem: "小团队协作困难",
  steps: [
    "识别核心问题",
    "分析根本原因",
    "探索解决方案",
    "评估可行性",
    "生成建议"
  ]
});

2. Context7 MCP

用途:框架特定的可行性评估

应用场景

  • 技术选型分析
  • 框架对比评估
  • 架构模式推荐

使用示例

// 使用 Context7 进行技术栈评估
const techStack = await context7.evaluate({
  requirements: {
    performance: "high",
    scalability: "medium",
    teamSize: "small"
  },
  frameworks: ["React", "Vue", "Angular"]
});

3. Magic MCP

用途:UI/UX 可行性分析

应用场景

  • 用户界面设计评估
  • 交互模式分析
  • 设计系统集成

使用示例

// 使用 Magic 进行 UI 可行性分析
const uiAnalysis = await magic.analyzeUI({
  userStory: "任务看板拖拽操作",
  targetUsers: "项目经理",
  devices: ["desktop", "mobile"]
});

4. Playwright MCP

用途:用户体验验证

应用场景

  • 交互流程测试
  • 用户体验验证
  • 可用性测试

使用示例

// 使用 Playwright 验证用户流程
const uxTest = await playwright.testFlow({
  flow: ["登录", "创建任务", "分配任务", "查看进度"],
  metrics: ["完成时间", "错误率", "满意度"]
});

5. Serena MCP

用途:跨会话持久化

应用场景

  • 需求文档存储
  • 项目上下文管理
  • 跨会话记忆

使用示例

// 使用 Serena 保存需求文档
await serena.save({
  projectId: "project-001",
  document: "requirements.md",
  content: requirementsDoc
});

// 跨会话加载
const savedDoc = await serena.load({
  projectId: "project-001",
  document: "requirements.md"
});

3.2 工具协调策略

策略1:串行执行(Sequential)

适用场景:复杂需求,需要逐步深入

Step 1: Sequential Thinking - 需求分析
   ↓
Step 2: Context7 - 技术评估
   ↓
Step 3: Magic - UI 分析
   ↓
Step 4: Playwright - UX 验证
   ↓
Step 5: Serena - 持久化存储

策略2:并行执行(Parallel)

适用场景:多维度分析,提高效率

┌─────────────────────────────────────┐
│  多角色并行分析                      │
├─────────────────────────────────────┤
│  ┌───────────┐  ┌───────────┐       │
│  │ 架构师    │  │ 分析师    │       │
│  │Context7   │  │Sequential │       │
│  └───────────┘  └───────────┘       │
│  ┌───────────┐  ┌───────────┐       │
│  │ 前端      │  │ 安全      │       │
│  │ Magic     │  │ Sequential│       │
│  └───────────┘  └───────────┘       │
└─────────────────────────────────────┘

四、实战案例分析

案例1:AI 驱动的项目管理工具

项目背景

  • 客户:小型科技公司(20 人)
  • 痛点:团队协作困难,任务分配低效
  • 目标:构建 AI 驱动的项目管理工具

Step 1:启动探索

用户:/sc:brainstorm "AI 驱动的项目管理工具" --strategy systematic --depth deep

AI:好的,让我们开始系统性探索。

【第一轮:核心定位】
1. 主要解决什么问题?
   - 任务分配低效?
   - 进度跟踪困难?
   - 团队沟通不畅?

2. 目标用户规模?
   - 小团队(5-20 人)
   - 中型团队(20-100 人)
   - 大型团队(100+ 人)

3. AI 功能预期?
   - 智能任务分配
   - 进度预测
   - 风险预警

Step 2:深入分析

用户:主要解决任务分配低效,目标用户是 20 人的小团队,需要智能任务分配

AI:明白了。让我协调多个角色进行深入分析:

【架构师】
- 推荐技术栈:React + Node.js + PostgreSQL
- AI 方案:集成 OpenAI API(快速上线)
- 实时通信:WebSocket

【前端】
- 核心页面:任务看板、团队视图、AI 推荐
- 交互重点:拖拽操作、实时更新

【后端】
- 数据模型:用户、任务、技能标签、工作负载
- API 设计:RESTful + WebSocket

【安全】
- 认证:JWT + Refresh Token
- 权限:RBAC
- 数据:TLS + 加密存储

【分析师】
- 市场定位:小型敏捷团队
- 差异化:AI 智能分配(竞品少)
- MVP 建议:先做核心功能,2 个月上线

Step 3:验证可行性

AI:基于分析,我整理了可行性报告:

✅ 技术可行:技术栈成熟,AI API 可直接调用
✅ 市场需求:竞品少,差异化明显
⚠️ 资源需求:需要 2 个开发人员,2 个月

【风险评估】
- AI 效果不达预期(中)→ 先做 MVP 验证
- 用户习惯难改变(中)→ 提供免费试用

【建议】
1. 先做 MVP,验证 AI 分配效果
2. 重点打磨核心功能
3. 快速迭代,每月发布新版本

Step 4:生成需求文档

# AI 项目管理工具需求文档

## 核心功能
1. AI 智能任务分配(P0)
2. 实时协作(P0)
3. 任务看板(P1)
4. 进度追踪(P1)
5. 报表分析(P2)

## 技术栈
- 前端:React 18 + TypeScript + TailwindCSS
- 后端:Node.js 18 + Express + PostgreSQL
- AI:OpenAI GPT-4 API
- 实时:WebSocket (Socket.io)

## 时间线
- Week 1-2:UI 原型 + 数据库设计
- Week 3-6:核心功能开发
- Week 7-8:测试 + 上线

## 下一步
- [ ] 使用 <code>/sc:design 进行架构设计
- [ ] 使用 /sc:workflow 制定详细计划

案例2:实时协作功能

项目背景

  • 客户:在线教育平台
  • 痛点:师生互动性差
  • 目标:添加实时协作功能

启动探索

用户:/sc:brainstorm "实时协作功能" --strategy agile --parallel

AI:好的,启动敏捷探索模式,并行分析:

【并行角色分析】
┌─────────────────┐
│ 前端分析        │
│ - 实时白板      │
│ - 共享编辑器    │
│ - 视频窗口      │
└─────────────────┘
┌─────────────────┐
│ 后端分析        │
│ - WebRTC        │
│ - WebSocket     │
│ - SFU 服务器    │
└─────────────────┘
┌─────────────────┐
│ 安全分析        │
│ - 端到端加密    │
│ - 权限控制      │
│ - 内容审核      │
└─────────────────┘

【综合建议】
- 技术方案:WebRTC(音视频)+ WebSocket(数据)
- 第三方集成:声网 Agora(降低开发难度)
- 安全方案:端到端加密 + 实时审核

五、最佳实践与注意事项

5.1 成功要素

要素1:系统性提问

原则

  • 从宏观到微观
  • 从业务到技术
  • 从现在到未来

示例

❌ 错误:你想要什么功能?
✅ 正确:
   1. 这个项目要解决什么问题?
   2. 目标用户是谁?
   3. 用户现在的痛点是什么?
   4. 你希望用户得到什么价值?

要素2:多角色思维

原则

  • 不同角色看问题角度不同
  • 综合考虑才能全面
  • 避免单一视角盲区

示例

需求:用户登录功能

【安全视角】
- 需要防止暴力破解
- 需要多因素认证

【用户体验视角】
- 登录流程要简单
- 支持第三方登录

【后端视角】
- Session 还是 JWT?
- 如何处理 Token 刷新?

要素3:渐进式深入

原则

  • 不要一次问太多问题
  • 根据回答动态调整
  • 保持对话自然流畅

示例

Round 1: 了解大方向
   "这个工具主要解决什么问题?"

Round 2: 细化需求
   "你提到任务分配,具体是哪种场景?"

Round 3: 技术细节
   "AI 分配算法,你希望基于什么因素?"

5.2 常见陷阱

陷阱1:过早跳到实现

错误

用户:我想做一个项目管理工具
AI:好的,我来设计数据库 Schema...

正确

用户:我想做一个项目管理工具
AI:明白了。让我先了解一些背景信息...
   [先探索,再实现]

陷阱2:忽略非功能需求

错误

只关注功能需求,忘记性能、安全、可用性

正确

【功能需求】
- 任务创建、分配、跟踪

【非功能需求】
- 性能:< 2 秒响应
- 安全:JWT 认证
- 可用性:99.5% SLA

陷阱3:需求镀金

错误

用户:我想要一个简单的登录功能
AI:好的,我来设计多因素认证、生物识别、SSO...

正确

用户:我想要一个简单的登录功能
AI:明白了。是用户名密码登录,还是需要第三方登录?
   [聚焦核心需求,不过度设计]

5.3 文档管理

原则1:版本控制

# 需求文档命名规范
REQ-20260331-001.md  # 日期 + 序号
REQ-20260331-002.md

# 版本记录
## v1.0 (2026-03-31)
- 初始版本

## v1.1 (2026-04-01)
- 新增实时协作功能需求
- 更新非功能需求

原则2:跨会话持久化

// 使用 Serena MCP 持久化
await serena.save({
  projectId: "project-001",
  phase: "brainstorm",
  documents: {
    requirements: "REQ-20260331-001.md",
    userStories: "USER-STORIES.md",
    risks: "RISK-ASSESSMENT.md"
  }
});

// 下次会话加载
const project = await serena.load({
  projectId: "project-001"
});

六、总结与展望

6.1 核心价值

效率提升

  • 传统需求分析:数天到数周
  • AI 辅助需求发现:数小时到一天

质量保证

  • 系统性提问,避免遗漏
  • 多角色分析,全面覆盖
  • 可行性验证,降低风险

标准化

  • 统一的流程和模板
  • 可复用的最佳实践
  • 知识沉淀和传承

6.2 适用场景

场景 推荐策略 探索深度
新产品 systematic deep
功能迭代 agile normal
企业系统 enterprise deep
快速验证 agile shallow
复杂系统 systematic deep

6.3 未来方向

更智能的分析

  • AI 自动识别矛盾需求
  • 智能推荐最佳实践
  • 自动生成技术方案

更好的协作

  • 多人实时协作探索
  • 团队需求评审
  • 自动生成演示文稿

更深的集成

  • 直接对接项目管理工具(Jira、Trello)
  • 自动创建开发任务
  • 持续跟踪需求变更

七、快速参考

7.1 命令速查

# 启动需求发现
/sc:brainstorm "项目想法"

# 系统性探索(复杂项目)
/sc:brainstorm "企业级应用" --strategy systematic --depth deep

# 敏捷探索(快速验证)
/sc:brainstorm "新功能" --strategy agile --depth shallow

# 并行分析(多维度)
/sc:brainstorm "跨平台应用" --parallel

7.2 模板速查

需求文档模板

# 项目需求文档

## 1. 项目概述
- 背景
- 目标
- 价值

## 2. 功能需求
- 核心功能
- 辅助功能

## 3. 非功能需求
- 性能
- 安全
- 可用性

## 4. 用户故事
- 故事1
- 故事2

## 5. 开放问题
- 待确认
- 风险项

7.3 检查清单

# 需求发现检查清单

## 探索阶段
- [ ] 核心问题识别
- [ ] 目标用户定义
- [ ] 业务价值明确

## 分析阶段
- [ ] 多角色分析完成
- [ ] 技术可行性评估
- [ ] 风险识别

## 验证阶段
- [ ] 可行性报告生成
- [ ] 优先级排序
- [ ] MVP 范围确定

## 生成阶段
- [ ] 需求文档完整
- [ ] 用户故事清晰
- [ ] 验收标准明确

## 移交阶段
- [ ] 交付物清单
- [ ] 下一步计划
- [ ] 相关人员确认

作者:PaPaBot
日期:2026-03-31
标签:需求发现、AI 辅助、Brainstorm、MCP

相关文章

Views: 23

Claude Code——终端里的全能编程 Agent

引言:AI 编程工具的新纪元

2026年,AI 编程工具已经从"代码补全"进化到"真正的编程伙伴"。在众多工具中,Claude Code 以其独特的"终端 Agent"定位脱颖而出。它不是简单的代码补全工具,而是一个能够理解你的代码库、自主执行任务、验证编译结果的全能工程师。

核心差异

  • Cursor:"你告诉 AI 改什么,AI 帮你改"(辅助驾驶)
  • Claude Code:"你告诉 AI 你想要什么结果,AI 自己去读文件、写代码、跑命令、提交 Git"(自动驾驶)

这种差异让 Claude Code 更接近一个真实的软件工程师——它能独立完成从需求理解到代码验证的完整流程。


一、Claude Code 是什么?

Claude Code 是 Anthropic 推出的终端 AI 编程工具,具有以下特点:

1.1 核心能力

能力 说明
代码理解 自动读取项目结构、分析依赖关系、理解代码上下文
代码生成 根据需求生成符合项目规范的代码(遵循 CLAUDE.md)
命令执行 自动运行 npm、git、maven 等命令
自我验证 编译失败会自动修复,直到代码能运行
Git 集成 自动提交代码、创建分支、处理冲突

1.2 技术架构

Claude Code 架构
├── 核心引擎:Claude 3.7 Sonnet
├── 工具集成
│   ├── 文件系统(读/写)
│   ├── Shell 命令执行
│   ├── Git 操作
│   └── 编译器/测试框架
├── 上下文管理
│   ├── 项目结构分析
│   ├── 依赖关系图
│   └── 代码语义理解
└── 权限系统
    ├── 沙箱模式(默认)
    └── 全权模式(--dangerously-skip-permissions)

1.3 与传统工具的对比

特性 Claude Code Cursor GitHub Copilot
操作方式 终端对话 + 自主执行 IDE 内嵌,手动确认 IDE 内嵌,代码补全
自主程度 ⭐⭐⭐⭐⭐ 高 ⭐⭐⭐ 中 ⭐⭐ 低
适用场景 批量修改、完整功能、重构 边写边改、逐行补全 代码补全、简单建议
IDE 依赖 ❌ 无(任何编辑器) ✅ 必须用 Cursor ✅ 需要插件
自我验证 ✅ 自动编译测试 ❌ 需手动验证 ❌ 无

二、安装与认证

2.1 安装要求

  • Node.js: 21+ (推荐 22+)
  • 操作系统: macOS / Linux / Windows
  • 网络: 需要访问 Anthropic API

2.2 安装方式

方式一:官方脚本(推荐)

# macOS / Linux
curl -fsSL https://claude.ai/install.sh | bash

# Windows(PowerShell)
irm https://claude.ai/install.ps1 | iex

方式二:包管理器

# Homebrew(macOS / Linux)
brew install --cask claude-code

# WinGet(Windows)
winget install Anthropic.ClaudeCode

方式三:NPM(已废弃)

# 不推荐,官方已标记为 deprecated
npm install -g @anthropic-ai/claude-code

2.3 认证流程

首次运行 claude 会自动引导认证:

  1. 选择认证方式

    • Anthropic 账号登录
    • API Key 认证
  2. 设置预算上限(重要!):

    # 建议设置每日预算
    claude config set max-daily-cost 10  # 美元
  3. 验证安装

    claude --version
    claude /help

2.4 价格说明

  • 计费方式: 按 Token 计费(使用 Claude 3.7 Sonnet)
  • 成本估算:
    • 日常编码任务:$2-5/天(比 Copilot 订阅便宜)
    • 复杂重构任务:$10-20/次(注意预算上限)
  • 省钱技巧:
    • 使用 /clear 清除上下文
    • 使用 /compact 压缩对话历史
    • 避免长会话(每个独立任务重新开始)

三、三种核心用法

3.1 交互式对话模式(最常用)

在项目目录下启动:

cd my-project
claude

进入交互式会话后,可以直接用自然语言对话:

你: 实现一个用户签到功能,包括 API、数据库表、前端组件

Claude: 好的,我来实现签到功能。首先让我分析一下项目结构...

[Claude 自动执行]
⏺ Search(pattern: "src/**/*.ts")
⏺ Read(src/models/User.ts)
⏺ Read(src/api/auth.ts)
⏺ Create(src/models/CheckIn.ts)
⏺ Create(src/api/checkin.ts)
⏺ Update(src/database/schema.sql)
⏺ Bash(npm run build)
⏺ Bash(npm test)

✅ 签到功能已完成,包括:
- 数据库表:checkins(id, user_id, check_in_time, points)
- API:POST /api/checkin
- 前端组件:CheckInButton.tsx
- 测试覆盖率:85%

关键差异:Claude Code 会真的去读你的文件、修改代码、跑命令,而不是把代码粘贴给你让你自己改。

3.2 单次任务模式(非交互)

适合写脚本或 CI/CD 集成:

# 单次执行任务
claude "重构 UserService,使用依赖注入"

# 在 CI 中使用
claude --non-interactive "检查代码风格并修复所有 lint 错误"

应用场景

  • 自动化代码审查
  • 批量重构
  • CI/CD 流程中的代码生成
  • 定时任务(如每日代码优化)

3.3 全权委托模式(高级)

⚠️ 警告:此模式不会询问确认,直接执行所有操作!

claude --dangerously-skip-permissions

使用建议

  • 适用场景:新功能开发、原型验证
  • 禁止场景:生产环境、重要数据、核心模块

建议

在新功能开发时用这个,别在生产代码上不经确认直接跑。这个模式就是字面意思的"全权委托",很爽,也要负责任地用。


四、实战:从零实现一个功能

4.1 场景描述

让 Claude Code 从零实现一个「用户签到」功能,包括:

  • 数据库表设计
  • 后端 API
  • 前端组件
  • 单元测试

4.2 执行流程

启动 Claude Code,描述需求:

你: 实现用户签到功能,要求:
1. 每天只能签到一次
2. 连续签到有额外积分奖励
3. 提供 API 和前端组件
4. 需要单元测试

Claude Code 的处理流程(你会在终端里实时看到):

⏺ 分析项目结构...
⏺ Search(pattern: "src/**/*.ts")
⏺ Read(src/models/User.ts)
⏺ Read(src/api/auth.ts)
⏺ Read(src/database/schema.sql)

⏺ 设计数据库表...
⏺ Create(src/models/CheckIn.ts)
  - id: UUID
  - user_id: UUID
  - check_in_time: TIMESTAMP
  - points: INTEGER
  - streak_days: INTEGER

⏺ 实现 API...
⏺ Create(src/api/checkin.ts)
  - POST /api/checkin
  - GET /api/checkin/status
  - GET /api/checkin/history

⏺ 创建前端组件...
⏺ Create(src/components/CheckInButton.tsx)
⏺ Create(src/components/CheckInHistory.tsx)

⏺ 编写测试...
⏺ Create(tests/checkin.test.ts)

⏺ 验证实现...
⏺ Bash(npm run build)
  ✅ Build successful

⏺ Bash(npm test)
  ✅ Tests passed (12/12)

✅ 签到功能已完成!

整个过程 1-2 分钟,它会自己读项目结构、对齐包名、编译验证。通常在它跑的时候喝杯水。

4.3 自动纠错循环

如果编译失败,它会自己修:

⏺ Bash(npm run build)
  ❌ Error: Cannot find module '@/models/User'

⏺ 修复导入路径...
⏺ Update(src/api/checkin.ts)
  - import { User } from '@/models/User'
  + import { User } from '../models/User'

⏺ Bash(npm run build)
  ✅ Build successful

这就是和 Cursor 的本质区别:Cursor 给你改完代码,跑不跑得通你自己去 IDE 里看;Claude Code 改完会自己验证,不行自己继续修。


五、核心杀手锏:无限自我纠错循环

5.1 工作流程图

用户描述需求
    ↓
Claude Code 分析项目
    ↓
读取相关文件
    ↓
生成/修改代码
    ↓
编译验证 ──→ 失败 ──→ 自动修复 ──→ 重新编译
    ↓ 成功
返回结果给用户

5.2 实际案例

场景:重构一个模块,涉及 20 个文件的包名修改

Cursor 方式

  1. 你告诉 AI 改哪些文件
  2. AI 逐个修改
  3. 你手动去 IDE 里跑编译
  4. 发现错误,再告诉 AI 改
  5. 循环直到成功

Claude Code 方式

  1. 你说"重构这个模块的包名"
  2. Claude Code 自动:
    • 分析所有依赖文件
    • 批量修改 20 个文件
    • 运行编译
    • 发现错误自动修复
    • 循环直到编译成功
  3. 你喝茶等待 2 分钟,任务完成

5.3 纠错策略

Claude Code 的纠错策略包括:

  1. 导入路径修复:自动对齐项目包结构
  2. 类型错误修复:根据 TypeScript 错误自动调整类型
  3. 依赖安装:缺少包会自动 npm install
  4. 测试修复:测试失败会自动修改代码
  5. Lint 修复:自动运行 eslint --fix

六、常用斜杠命令

6.1 生存指南

命令 作用 使用频率
/help 查看所有可用命令 偶尔
/clear 清除当前对话上下文,开始新任务 ⭐⭐⭐⭐⭐ 极高
/compact 压缩对话历史(减少 Token 消耗) ⭐⭐⭐⭐ 高
/cost 查看当前会话消耗了多少 Token 和费用 ⭐⭐⭐ 中
/bug 报告 Claude Code 的 Bug 偶尔
/exitCtrl+C 退出 每次结束

6.2 最爱的命令:/clear

为什么最常用?

你: 实现功能 A
Claude: [完成功能 A]

你: /clear  ← 清除上下文

你: 实现功能 B
Claude: [完成功能 B,不会受功能 A 的干扰]

好处

  1. 防止干扰:旧上下文不会影响新任务
  2. 节省 Token:减少不必要的上下文传递
  3. 提高准确性:AI 不会被旧任务误导

最佳实践:每完成一个独立任务就 /clear 一次。

6.3 /compact 的妙用

长会话时,对话历史会越来越长,消耗大量 Token。/compact 会智能压缩:

原对话(5000 tokens):
你: 修改文件 A
Claude: [修改 A]
你: 修改文件 B
Claude: [修改 B]
...(50 轮对话)

压缩后(500 tokens):
已完成的任务:
- 修改了文件 A、B、C...
- 当前状态:项目可编译
- 下一步:等待用户指令

七、CLAUDE.md——给 Claude Code 的项目规范

7.1 什么是 CLAUDE.md?

和 Cursor 的 .cursorrules 一样,Claude Code 支持在项目根目录放一个 CLAUDE.md 文件,每次启动都会自动读取这份规范。

作用

  • 定义项目技术栈
  • 规定代码风格
  • 约定命名规范
  • 禁止某些操作

7.2 完整示例

# CLAUDE.md

## 项目信息
- Java 21 + Spring Boot 3.5.11 + Spring AI 1.1.2
- 包名:com.jichi.agent
- 构建工具:Maven

## 代码规范
- 使用 @Slf4j 打日志,不用 System.out.println
- DTO 用 Java Record
- 构造器注入,不用 @Autowired 字段注入
- 异常用 ResponseStatusException,统一在 @RestControllerAdvice 处理
- 每个类头部必须有 package 声明和完整 import

## Spring AI 规范
- ChatModel 注入用 @Qualifier("dashScopeChatModel")
- 不用 ChatClient.Builder,直接注入 ChatModel 再 build
- SearchRequest 用 builder 模式:SearchRequest.builder().query(q).topK(5).build()

## 禁止事项
- 不要生成任何测试类(我们有独立的测试模块)
- 不要修改 pom.xml 里已有的依赖版本
- 代码注释用中文

## 数据库规范
- 表名用下划线命名:user_checkins
- 主键用 UUID
- 必须有 created_at 和 updated_at 字段
- 软删除用 deleted_at 字段

## API 规范
- RESTful 风格
- 统一返回格式:Response<T>
- 错误码遵循 HTTP 标准

7.3 CLAUDE.md 的好处

  1. 代码风格统一:生成的代码像你自己人写的
  2. 减少沟通成本:不用每次都重复说明规范
  3. 项目活文档:新人加入可以读这个文件快速了解规范
  4. 提高效率:AI 第一次就生成符合规范的代码

7.4 最佳实践

写得越具体,代码越符合你的项目风格

❌ 不好的例子:
## 代码规范
- 写好代码

✅ 好的例子:
## 代码规范
- 使用 @Slf4j 打日志,不用 System.out.println
- DTO 用 Java Record
- 构造器注入,不用 @Autowired 字段注入

八、Claude Code vs Cursor——怎么选?

8.1 核心差异对比

维度 Claude Code Cursor
操作方式 终端对话 + 自主执行 IDE 内嵌,需要手动确认改动
适用场景 批量修改、完整功能实现、重构 边写边改、逐行补全、精细调整
IDE 依赖 无,任何编辑器都能配合 必须用 Cursor IDE
自主程度 高,能自己跑命令、验证编译 中,改完代码需要你自己跑
上手难度 低,终端直接用 低,GUI 操作
价格 按 Token 计费 订阅制($20/月)

8.2 使用场景建议

选择 Claude Code 的场景

  • ✅ 批量修改 20+ 文件
  • ✅ 从零实现完整功能
  • ✅ 重构整个模块
  • ✅ CI/CD 集成
  • ✅ 不想绑定特定 IDE

选择 Cursor 的场景

  • ✅ 日常开发中的逐步实现
  • ✅ 逐行代码补全
  • ✅ 精细调整代码
  • ✅ 需要实时预览
  • ✅ 习惯 GUI 操作

8.3

实际工作流

两个工具我都在用,效率是真的高:

  • Cursor 负责:日常开发中的逐步实现、边写边改、逐行补全
  • Claude Code 负责:"大块头"任务——重构模块、批量修改、从需求生成完整功能

两个一起用,互补性强。

8.4 决策树

你的任务是什么?
├─ 批量修改 10+ 文件 → Claude Code
├─ 从零实现新功能 → Claude Code
├─ 重构模块 → Claude Code
├─ CI/CD 自动化 → Claude Code
├─ 逐行补全代码 → Cursor
├─ 精细调整逻辑 → Cursor
└─ 实时预览效果 → Cursor

九、生态工具介绍

9.1 ccswitch

简介:ccswitch 是 Claude Code 的模型切换工具,支持在不同 Claude 模型之间动态切换。

GitHubhttps://github.com/sst/ccswitch

功能

  • 动态切换 Claude 模型(Sonnet / Opus / Haiku)
  • 根据任务复杂度自动选择模型
  • 成本优化(简单任务用 Haiku,复杂任务用 Opus)

使用方法

# 安装
npm install -g ccswitch

# 配置
ccswitch config set default-model claude-3-5-sonnet

# 使用
ccswitch "实现用户登录功能"

应用场景

  • 简单任务(如格式化代码)→ 自动切换到 Haiku(便宜)
  • 复杂任务(如架构设计)→ 自动切换到 Opus(强大)
  • 日常编码 → 默认 Sonnet(平衡)

9.2 cloudcli

简介:cloudcli 是 Claude Code 的云服务集成工具,支持将 Claude Code 部署到云端。

功能

  • 云端运行 Claude Code(无需本地安装)
  • 团队共享配置
  • 云端会话管理
  • API 接口(集成到其他工具)

使用方法

# 安装
npm install -g @cloudcli/cli

# 登录
cloudcli login

# 创建云端会话
cloudcli session create --project my-project

# 执行任务
cloudcli run "重构 UserService"

应用场景

  • 团队协作:共享 Claude Code 配置
  • CI/CD:在云端自动运行
  • 远程开发:无需本地资源

9.3 其他生态工具

9.3.1 claude-code-plugins

官方插件仓库https://github.com/anthropics/claude-code/tree/main/plugins

常用插件

  • plugin-git-enhanced:增强 Git 操作
  • plugin-docker:Docker 集成
  • plugin-testing:测试框架集成
  • plugin-docs:自动生成文档

使用方法

# 安装插件
claude plugin install git-enhanced

# 使用插件
claude --plugin git-enhanced "创建发布分支"

9.3.2 claude-code-monitor

功能:监控 Claude Code 的使用情况和成本

# 安装
npm install -g claude-code-monitor

# 启动监控
claude-code-monitor

# 查看统计
claude-code-monitor stats

输出示例

今日统计(2026-03-29):
- 任务数:15
- Token 消耗:125,432
- 成本:$3.21
- 最常用命令:/clear (12次)

9.3.3 MCP (Model Context Protocol) 集成

简介:Anthropic 推出的模型上下文协议,让 Claude Code 能访问外部工具和数据源

支持的工具

  • 数据库(PostgreSQL、MySQL)
  • API 服务
  • 文件系统
  • 云服务(AWS、GCP、Azure)

示例

# 配置 MCP 服务器
claude mcp add postgresql --connection-string "postgresql://..."

# 使用
claude "查询最近一周的用户数据"

十、最佳实践

10.1 任务描述技巧

好的描述

✅ 实现用户签到功能,要求:
1. 每天只能签到一次
2. 连续签到有额外积分奖励(7天+10分,30天+50分)
3. 提供 REST API:POST /api/checkin
4. 需要单元测试,覆盖率 > 80%
5. 使用现有的 User 模型

不好的描述

❌ 做个签到功能

差异

  • ✅ 明确需求、边界、技术细节
  • ❌ 太模糊,AI 会瞎猜

10.2 成本控制

技巧 1:使用 /clear

# 每完成一个任务就清除上下文
你: 实现功能 A
Claude: [完成]
你: /clear  ← 节省后续任务的 Token
你: 实现功能 B

技巧 2:使用 /compact

# 长会话时压缩历史
你: /compact
Claude: 对话历史已压缩(5000 tokens → 500 tokens)

技巧 3:设置预算上限

# 设置每日预算
claude config set max-daily-cost 10  # 美元

# 设置单次任务预算
claude config set max-task-cost 2  # 美元

10.3 安全建议

⚠️ 重要警告

  1. 不要在生产环境使用 --dangerously-skip-permissions
  2. 不要让 AI 访问敏感数据(密钥、密码、token)
  3. 定期检查 AI 生成的代码(可能有安全漏洞)
  4. 使用版本控制(Git),方便回滚

推荐流程

1. Claude Code 生成代码
2. 人工审查代码
3. 运行测试
4. 提交到 Git
5. 代码审查(Pull Request)
6. 合并到主分支

10.4 团队协作

共享 CLAUDE.md

# 团队共享项目规范
git add CLAUDE.md
git commit -m "添加 Claude Code 规范"
git push

统一配置

# 团队成员使用相同配置
claude config set default-model claude-3-5-sonnet
claude config set max-daily-cost 10

十一、常见问题

Q1: Claude Code 会取代程序员吗?

A: 不会。Claude Code 是工具,不是替代品。它擅长:

  • ✅ 重复性工作
  • ✅ 批量修改
  • ✅ 代码生成

但不擅长:

  • ❌ 架构设计
  • ❌ 业务理解
  • ❌ 创新思维

结论:它会让程序员更高效,但不会取代程序员。

Q2: 成本会不会很高?

A: 看使用方式。

  • 日常使用:$2-5/天(比 Copilot 便宜)
  • 复杂任务:$10-20/次(注意预算)
  • 省钱技巧:使用 /clear/compact、设置预算上限

Q3: Cursor 和 Claude 比,选哪个?

A: 工具定位不同:

工具 定位 价格
Cursor IDE + AI $20/月
Claude Code 终端 Agent 按量计费

Q4: 支持哪些编程语言?

A: 理论上支持所有语言,但擅长:

  • ✅ JavaScript/TypeScript
  • ✅ Python
  • ✅ Java
  • ✅ Go
  • ✅ Rust

对冷门语言支持较弱。

Q5: 数据安全吗?

A: Anthropic 的数据政策:

  • ✅ 对话数据加密存储
  • ✅ 不会用你的代码训练模型
  • ✅ 有限保留期(90天)
  • ✅ 符合 GDPR、SOC 2

但建议:

  • ❌ 不要让 AI 访问敏感数据
  • ✅ 使用本地模型(如 Ollama)处理敏感项目

十二、总结

12.1 Claude Code 的核心价值

  1. 真正的自动化:不是补全代码,而是完成整个任务
  2. 自我纠错:编译失败会自动修复
  3. 不绑定 IDE:任何编辑器都能用
  4. 项目规范:通过 CLAUDE.md 让 AI 遵循你的风格

12.2 适用人群

  • ✅ 专业开发者(提高效率)
  • ✅ 团队协作(共享规范)
  • ✅ CI/CD 自动化
  • ❌ 初学者(建议先用 Copilot 学习)

12.3 未来展望

Claude Code 代表了 AI 编程工具的新方向:从"辅助工具"到"真正的合作伙伴"。随着技术进步,我们可以期待:

  • 更强的理解能力:理解复杂业务逻辑
  • 更好的自主性:独立完成更复杂的任务
  • 更低的成本:模型优化降低使用成本
  • 更广的生态:更多插件和集成

附录:快速开始清单

安装(5分钟)

# 1. 安装
curl -fsSL https://claude.ai/install.sh | bash

# 2. 认证
claude

# 3. 设置预算
claude config set max-daily-cost 10

第一个任务(2分钟)

cd my-project
claude

你: 实现一个工具函数:格式化日期为 YYYY-MM-DD

Claude: [自动完成]

学习资源


结语

Claude Code 不是代码补全工具,而是一个真正帮你干活的工程师。它不会取代程序员,但会让程序员的工作效率提升 10 倍。

建议

先从简单任务开始,熟悉它的能力边界,再逐步应用到复杂场景。记住,工具再强,也需要人来驾驭。

Views: 150

工具全景——2026 年你需要认识的 AI 编程工具

2026 年你需要认识的 AI 编程工具

上一节聊了 Vibe Coding 是什么,这一节带大家认识一下当前主流的 AI 编程工具都有哪些、各自的定位是什么。

先说清楚:这里列的不是市面上所有工具,新工具隔几个月就冒一个,穷举没有意义。我们挑的是几类有代表性的,覆盖不同的使用场景和工作方式。

看完这节,你会对这个生态有个清晰的认知框架——以后遇到没见过的工具,自己也能判断它属于哪类、适合什么场景,不需要再来问"这个工具怎么样"。

至于最终用哪个,完全可以根据自己的习惯和需求自由选择,没有标准答案。

三类工具,三种思路

目前 AI 编程工具大致可以分三类,思路上有根本差异:

  • AI IDE 类:把编辑器本身重做,AI 功能深度内嵌进去,和代码编辑是一体的
  • IDE 插件类:在你现有的编辑器(IntelliJ、VS Code)上装一个插件,不换编辑器,只是增强
  • 终端 Agent 类:完全在命令行里工作,没有图形界面,AI 直接读文件、写文件、跑命令

这三类的核心差异不是能力强弱,而是工作方式不同。理解了这个,后面看具体工具就不容易混乱。

AI IDE 类:编辑器即 AI

Cursor:AI IDE 的标杆

基于 VS Code 魔改,目前 AI IDE 里最火的一个。

Agent 模式:你描述一个功能需求,它会自己规划任务、读相关文件、写代码、修 Bug,整个流程几乎不需要手动干预。这是和普通代码补全工具最大的区别。

Rules 系统:可以把项目的技术栈规范、代码风格写进 .cursor/rules/,AI 每次生成代码都会遵循这套规范,输出风格和项目保持一致。

这个模块里 Cursor 会是主角,后面几节会深度讲。

Windsurf:Cursor 的直接对手

原 Codeium 出品,2025 年经历了一轮收购风波(曾传出被 OpenAI 和 Google 接洽),最终以独立品牌继续运营。

主打"Cascade"流式编辑模式,思路和 Cursor 的 Agent 类似,界面比较干净。竞争压力下功能迭代明显加快,是 Cursor 目前最直接的竞争对手。

Trae:国内开发者的友好选择

字节跳动出品,国内用户友好,中文交互体验好,对国内开发者来说网络访问也更顺畅。2025 年持续迭代,免费策略比较激进。

IDE 插件类:在熟悉的环境里增强

GitHub Copilot:企业级首选

微软 + GitHub 出品,支持 IntelliJ、VS Code,是企业里用得最广的 AI 编程工具。

补全质量稳定:这几年积累了大量 Java 代码数据,补全体验扎实。最近加入的 Agent 功能(Copilot Workspace)也在持续增强。

IntelliJ 用户、企业团队环境里,Copilot 是首先会遇到的选项。

JetBrains AI Assistant:深度集成

JetBrains 官方出品,深度集成在 IntelliJ IDEA 里,支持代码补全、重构建议、测试生成、提交信息自动生成等功能。

对 Java 开发者来说,和 IDE 原生功能的结合是最流畅的——不用切换工具,直接在熟悉的环境里用。

2026 年已支持接入多个主流模型,是企业 Java 团队里越来越多被采用的选项。

Tabnine:私有化部署

老牌 AI 补全工具,特点是支持私有化部署——对数据合规要求高的企业(金融、医疗)来说,能在内网部署是很重要的能力。

终端 Agent 类:命令行里的 AI 工程师

Claude Code:大规模重构专家

Anthropic 出品,纯命令行 Agent,没有图形界面。

定位和 Cursor 不同——它更擅长大规模、跨文件的任务。比如"把整个项目的 DAO 层从 MyBatis 迁移到 JPA"这种需要同时修改几十个文件的工作,Claude Code 处理起来很顺手。

它会自己读现有代码结构、写文件、执行 mvn compile 验证、发现报错自己修——整个过程全自动。

这个模块里有专门一节讲 Claude Code,大家到时候跟着操作一遍就有感觉了。

Aider:开源可控

开源命令行 Agent,最大特点是可以接任意 LLM(OpenAI、Claude、本地模型都行)。对想自己控制底层模型、或者需要离线使用的场景比较有用。

OpenAI Codex CLI:沙箱安全

OpenAI 2025 年推出的终端编程 Agent,是 Claude Code 的直接对标。底层默认跑 o4-mini,需要更强推理能力时可以切 o3。

沙箱执行模式:它有三档安全级别:

  • suggest 模式:只给建议不动手
  • auto-edit:可以改文件但执行命令要你确认
  • full-auto:完全自主跑在沙箱里

codex "把这个模块的测试覆盖率跑到 80% 以上" 扔进去,它自己分析代码、生成测试、执行验证、报告结果,全程不用盯着——你可以放心让它跑 mvn testdocker build,出了问题沙箱隔离,不会影响宿主机。

和 Claude Code 怎么选? 两个都值得试一下。社区反馈 Claude Code 在复杂多步推理上略强,Codex CLI 在安全控制粒度上更细腻。大多数时候用哪个主要看你手头哪家的 API 账号更顺手。

一张全景图

类别 工具 特点 适用场景
AI IDE Cursor Agent 模式 + Rules 系统 从零开始的项目,需要深度 AI 辅助
AI IDE Windsurf Cascade 流式编辑 Cursor 的替代选择
AI IDE Trae 中文友好 + 免费策略激进 国内开发者
IDE 插件 GitHub Copilot 企业级 + 稳定补全 企业团队,IntelliJ 用户
IDE 插件 JetBrains AI 深度集成 IntelliJ Java 企业开发
IDE 插件 Tabnine 私有化部署 数据合规要求高的企业
终端 Agent Claude Code 大规模跨文件任务 重构、迁移、批量修改
终端 Agent Aider 开源可控 需要自定义底层模型
终端 Agent Codex CLI 沙箱安全 自动化测试、安全要求高

这个模块会重点讲哪些

这个模块的重点是 CursorClaude Code,原因很简单:这两个代表了两种不同的 AI 编程范式,学会这两个,其他工具上手都很快。

Copilot 的基本用法大家可以类比 Cursor,核心逻辑是一样的,只是嵌在 IntelliJ 里体验会不同。

其他工具如果大家感兴趣,可以根据这节的介绍自行探索,原理都相通。

写在最后:工具是手段,不是目的

最后想提醒一点:工具是手段,不是目的。

Vibe Coding 的核心是"用自然语言描述需求,让 AI 实现",而不是"必须用哪个工具"。

Cursor 好用,但如果你已经是 10 年 IntelliJ 老用户,强行切到 Cursor 反而降低效率——这种情况下,Copilot + JetBrains AI 可能更适合你。

Claude Code 强大,但如果你更习惯图形界面,强行用命令行只会增加认知负担。

选择工具的原则

  1. 熟悉度优先:在熟悉的工具上加 AI 功能,比重新学一个工具成本低
  2. 场景匹配:大规模重构用 Claude Code,日常开发用 Cursor 之类的产品。

本文是 Vibe Coding 系列的第二篇。关注这个系列,一起探索 AI 时代的编程新范式。

Views: 52

代码都不用看了?Vibe Coding 正在重塑编程的未来

代码都不用看了?Vibe Coding 正在重塑编程的未来

2025年,一种名为"Vibe Coding"的编程方式正在颠覆整个开发社区。前 OpenAI 联合创始人 Andrej Karpathy 的一条推文,让"跟着感觉走"成了年度热词。但这真的意味着程序员可以"不看代码"了吗?

当代码遇上直觉:Vibe Coding 的诞生

2025年2月,前 OpenAI 联合创始人、特斯拉 AI 前负责人 Andrej Karpathy 发了一条推文:

"There's a new kind of coding I call 'vibe coding', where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. I'm doing this all with voice now... I just tell Cursor what I want and it does it... It's not really coding—I barely read the code at all."

翻译过来:有一种新的编程方式叫 Vibe Coding。你完全顺着感觉走,拥抱指数级增长,甚至忘记代码的存在。我现在全用语音,只需要告诉 Cursor 我想要什么,它就帮我做到。这真的不是在写代码——我几乎不看代码。

这条推文像一颗石子投入平静的湖面,激起了2025年IT圈最大的涟漪。Collins词典甚至将其列为年度词汇候选之一。

从建筑工人到建筑师:编程角色的根本转变

核心变化只有一个:你不再写代码,你负责"说清楚你要什么"。

想象一下这个场景:

传统开发:你是一名建筑工人,每天搬砖、砌墙、安装水电管线。你熟悉每一块砖的重量,知道水泥和沙子的最佳配比,你的手上布满老茧,那是劳动的勋章。

Vibe Coding:你成为了一名建筑师。你不再亲手搬砖,而是站在图纸前,决定"这面墙要不要"、"这个房间做什么用"、"采光从哪里来"。你依然需要懂建筑逻辑,但你的价值从"执行"变成了"决策"。

这不是降级,而是升级——从决定"怎么做"跃升为决定"做什么"

Vibe Coding 的四大核心特征

Vibe Coding 不是魔法,它有明确的特征:

1. 自然语言驱动

  • 过去:if (user.isLoggedIn() && user.hasPermission("admin")) { ... }
  • 现在:"检查用户是否登录且有管理员权限"

你用中文或英文描述需求,AI 将你的描述翻译成代码。这不是偷懒,而是效率的革命。

2. 迭代优先

不追求第一次就完美。快速出原型,快速测试,快速调整。传统开发可能花3天写完一个功能,Vibe Coding 用3小时出第一版,然后通过5轮快速迭代达到同等质量。

3. 验证而非审查

关键转变:不逐行读代码,而是通过运行和测试来验证结果。你不需要知道AI用了什么设计模式,你只需要知道:功能是否正常?性能是否达标?安全是否可控?

4. AI 是执行层

你从程序员变成了架构师 + 产品经理。你决定"做什么"(what),AI 负责"怎么实现"(how)。这不是让你变得不重要,而是让你变得更重要——因为你要做的决策更关键。

数据不会撒谎:2026 年的现实

让我们看几组数据,感受这个趋势的猛烈程度:

数据 来源 意味着什么
YC Winter 2025 批次中,25% 的团队 95% 代码由 AI 生成 Y Combinator 官方报告 创业公司已经在用AI狂奔
超过 70% 的开发者已在日常工作中使用 AI 辅助编程 GitHub Octoverse 2025 这不是未来,是现在
Google 25% 的新代码由 AI 生成,并由工程师审查合并 Google 财报电话会议 巨头公司已经规模化应用
45% 的 AI 生成代码含安全漏洞 SAST 分析报告 效率提升了,但风险也来了

最后一条数据要特别注意:效率提升的同时,安全风险也在上升。这恰恰说明了为什么"懂技术"在 Vibe Coding 时代反而更重要。

Vibe Coding ≠ 代替程序员

很多人问:Vibe Coding 是不是就是用 AI 代替程序员?

不是的。

关键转变在于:技术理解力 >>> 代码手写能力

就像建筑师不需要亲自切菜,但他一眼就能看出食材新不新鲜、火候对不对。Vibe Coding 的正确姿势是:让 AI 生成,但你要能看出哪里不对

Java 开发者的隐藏优势

这里有个反直觉的真相:Java 开发者在 Vibe Coding 时代有独特优势

很多人觉得 Python 才是 AI 时代的王,Java 太重了。但事实恰恰相反。

优势一:生态成熟 = AI 的超级饲料

GPT、Claude 这些模型见过的 Java 代码数量是天文数字。Spring Boot、MyBatis、JPA、Hibernate、Maven、Gradle、Spring Cloud……这些框架的代码遍布 GitHub 的每一个角落。

AI 生成 Java 代码的质量,实际上相当高。为什么?因为它"吃"过的 Java 代码太多了。

优势二:强类型红线 = 自带 Code Review

Java 的强类型系统 + IDE 的即时红线提示,让 AI 生成的错误代码立刻暴露。

// AI 生成的错误代码
String userId = user.getId(); // 如果 getId() 返回 Long,IDE 瞬间标红!

在 Python 或 JavaScript 里,这种 Bug 可能要到运行时才发现。但在 Java 里,AI 的低级错误无处遁形。

优势三:企业主场 = 提效刚需

Java 在金融、电商、物流这些企业核心系统里份额极高。这些系统复杂度高、改动频繁、质量要求严——恰恰是 Vibe Coding 提效的最佳战场。

而这些系统的开发者,就是你。

优势四:架构思维 = 精准控局

Vibe Coding 对"我要什么架构"的表达依赖很高。Java 开发者大多有丰富的分层架构、设计模式经验,你在描述需求时天然更精准:

"用策略模式重构这个支付逻辑,支持微信、支付宝、银联三种渠道,每个渠道独立配置超时和重试策略。"

这种描述,AI 听得懂,也能执行好。而缺乏架构经验的人,可能只会说:"帮我写个支付功能",结果得到一堆面条代码。

"我几乎不看代码"的真相

Karpathy 说"我几乎不看代码",这句话需要加个注脚:

他是前 OpenAI 联合创始人,他"不看"并不代表他"不懂"。他是因为懂得太深,所以能快速判断 AI 输出的质量。

这就像米其林大厨不需要亲自切菜,但他一眼就能看出食材新不新鲜、火候对不对。

Vibe Coding 的正确姿势是:让 AI 生成,但你要能看出哪里不对。

这要求你有扎实的技术基础:

  • Java Core:理解 JVM、集合框架、并发编程
  • 算法导论:知道什么问题用什么算法解决
  • 计算机网络:理解 HTTP、TCP/IP、分布式通信
  • 数据库原理:懂索引、事务、隔离级别
  • 安全知识:知道 SQL 注入、XSS、CSRF 是什么

技术底子在,Vibe Coding 才能用好。 不然,你只是在盲目信任 AI 的输出,这是在踩坑。

写在最后:这只是开始

Vibe Coding 不是终点,而是新的起点。它让程序员从"搬砖工"变成了"建筑师",从"执行者"变成了"决策者"。

核心目标:日常开发效率提升 3-5 倍!

但这个转变需要准备:

  1. 扎实的技术底子:能看出AI代码的问题
  2. 清晰的思维表达:能准确描述"我要什么"
  3. 架构设计能力:知道"好的架构"长什么样
  4. 验证测试思维:通过测试而非审查来保证质量

接下来的系列文章中,我们将深入探讨:

  • Vibe Coding 的工具生态(Cursor、Claude Code、GitHub Copilot 等)
  • 如何用自然语言精准描述需求
  • AI 生成代码的安全审查实践
  • Java 项目中的 Vibe Coding 实战案例

准备好了吗?让我们开始这场编程范式的革命。


本文是 Vibe Coding 系列的第一篇。关注这个系列,一起探索 AI 时代的编程新范式。

Views: 34

Index