企业官网建设流程全解析

Claude Code 2.0 重构后，一个最显著的变化是它对“上下文工程”的理解和应用方式发生了根本性转变。过去，开发者习惯于在系统提示词（System Prompt）中堆砌冗长的规则、角色定义和格式要求，试图通过“微操”来精确控制 AI 的行为。但在 2.0 版本中，这种模式被彻底颠覆。核心思想从“用指令约束 AI”转向了“用结构引导 AI”，其关键载体就是claude.md和skills文件。这意味着，以往动辄数百上千字的系统提示词可以被大幅精简，甚至完全重构，将复杂的工程规则外置到结构化的文件中，让 AI 的上下文理解能力从“阅读理解题”变成了“填空题”，效率和准确性都得到了质的提升。

如果你正在使用 Claude Code 进行代码生成、重构或技术问答，却感觉提示词越来越臃肿，效果却不稳定，或者你听说过skills但不知如何入手，那么这篇文章正是为你准备的。本文将带你深入理解 Claude Code 2.0 上下文工程的新范式，通过一个从零开始的 Java 项目示例，演示如何利用claude.md和自定义skills来构建高效、可复用的开发工作流。你将学会如何将模糊的、文本化的要求，转化为清晰的、结构化的工程规则，从而让 Claude Code 真正成为你得心应手的“超级编程伙伴”。

1. 理解 Claude Code 2.0 上下文工程的核心变革

在深入实践之前，我们必须先厘清几个核心概念，以及它们为何代表了上下文工程的范式转移。

1.1 从“指令驱动”到“结构驱动”的范式转变

传统的 AI 编码辅助工具，其工作模式严重依赖于用户在对话中输入的即时指令。为了获得稳定、符合预期的输出，用户不得不编写极其详细、包含大量“如果……就……”逻辑的系统提示词。例如，一个传统的 Java 开发提示词可能包含：“请遵循 Google Java 代码风格，使用 Lombok 注解减少样板代码，Controller 层方法必须添加@RestController和@RequestMapping，Service 层需要注入 Repository……”。这种模式存在几个致命问题：

1. 上下文消耗巨大：冗长的系统提示词会占用宝贵的上下文窗口（Token），挤占用于分析实际代码的空间。
2. 规则冲突与遗忘：随着对话轮次增加，AI 可能遗忘或混淆早期设定的复杂规则。
3. 缺乏可复用性：针对不同项目或技术栈，需要重新编写或大幅修改提示词，难以沉淀为团队资产。

Claude Code 2.0 引入的claude.md和skills机制，正是为了解决这些问题。它的核心理念是：将稳定的、项目级的工程约束和知识，从易变的对话上下文中剥离出来，固化为项目目录下的结构化文件。AI 在分析你的请求时，会优先参考这些本地文件中的规则，而不是完全依赖历史对话中的文本指令。

1.2 核心文件：claude.md 与 skills 的角色定义

• claude.md：这是你项目的“宪法”或“总纲”。它定义了项目的基本规则、技术栈偏好、代码风格和全局约束。你可以把它想象成一个超级浓缩、结构化的“项目 README + 编码规范”。AI 在响应任何与项目相关的问题时，都会首先查阅这个文件。
• skills：这是你的“技能工具箱”或“最佳实践库”。一个skill是一个独立的、可执行的指令模板或代码模式。它比claude.md中的规则更具体，用于完成特定的、重复性的开发任务。例如，“创建一个 Spring Boot REST Controller”可以是一个 skill，“为实体类生成 JPA 注解和 DTO”可以是另一个 skill。

这种分工带来了清晰的责任边界：claude.md管“是什么”和“不能做什么”（静态规则），而skills管“怎么做”（动态模板）。

1.3 新旧模式对比：为什么系统提示词可以大幅删减

下表清晰地展示了新旧两种模式在处理同一需求（“创建一个用户管理模块”）时的差异：

因此，在 2.0 版本中，你的系统提示词可以精简到只包含最核心的、与会话强相关的临时指令，例如：“请基于当前项目的claude.md和skills，帮我实现用户登录功能。” 绝大部分工程规则，都已经在项目文件中定义好了。

2. 环境准备与项目初始化

在开始编写规则之前，我们需要一个干净的项目环境。这里以一个典型的 Spring Boot 后端项目为例。

2.1 基础环境与工具确认

确保你的开发环境已就绪：

• IDE: Visual Studio Code (VS Code) 是 Claude Code 插件的原生运行环境。
• Claude Code 插件: 在 VS Code 扩展商店中搜索 “Claude Code” 并安装最新版本。
• Java 开发环境: JDK 11 或以上版本，Maven 或 Gradle 构建工具。
• 项目：一个空的或已有的 Spring Boot 项目目录。

打开 VS Code，并导航到你的项目根目录。在终端中，你可以通过以下命令快速验证环境：

# 检查 Java 版本 java -version # 检查 Maven 版本（如果使用Maven） mvn -v # 检查 Claude Code 插件是否激活 # 通常可以在 VS Code 左侧活动栏看到 Claude Code 的图标

2.2 创建核心配置文件：claude.md

在项目根目录下，创建一个名为claude.md的文件。这个文件将作为我们整个项目的“AI 开发规范”。

首先，我们写入最基础的框架约束和技术栈声明：

# 项目 AI 开发规范 (claude.md) ## 项目概述 - **项目名称**: 用户中心微服务 (User-Center-Microservice) - **核心框架**: Spring Boot 2.7.x - **构建工具**: Maven - **Java 版本**: 11 - **持久层**: Spring Data JPA + Hibernate - **数据库**: MySQL 8.0 - **API 风格**: RESTful API ## 代码风格与规范 - **代码风格**: 严格遵守 Google Java 代码风格。 - **包结构**: - `com.example.usercenter.controller`: 控制器层 - `com.example.usercenter.service`: 业务逻辑层 - `com.example.usercenter.repository`: 数据访问层 - `com.example.usercenter.model.entity`: 实体类 - `com.example.usercenter.model.dto`: 数据传输对象 - `com.example.usercenter.model.vo`: 视图对象（用于API响应） - `com.example.usercenter.config`: 配置类 - `com.example.usercenter.common`: 通用工具、常量、异常 - **命名约定**: - 实体类: 大写驼峰，名词，如 `User`, `UserProfile` - Service 接口: `XxxService` - Service 实现类: `XxxServiceImpl` - Controller: `XxxController` - Repository: `XxxRepository` - DTO: `XxxDTO` (入参), `XxxVO` (出参) ## 技术栈特定规则 ### Spring Boot - 使用 `@RestController` 而非 `@Controller`。 - 依赖注入优先使用构造函数注入 (`@Autowired` on constructor)。 - API 路径前缀统一为 `/api/v1/`。 ### Spring Data JPA - 实体类必须使用 `@Entity` 注解。 - 必须定义主键 `@Id` 和生成策略 `@GeneratedValue`。 - 关联关系注解 (`@OneToMany`, `@ManyToOne` 等) 需明确指定 `fetch` 类型和 `cascade` 策略，避免 N+1 问题。 - 查询方法名需遵循命名约定，复杂查询使用 `@Query`。 ### 通用开发约束 - **禁止** 在 Controller 中编写业务逻辑。 - **禁止** 在循环中进行数据库查询。 - **必须** 对所有 Service 方法进行事务管理 (`@Transactional`)。 - **必须** 对所有的 REST API 出参使用统一的响应包装器 `Result<T>`。 - **必须** 使用 Slf4j 进行日志记录，不同级别 (`INFO`, `WARN`, `ERROR`) 用于不同场景。 - **推荐** 使用 MapStruct 进行 DTO/Entity 转换。 ## 与 AI 协作的特别说明 - 当你被要求创建或修改代码时，请首先参考本文件中的规范。 - 如果遇到规范未涵盖的情况，请遵循 Spring Boot 和 Java 社区的最佳实践。 - 生成代码后，请简要说明关键部分是如何遵循上述规范的。

这个claude.md文件已经定义了一个清晰的框架。AI 在生成代码时，会主动去匹配这些规则，比如自动将 Controller 放在正确的包下，使用构造函数注入等。

注意：claude.md是静态规则，它不包含具体的代码模板。接下来，我们将用skills来补充动态模板。

3. 构建你的技能库：定义与使用 Skills

Skills是 Claude Code 2.0 的“超级武器”。它们本质上是保存在项目.claude目录下的文件，每个文件描述了一个可重复使用的操作模式。

3.1 创建 Skill 目录与基础 Skill

首先，在项目根目录下创建.claude文件夹（注意开头的点）。然后，我们创建第一个 skill 文件：.claude/create_rest_controller.skill.yml。

我们选择 YAML 格式来定义 skill，因为它结构清晰，易于阅读和编写。

# .claude/create_rest_controller.skill.yml name: create_rest_controller description: 根据给定的实体名称，创建一个符合项目规范的 Spring Boot REST Controller。 inputs: - name: entity_name description: 实体类的名称（英文，单数，如 User, Product） required: true steps: - action: generate_file path: "src/main/java/com/example/usercenter/controller/{{inputs.entity_name}}Controller.java" content: | package com.example.usercenter.controller; import com.example.usercenter.common.Result; import com.example.usercenter.model.dto.{{inputs.entity_name}}DTO; import com.example.usercenter.model.vo.{{inputs.entity_name}}VO; import com.example.usercenter.service.{{inputs.entity_name}}Service; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.*; import javax.validation.Valid; import java.util.List; /** * {{inputs.entity_name}} 控制器。 */ @Slf4j @RestController @RequiredArgsConstructor @RequestMapping("/api/v1/{{inputs.entity_name|lowercase}}s") public class {{inputs.entity_name}}Controller { private final {{inputs.entity_name}}Service {{inputs.entity_name|lowercase}}Service; @PostMapping public Result<{{inputs.entity_name}}VO> create(@Valid @RequestBody {{inputs.entity_name}}DTO dto) { log.info("创建{{inputs.entity_name}}请求: {}", dto); {{inputs.entity_name}}VO vo = {{inputs.entity_name|lowercase}}Service.create(dto); return Result.success(vo); } @GetMapping("/{id}") public Result<{{inputs.entity_name}}VO> getById(@PathVariable Long id) { {{inputs.entity_name}}VO vo = {{inputs.entity_name|lowercase}}Service.getById(id); return Result.success(vo); } @GetMapping public Result<List<{{inputs.entity_name}}VO>> listAll() { List<{{inputs.entity_name}}VO> list = {{inputs.entity_name|lowercase}}Service.listAll(); return Result.success(list); } @PutMapping("/{id}") public Result<{{inputs.entity_name}}VO> update(@PathVariable Long id, @Valid @RequestBody {{inputs.entity_name}}DTO dto) { log.info("更新{{inputs.entity_name}}请求，ID: {}, 数据: {}", id, dto); {{inputs.entity_name}}VO vo = {{inputs.entity_name|lowercase}}Service.update(id, dto); return Result.success(vo); } @DeleteMapping("/{id}") public Result<Void> delete(@PathVariable Long id) { log.info("删除{{inputs.entity_name}}请求，ID: {}", id); {{inputs.entity_name|lowercase}}Service.delete(id); return Result.success(); } }

关键解释：

• name和description: 定义了 skill 的标识和用途。
• inputs: 定义了用户需要提供的参数。这里只需要一个实体名。
• steps: 定义了 skill 执行的动作序列。目前只有一个generate_file动作。
• path和content: 使用{{inputs.entity_name}}和过滤器|lowercase进行模板渲染，根据输入动态生成文件路径和内容。内容严格遵循了claude.md中定义的包结构、注解、命名和响应格式。

3.2 在 VS Code 中激活并使用 Skill

创建好 skill 文件后，Claude Code 插件会自动识别它们。在 VS Code 中打开 Claude Code 聊天面板，你现在可以这样使用它：

你（在聊天框输入）:

使用 skill: create_rest_controller，实体名称为 Product。

Claude Code 的响应:

1. 它会识别到你要使用create_rest_controller这个 skill。
2. 它会发现需要参数entity_name，并确认你提供的值是Product。
3. 然后，它会在内存中根据模板生成代码，并展示给你预览，同时询问你是否确认创建文件src/main/java/com/example/usercenter/controller/ProductController.java。
4. 你确认后，文件才会被实际写入项目。

这个过程将创建 Controller 这个重复性劳动，从“描述需求 -> AI 理解 -> 生成代码 -> 人工检查”的模糊流程，变成了“调用技能 -> 填充参数 -> 预览确认”的精准流水线。一致性极高。

3.3 创建配套的 Service 和 DTO Skill

一个完整的 CRUD 通常需要 Controller、Service、DTO 和 Entity。我们可以创建配套的 skills。

创建.claude/create_service_interface.skill.yml:

name: create_service_interface description: 创建 Service 层接口。 inputs: - name: entity_name description: 实体类的名称 required: true steps: - action: generate_file path: "src/main/java/com/example/usercenter/service/{{inputs.entity_name}}Service.java" content: | package com.example.usercenter.service; import com.example.usercenter.model.dto.{{inputs.entity_name}}DTO; import com.example.usercenter.model.vo.{{inputs.entity_name}}VO; import java.util.List; /** * {{inputs.entity_name}} 业务逻辑接口。 */ public interface {{inputs.entity_name}}Service { /** * 创建。 */ {{inputs.entity_name}}VO create({{inputs.entity_name}}DTO dto); /** * 根据ID查询。 */ {{inputs.entity_name}}VO getById(Long id); /** * 查询所有。 */ List<{{inputs.entity_name}}VO> listAll(); /** * 更新。 */ {{inputs.entity_name}}VO update(Long id, {{inputs.entity_name}}DTO dto); /** * 删除。 */ void delete(Long id); }

创建.claude/create_dto.skill.yml:

name: create_dto description: 创建数据传输对象 (DTO)。 inputs: - name: entity_name description: 实体类的名称 required: true - name: fields description: | 字段列表，每行一个，格式为 `类型:字段名:描述`。 例如： String:username:用户名 String:email:邮箱 Integer:age:年龄 required: true steps: - action: generate_file path: "src/main/java/com/example/usercenter/model/dto/{{inputs.entity_name}}DTO.java" content: | package com.example.usercenter.model.dto; import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModelProperty; import lombok.Data; import javax.validation.constraints.*; /** * {{inputs.entity_name}} 创建/更新请求 DTO。 */ @Data @ApiModel(description = "{{inputs.entity_name}}请求数据") public class {{inputs.entity_name}}DTO { {% for field in inputs.fields.split("\n") %} {% set parts = field.split(":") %} {% if parts|length >= 2 %} @ApiModelProperty(value = "{{ parts[2] if parts|length > 2 else parts[1] }}") {% if parts[0] == "String" %} @NotBlank(message = "{{ parts[1] }}不能为空") {% elif parts[0] == "Integer" or parts[0] == "Long" %} @NotNull(message = "{{ parts[1] }}不能为空") {% endif %} private {{ parts[0] }} {{ parts[1] }}; {% endif %} {% endfor %} }

这个 DTO skill 更复杂一些，它接受一个多行字符串fields，并使用简单的模板逻辑 ({% ... %}) 来循环生成字段和校验注解。这展示了 skills 可以处理复杂的、结构化的输入。

现在，你可以通过组合使用这些 skills 来快速搭建一个模块：

1. 使用 skill: create_dto，实体名称为 Product，字段为...
2. 使用 skill: create_service_interface，实体名称为 Product
3. 使用 skill: create_rest_controller，实体名称为 Product

4. 高级技巧：组合 Skill 与动态上下文

当claude.md和基础 skills 就位后，你的系统提示词可以变得极其简洁。更重要的是，Claude Code 能智能地结合文件上下文。

4.1 利用现有代码上下文进行增强

假设你已经手动创建了Product实体类 (Product.java)。现在你想让 Claude Code 为你生成对应的ProductRepository。你不需要在 skill 里定义所有 JPA 规则，只需在聊天框提出请求：

请为 src/main/java/com/example/usercenter/model/entity/Product.java 这个实体类，创建一个符合项目规范的 Spring Data JPA Repository 接口。

Claude Code 会：

1. 读取你提到的Product.java文件，分析其中的类名、字段（尤其是@Id字段）。
2. 结合claude.md中关于包结构 (repository包) 和命名规范 (XxxRepository) 的规则。
3. 自动生成一个类似下面的ProductRepository.java并放置到正确位置：

package com.example.usercenter.repository; import com.example.usercenter.model.entity.Product; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface ProductRepository extends JpaRepository<Product, Long> { // 可以根据需要添加自定义查询方法 // Product findByName(String name); }

这就是“结构驱动”的威力：AI 不再需要你事无巨细地描述“创建一个继承 JpaRepository 的接口，泛型是 Product 和 Long，放在 repository 包下……”，它通过读取现有文件结构和claude.md规则，自己推导出了这一切。

4.2 创建更复杂的组合 Skill

你可以创建执行一连串动作的 skill。例如，一个“搭建完整 CRUD 模块”的 skill。

创建.claude/scaffold_crud_module.skill.yml:

name: scaffold_crud_module description: 为一个新实体搭建完整的 CRUD 模块（Entity需已存在）。 inputs: - name: entity_name description: 已存在的实体类名称 required: true steps: - action: run_skill skill_name: create_dto inputs: entity_name: "{{inputs.entity_name}}" fields: | String:name:名称 String:description:描述 BigDecimal:price:价格 Integer:stock:库存 - action: run_skill skill_name: create_service_interface inputs: entity_name: "{{inputs.entity_name}}" - action: generate_file path: "src/main/java/com/example/usercenter/service/{{inputs.entity_name}}ServiceImpl.java" content: | package com.example.usercenter.service; import com.example.usercenter.model.dto.{{inputs.entity_name}}DTO; import com.example.usercenter.model.entity.{{inputs.entity_name}}; import com.example.usercenter.model.vo.{{inputs.entity_name}}VO; import com.example.usercenter.repository.{{inputs.entity_name}}Repository; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import javax.persistence.EntityNotFoundException; import java.util.List; import java.util.stream.Collectors; @Slf4j @Service @RequiredArgsConstructor @Transactional public class {{inputs.entity_name}}ServiceImpl implements {{inputs.entity_name}}Service { private final {{inputs.entity_name}}Repository {{inputs.entity_name|lowercase}}Repository; @Override public {{inputs.entity_name}}VO create({{inputs.entity_name}}DTO dto) { {{inputs.entity_name}} entity = new {{inputs.entity_name}}(); BeanUtils.copyProperties(dto, entity); {{inputs.entity_name}} savedEntity = {{inputs.entity_name|lowercase}}Repository.save(entity); return convertToVO(savedEntity); } @Override public {{inputs.entity_name}}VO getById(Long id) { {{inputs.entity_name}} entity = {{inputs.entity_name|lowercase}}Repository.findById(id) .orElseThrow(() -> new EntityNotFoundException("{{inputs.entity_name}} not found with id: " + id)); return convertToVO(entity); } @Override public List<{{inputs.entity_name}}VO> listAll() { return {{inputs.entity_name|lowercase}}Repository.findAll().stream() .map(this::convertToVO) .collect(Collectors.toList()); } @Override public {{inputs.entity_name}}VO update(Long id, {{inputs.entity_name}}DTO dto) { {{inputs.entity_name}} entity = {{inputs.entity_name|lowercase}}Repository.findById(id) .orElseThrow(() -> new EntityNotFoundException("{{inputs.entity_name}} not found with id: " + id)); BeanUtils.copyProperties(dto, entity); {{inputs.entity_name}} updatedEntity = {{inputs.entity_name|lowercase}}Repository.save(entity); return convertToVO(updatedEntity); } @Override public void delete(Long id) { if (!{{inputs.entity_name|lowercase}}Repository.existsById(id)) { throw new EntityNotFoundException("{{inputs.entity_name}} not found with id: " + id); } {{inputs.entity_name|lowercase}}Repository.deleteById(id); } private {{inputs.entity_name}}VO convertToVO({{inputs.entity_name}} entity) { {{inputs.entity_name}}VO vo = new {{inputs.entity_name}}VO(); BeanUtils.copyProperties(entity, vo); return vo; } } - action: run_skill skill_name: create_rest_controller inputs: entity_name: "{{inputs.entity_name}}" - action: generate_file path: "src/main/java/com.example.usercenter/model/vo/{{inputs.entity_name}}VO.java" content: | package com.example.usercenter.model.vo; import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModelProperty; import lombok.Data; import java.math.BigDecimal; import java.time.LocalDateTime; /** * {{inputs.entity_name}} 响应视图对象。 */ @Data @ApiModel(description = "{{inputs.entity_name}}响应数据") public class {{inputs.entity_name}}VO { @ApiModelProperty(value = "ID") private Long id; @ApiModelProperty(value = "名称") private String name; @ApiModelProperty(value = "描述") private String description; @ApiModelProperty(value = "价格") private BigDecimal price; @ApiModelProperty(value = "库存") private Integer stock; @ApiModelProperty(value = "创建时间") private LocalDateTime createTime; @ApiModelProperty(value = "更新时间") private LocalDateTime updateTime; }

这个组合 skill 通过run_skill动作调用了之前定义的 skills，并生成了 Service 实现类和 VO。现在，你只需要一个命令：使用 skill: scaffold_crud_module，实体名称为 Order，就能瞬间生成一个包含 DTO、Service接口及实现、Controller、VO 的完整 CRUD 模块骨架，且完全符合项目规范。

5. 常见问题排查与最佳实践

将工程规则迁移到claude.md和skills后，你可能会遇到一些新问题。以下是典型的排查路径和建议。

5.1 常见问题与解决方案

5.2 最佳实践清单

为了最大化发挥 Claude Code 2.0 新特性的价值，请遵循以下实践：

1. claude.md宜精不宜多：优先写入最稳定、最普适的工程约束。避免将临时性的、项目特定阶段的规则写进去。可以将其视为“项目级编码规范”。
2. Skill 设计要“高内聚、低耦合”：一个 skill 只做好一件事。不要创建一个试图生成整个微服务的“巨无霸”skill。而是创建create_controller、create_service、create_repository等小 skill，然后通过组合 skill 来完成大任务。
3. Skill 输入参数要明确：使用description字段清晰描述每个参数的意义和格式。对于复杂参数（如字段列表），提供明确的示例。
4. 版本化管理你的 AI 工程资产：将claude.md和.claude/目录提交到 Git。这确保了团队协作时，所有人的 Claude Code 都遵循同一套规则，生成风格一致的代码。
5. 区分学习与生产：
   • 学习/探索：可以创建一些实验性的 skill，用于快速原型验证。
   • 生产开发：skill 模板应经过评审，确保其生成的代码符合安全、性能和可维护性要求。例如，生成的 Service 方法必须包含事务注解和适当的异常处理。
6. 定期维护和重构：随着项目技术栈升级（如 Spring Boot 从 2.x 升级到 3.x），需要同步更新claude.md和相关的 skill 模板。
7. 不要完全放弃对话：claude.md和skills处理的是“已知的、重复的”模式。对于复杂的、一次性的逻辑推理、代码审查或 bug 分析，仍然需要通过与 Claude Code 的自然语言对话来完成。两者是互补关系。

5.3 扩展方向：探索更强大的 Skills

当前的 skills 主要基于文件生成。Claude Code 的 skills 生态（有时通过 MCP - Model Context Protocol 扩展）正在快速发展，未来可以集成更多能力：

• 数据库操作：创建根据实体类生成初始化 SQL 的 skill。
• API 测试：生成针对新 Controller 的 Postman 集合或单元测试的 skill。
• 部署配置：生成 Dockerfile 或 Kubernetes YAML 的 skill。
• 代码重构：创建“将字段从String改为LocalDate并更新所有相关方法”的 refactor skill。

你可以关注 Claude Code 的官方文档和社区，了解如何编写和分享更高级的 skills。

Claude Code 2.0 的重构，本质上是将 AI 编程从“艺术”（依赖即兴、模糊的提示）转向“工程”（依赖结构、规则和模板）。通过投入时间精心设计你的claude.md和skills，你将在项目初期获得巨大的长期回报：更一致的代码、更快的开发速度、更低的沟通成本。最关键的下一步，不是学习更多复杂的 skill 语法，而是在你当前的项目中，挑选一个最重复、最规范的编码任务，尝试为它创建第一个.skill.yml文件，并体验从“描述它”到“调用它”的效率飞跃。