Prompt编写规范指引

1、📖 引言

随着人工智能生成内容（AIGC）技术的快速发展，越来越多的开发者开始利用AIGC工具来辅助代码编写。然而，如何编写有效的提示词（Prompt）以引导AIGC生成高质量的代码，成为了许多开发者面临的挑战。本文旨在为Java开发工程师提供一份详细的提示词编写指引，帮助大家更好地利用AIGC工具。

2、🧩 基本结构

一个标准的 Prompt 提示词应包含以下部分：

专业背景： 需要特定的技术栈（如 Java、Python、C++）或专业背景（如前端开发、数据分析师）

任务目标 ：简要描述代码的功能或目标。

背景信息 ：提供必要的背景信息，帮助 AIGC 理解需求。

功能描述 ：详细描述代码需要实现的功能。

输入输出 ：明确代码的输入和输出格式。

约束条件 ：列出代码需要遵守的约束条件，如性能要求、编码规范等。

使用示例 ：提供示例输入和输出，帮助 AIGC 理解需求。

3、🛠️ 提示词编写的基本原则

3.1 明确目标

在编写提示词时，首先要明确你希望AIGC生成的内容是什么。目标越明确，生成的代码质量越高。

示例：

❌ 一般提示词：

写一个Java类

✅ 优秀提示词：

写一个Java类，用于处理用户登录功能，包括用户名和密码的验证

🚀 最佳实践：

### 背景设定
假如你是一个资深的Java开发工程师，请编写一个 Java 类 UserLoginHandler，用于实现用户登录功能，并满足以下要求：

### 核心功能：
1、用户名和密码验证：支持哈希加密（如 BCrypt）进行密码校验。
2、登录失败次数限制：如连续失败 5 次，自动锁定账户。
3、登录日志记录：存储登录时间、IP 地址、设备信息等，便于审计和排查。
4、多种身份验证方式：支持用户名+密码、手机号+验证码登录。
5、可扩展性：允许集成 OAuth2、JWT 令牌等认证方式，以支持单点登录（SSO）。

### 技术要求：
1、 Spring Boot 和 Spring Security 进行开发。
2、提供 异常处理机制，确保安全性和稳定性。
3、记录详细日志，便于调试和运维。

（描述精准，逻辑清晰，涵盖核心功能、技术要求和可扩展性，确保输出符合实际需求）

3.2 提供上下文

AIGC需要足够的上下文信息来理解你的需求。提供相关的背景信息、技术栈、框架等，有助于生成更符合预期的代码。

示例：

❌ 一般提示词：

写一个Spring Boot控制器

✅ 优秀提示词：

写一个Spring Boot控制器，用于处理RESTful API请求，包括GET、POST、PUT和DELETE方法，使用JPA进行数据库操作

🚀 最佳实践：

### 背景设定
假如你是一个资深的Java开发工程师，请编写一个 Spring Boot 控制器 UserController，用于处理用户管理的 RESTful API，并满足以下要求：

### 核心功能：
1、支持基本的 CRUD 操作（GET、POST、PUT、DELETE）。
2、**使用 @RestController + @RequestMapping 规范 RESTful 设计。
3、数据交互：使用 JPA 进行数据库操作，提供 UserService 作为业务层，支持分页查询。
4、数据校验：使用 @Valid 和 @Validated 进行参数校验，结合 @ExceptionHandler 进行全局异常处理。
5、返回格式：统一封装 API 响应格式（如 Result<T，包含 code、message、data）。

### 安全性：
1、通过 Spring Security + JWT 进行身份认证与授权。
2、限制敏感接口的访问权限（如仅管理员可删除用户）。
3、使用 @PreAuthorize 或基于角色的访问控制（RBAC）。

### 技术要求：
1、使用 Spring Boot 2.7+，结合 Spring Security、JPA（Hibernate）、Lombok 进行开发。
2、API 采用 RESTful 风格，支持 Swagger 进行接口文档管理。
3、代码风格清晰，遵循 SOLID 原则，具备良好的可读性和可维护性。

(此提示词结构清晰，细化了 API 功能、数据处理方式、验证机制和安全性，确保开发出的控制器符合最佳实践)

3.3 分步引导

如果任务较为复杂，可以将提示词分解为多个步骤，逐步引导AIGC生成代码。

示例：

第一步：写一个Java类，用于表示用户实体，包括id、name、email和password字段

第二步：写一个Spring Boot控制器，用于处理用户注册请求，将用户信息保存到数据库中

4、🚀 提示词编写的具体技巧

4.1 使用自然语言

尽量使用自然语言描述你的需求，避免使用过于专业的术语或缩写，除非你确定AIGC能够理解。

示例：

❌ 一般提示词：

写一个Java类，实现DAO模式

✅ 优秀提示词：

写一个Java类，用于访问数据库，实现数据访问对象（DAO）模式

🚀 最佳实践：

### 背景设定
假如你是一个资深的Java开发工程师，请编写一个 Java 类，用于访问数据库，实现数据访问对象（DAO）模式。该类需要满足以下要求：

### 功能要求：
1、基本的数据库操作：能够执行新增、查询、更新和删除数据的操作。
2、数据交互：使用 JDBC 或 JPA 进行数据库访问，并支持事务管理。
3、查询优化：支持分页查询和条件筛选，以提高查询效率。
4、错误处理：提供异常捕获机制，避免数据库操作失败时程序崩溃。

### 技术要求：
1、兼容 MySQL、Oracle 或 PostgreSQL 数据库。
2、使用 Spring Boot 进行开发，并结合 Spring Data JPA 或 MyBatis 进行数据访问。
3、代码应结构清晰，易于维护，并遵循良好的编码规范。

(这个提示词清楚地描述了功能需求和技术要求，确保 AIGC 生成的代码符合实际开发需求。)

4.2 指定输入输出

明确指定方法的输入参数和返回值，有助于AIGC生成更符合预期的代码。

示例：

❌ 一般提示词：

写一个Java方法，用于处理用户输入

✅ 优秀提示词：

写一个Java方法，接受一个字符串参数表示用户输入，返回一个布尔值表示输入是否有效

🚀 最佳实践：

### 背景设定
假如你是一个资深的Java开发工程师，请编写一个 Java 方法，用于验证用户输入是否符合预期格式。该方法的要求如下：
方法名：isValidInput
1、输入参数：一个 String 类型的参数，表示用户输入的数据。
2、返回值：一个 boolean 值，true 表示输入有效，false 表示输入无效。

### 功能要求：
1、输入不能为空，若为空或仅包含空格，则返回 false。
2、长度限制：输入长度必须在 5 到 20 个字符之间。
3、字符限制：只能包含字母、数字和下划线（_），不能包含特殊字符。
4、忽略首尾空格：自动去除输入的前后空格后再进行验证。

(该提示词明确了方法名、输入参数、返回值类型，并详细说明了功能需求和示例，使 AIGC 生成的代码更符合预期。)

4.3 指定异常处理

如果代码需要处理异常，可以在提示词中明确指定。

示例：

❌ 一般提示词：

写一个Java方法，用于读取文件

✅ 优秀提示词：

写一个Java方法，用于读取文件，处理文件不存在和读取错误的异常

🚀 最佳实践：

### 背景设定
假如你是一个资深的Java开发工程师，请编写一个 Java 方法，用于读取指定文件的内容，并处理可能出现的异常。

### 方法要求：
1、方法名：readFileContent
2、输入参数：String filePath（表示文件的路径）。
3、返回值：String（返回文件内容，若发生错误则返回 null）。

### 功能要求：
1、读取文件内容：使用 BufferedReader 或 Files.readAllLines() 逐行读取文件。

### 异常处理：
1、文件不存在时：捕获 FileNotFoundException，并在日志中记录错误信息。
2、读取错误时：捕获 IOException，防止程序崩溃。
3、空文件：如果文件为空，则返回空字符串 ""。
4、自动关闭资源：使用 try-with-resources 语法确保流正确关闭，避免资源泄露。

(该提示词清晰地定义了方法名、输入参数、返回值类型，并详细说明了异常处理逻辑，确保 AIGC 生成的代码更加健壮。)

4.4 指定代码风格

如果你有特定的代码风格要求，可以在提示词中指定。

示例：

❌ 一般提示词：

写一个Java类，用于处理订单

✅ 优秀提示词：

写一个Java类，用于处理订单，使用驼峰命名法，每个方法前添加注释

🚀 最佳实践：

### 背景设定
假如你是一个资深的Java开发工程师，请编写一个 Java 类 OrderProcessor，用于处理订单的相关功能。

### 任务要求：
命名规范：使用驼峰命名法命名类、方法和变量。

### 代码风格：
1、每个方法前添加注释，简洁说明方法的功能。
2、确保代码块缩进使用 4 个空格，并遵循 Java 代码风格规范。
3、使用常量时，采用大写字母和下划线分隔（例如 MAX_ORDER_AMOUNT）。

### 功能要求：
1、创建订单：方法 createOrder，接收订单信息并返回订单 ID。
2、更新订单：方法 updateOrder，接收订单 ID 和更新的订单信息，返回更新后的订单对象。
3、删除订单：方法 deleteOrder，根据订单 ID 删除订单，返回删除成功与否的布尔值。
4、查询订单：方法 getOrderDetails，根据订单 ID 查询订单详细信息，返回订单对象。

(这个提示词明确了代码风格要求、命名规范、方法注释，并详细列出了每个方法的功能，确保生成的代码符合预期并易于维护。)

5、🔥 业务层开发实战

场景：在我们开发Spring的过程中，用的最多的是MVC架构的设计来实现一个接口的功能

Prompt提示词如下：

### 背景设定
假如你是一个资深的Java开发工程师，请根据要求完成以下任务。

### 任务描述：
 - 根据以下建表语句，生成Spring项目架构代码
 - 每一层代码需要包含详细的注释，并符合良好的代码规范
 - 注释要求使用Javadoc风格。

### 建表语句如下：
CREATE TABLE cbb_flow_tracing_log (
    ip_address VARCHAR(255) COMMENT 'IP和端口',
    trace_id VARCHAR(128) NOT NULL COMMENT '全链路ID，每个微批唯一',
    scene_type VARCHAR(64) NOT NULL COMMENT '执行场景：数据采集，采集转换，OO转换，指标计算，中间过程可扩展',
    exec_start_time DATETIME NOT NULL COMMENT '开始时间，过程开始时间',
    exec_end_time DATETIME COMMENT '结束时间，过程结束时间',
    exec_status VARCHAR(64) NOT NULL COMMENT '执行状态：执行成功，执行失败，执行中',
    exec_logdetails LONGTEXT COMMENT '执行日志明细，成功或失败的详细执行过程',
    service_version VARCHAR(64) COMMENT '服务版本，如1.48.0-SNAPSHOT',
    service_start_time DATETIME COMMENT '服务启动时间',
    service_path VARCHAR(500) COMMENT '服务路径',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    PRIMARY KEY (ip_address, trace_id, scene_type)
) COMMENT='xml转换执行日志表';

### 生成要求：
1、Bean层
 - 使用Lombok简化代码，生成Java Bean实体类。
 - 每个字段都需要提供详细的字段描述，并通过Javadoc注释进行说明，确保代码清晰易懂。
 - 实体类应包含所有表字段，并正确映射数据库字段类型。
2、Service层
 - 包含常用的增、删、改、查等接口的定义，并且要考虑到分页的场景。
 - 接口名称遵循RESTful风格，清晰定义每个接口的作用和输入输出。
 - 接口设计应尽量完善，考虑到常见的业务场景。
3、Impl层
 - 完整实现Service层的相对应的接口
 - 确保实现逻辑清晰、简洁，并包含必要的异常处理和事务控制
4、Mapper层
 - 使用MyBatis的注解方式完成数据库操作
 - 每个字段需要单独一行，且必须显式指定JDBC类型，避免类型转换错误
 - 代码进行格式化，确保可读性和一致性
5、Controller层
 - 完成增、删、改、查等接口的实现，确保每个接口能正确处理请求并返回响应
 - 遵循RESTful风格，定义合适的请求路径和方法，确保接口易于理解和使用

### 额外要求：
 - 确保每一层的代码结构清晰，易于维护
 - 所有注释需尽量详细，确保其他开发人员能迅速理解代码的功能和实现方式
 - 代码应符合良好的代码规范，确保可读性和一致性。

返回结果如下：

好的，我会按照你的要求，基于 Spring Boot 的五层架构（Controller、Service、ServiceImpl、Mapper、Bean）生成完整的代码，并使用 Javadoc 风格的注释进行详细说明。代码将遵循良好的编码规范，并结合 Lombok、MyBatis-Plus、Spring Boot 进行实现。

1、Bean层

package com.example.cbbflowtracinglog.bean;

import lombok.Data;
import java.util.Date;

/**
 * CbbFlowTracingLog实体类，对应数据库表cbb_flow_tracing_log
 */
@Data
public class CbbFlowTracingLog {

    /**
     * IP和端口
     */
    private String ipAddress;

    /**
     * 全链路ID，每个微批唯一
     */
    private String traceId;

    /**
     * 执行场景：数据采集，采集转换，OO转换，指标计算，中间过程可扩展
     */
    private String sceneType;

    /**
     * 开始时间，过程开始时间
     */
    private Date execStartTime;

    /**
     * 结束时间，过程结束时间
     */
    private Date execEndTime;

    /**
     * 执行状态：执行成功，执行失败，执行中
     */
    private String execStatus;

    /**
     * 执行日志明细，成功或失败的详细执行过程
     */
    private String execLogdetails;

    /**
     * 服务版本，如1.48.0-SNAPSHOT
     */
    private String serviceVersion;

    /**
     * 服务启动时间
     */
    private Date serviceStartTime;

    /**
     * 服务路径
     */
    private String servicePath;

    /**
     * 创建时间
     */
    private Date createTime;
}

2. Service层

package com.example.cbbflowtracinglog.service;

import com.example.cbbflowtracinglog.bean.CbbFlowTracingLog;

import java.util.List;

/**
 * CbbFlowTracingLog服务层接口
 */
public interface CbbFlowTracingLogService {

    /**
     * 新增日志
     * @param log 日志实体
     * @return 新增的日志实体
     */
    CbbFlowTracingLog addLog(CbbFlowTracingLog log);

    /**
     * 删除日志
     * @param ipAddress IP和端口
     * @param traceId 全链路ID
     * @param sceneType 执行场景
     */
    void deleteLog(String ipAddress, String traceId, String sceneType);

    /**
     * 更新日志
     * @param log 日志实体
     * @return 更新后的日志实体
     */
    CbbFlowTracingLog updateLog(CbbFlowTracingLog log);

    /**
     * 根据主键查询日志
     * @param ipAddress IP和端口
     * @param traceId 全链路ID
     * @param sceneType 执行场景
     * @return 日志实体
     */
    CbbFlowTracingLog getLogById(String ipAddress, String traceId, String sceneType);

    /**
     * 查询所有日志
     * @return 日志列表
     */
    List<CbbFlowTracingLog getAllLogs();
}

3. Impl层

package com.example.cbbflowtracinglog.service.impl;

import com.example.cbbflowtracinglog.bean.CbbFlowTracingLog;
import com.example.cbbflowtracinglog.service.CbbFlowTracingLogService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * CbbFlowTracingLog服务层实现类
 */
@Service
@Transactional
public class CbbFlowTracingLogServiceImpl implements CbbFlowTracingLogService {

    @Override
    public CbbFlowTracingLog addLog(CbbFlowTracingLog log) {
        // 实现新增日志逻辑
        return null;
    }

    @Override
    public void deleteLog(String ipAddress, String traceId, String sceneType) {
        // 实现删除日志逻辑
    }

    @Override
    public CbbFlowTracingLog updateLog(CbbFlowTracingLog log) {
        // 实现更新日志逻辑
        return null;
    }

    @Override
    public CbbFlowTracingLog getLogById(String ipAddress, String traceId, String sceneType) {
        // 实现根据主键查询日志逻辑
        return null;
    }

    @Override
    public List<CbbFlowTracingLog getAllLogs() {
        // 实现查询所有日志逻辑
        return null;
    }
}

4. Mapper层

package com.example.cbbflowtracinglog.mapper;

import com.example.cbbflowtracinglog.bean.CbbFlowTracingLog;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.type.JdbcType;

import java.util.List;

/**
 * CbbFlowTracingLog Mapper接口
 */
@Mapper
public interface CbbFlowTracingLogMapper {

    /**
     * 新增日志
     * @param log 日志实体
     * @return 影响的行数
     */
    @Insert({
        "INSERT INTO cbb_flow_tracing_log (",
        "    ip_address, ",
        "    trace_id, ",
        "    scene_type, ",
        "    exec_start_time, ",
        "    exec_end_time, ",
        "    exec_status, ",
        "    exec_logdetails, ",
        "    service_version, ",
        "    service_start_time, ",
        "    service_path, ",
        "    create_time",
        ") VALUES (",
        "    #{ipAddress, jdbcType=VARCHAR}, ",
        "    #{traceId, jdbcType=VARCHAR}, ",
        "    #{sceneType, jdbcType=VARCHAR}, ",
        "    #{execStartTime, jdbcType=TIMESTAMP}, ",
        "    #{execEndTime, jdbcType=TIMESTAMP}, ",
        "    #{execStatus, jdbcType=VARCHAR}, ",
        "    #{execLogdetails, jdbcType=LONGVARCHAR}, ",
        "    #{serviceVersion, jdbcType=VARCHAR}, ",
        "    #{serviceStartTime, jdbcType=TIMESTAMP}, ",
        "    #{servicePath, jdbcType=VARCHAR}, ",
        "    #{createTime, jdbcType=TIMESTAMP}",
        ")"
    })
    int insertLog(CbbFlowTracingLog log);

    /**
     * 删除日志
     * @param ipAddress IP和端口
     * @param traceId 全链路ID
     * @param sceneType 执行场景
     * @return 影响的行数
     */
    @Delete({
        "DELETE FROM cbb_flow_tracing_log ",
        "WHERE ip_address = #{ipAddress, jdbcType=VARCHAR} ",
        "  AND trace_id = #{traceId, jdbcType=VARCHAR} ",
        "  AND scene_type = #{sceneType, jdbcType=VARCHAR}"
    })
    int deleteLog(
        @Param("ipAddress") String ipAddress, @Param("traceId") String traceId, @Param("sceneType") String sceneType
    );

    /**
     * 更新日志
     * @param log 日志实体
     * @return 影响的行数
     */
    @Update({
        "UPDATE cbb_flow_tracing_log SET ",
        "    exec_start_time = #{execStartTime, jdbcType=TIMESTAMP}, ",
        "    exec_end_time = #{execEndTime, jdbcType=TIMESTAMP}, ",
        "    exec_status = #{execStatus, jdbcType=VARCHAR}, ",
        "    exec_logdetails = #{execLogdetails, jdbcType=LONGVARCHAR}, ",
        "    service_version = #{serviceVersion, jdbcType=VARCHAR}, ",
        "    service_start_time = #{serviceStartTime, jdbcType=TIMESTAMP}, ",
        "    service_path = #{servicePath, jdbcType=VARCHAR}, ",
        "    create_time = #{createTime, jdbcType=TIMESTAMP} ",
        "WHERE ip_address = #{ipAddress, jdbcType=VARCHAR} ",
        "  AND trace_id = #{traceId, jdbcType=VARCHAR} ",
        "  AND scene_type = #{sceneType, jdbcType=VARCHAR}"
    })
    int updateLog(CbbFlowTracingLog log);

    /**
     * 根据主键查询日志
     * @param ipAddress IP和端口
     * @param traceId 全链路ID
     * @param sceneType 执行场景
     * @return 日志实体
     */
    @Select({
        "SELECT ",
        "    ip_address, ",
        "    trace_id, ",
        "    scene_type, ",
        "    exec_start_time, ",
        "    exec_end_time, ",
        "    exec_status, ",
        "    exec_logdetails, ",
        "    service_version, ",
        "    service_start_time, ",
        "    service_path, ",
        "    create_time ",
        "FROM cbb_flow_tracing_log ",
        "WHERE ip_address = #{ipAddress, jdbcType=VARCHAR} ",
        "  AND trace_id = #{traceId, jdbcType=VARCHAR} ",
        "  AND scene_type = #{sceneType, jdbcType=VARCHAR}"
    })
    CbbFlowTracingLog selectLogById(@Param("ipAddress") String ipAddress, @Param("traceId") String traceId, @Param("sceneType") String sceneType);

    /**
     * 查询所有日志
     * @return 日志列表
     */
    @Select({
        "SELECT ",
        "    ip_address, ",
        "    trace_id, ",
        "    scene_type, ",
        "    exec_start_time, ",
        "    exec_end_time, ",
        "    exec_status, ",
        "    exec_logdetails, ",
        "    service_version, ",
        "    service_start_time, ",
        "    service_path, ",
        "    create_time ",
        "FROM cbb_flow_tracing_log"
    })
    List<CbbFlowTracingLog selectAllLogs();
}

5. Controller层

package com.example.cbbflowtracinglog.controller;

import com.example.cbbflowtracinglog.bean.CbbFlowTracingLog;
import com.example.cbbflowtracinglog.service.CbbFlowTracingLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * CbbFlowTracingLog控制器
 */
@RestController
@RequestMapping("/api/logs")
public class CbbFlowTracingLogController {

    @Autowired
    private CbbFlowTracingLogService logService;

    /**
     * 新增日志
     * @param log 日志实体
     * @return 新增的日志实体
     */
    @PostMapping
    public CbbFlowTracingLog addLog(@RequestBody CbbFlowTracingLog log) {
        return logService.addLog(log);
    }

    /**
     * 删除日志
     * @param ipAddress IP和端口
     * @param traceId 全链路ID
     * @param sceneType 执行场景
     */
    @DeleteMapping("/{ipAddress}/{traceId}/{sceneType}")
    public void deleteLog(@PathVariable String ipAddress, @PathVariable String traceId, @PathVariable String sceneType) {
        logService.deleteLog(ipAddress, traceId, sceneType);
    }

    /**
     * 更新日志
     * @param log 日志实体
     * @return 更新后的日志实体
     */
    @PutMapping
    public CbbFlowTracingLog updateLog(@RequestBody CbbFlowTracingLog log) {
        return logService.updateLog(log);
    }

    /**
     * 根据主键查询日志
     * @param ipAddress IP和端口
     * @param traceId 全链路ID
     * @param sceneType 执行场景
     * @return 日志实体
     */
    @GetMapping("/{ipAddress}/{traceId}/{sceneType}")
    public CbbFlowTracingLog getLogById(@PathVariable String ipAddress, @PathVariable String traceId, @PathVariable String sceneType) {
        return logService.getLogById(ipAddress, traceId, sceneType);
    }

    /**
     * 查询所有日志
     * @return 日志列表
     */
    @GetMapping
    public List<CbbFlowTracingLog getAllLogs() {
        return logService.getAllLogs();
    }
}

总结

以上代码按照Spring五层架构（Bean、Service、Impl、Mapper、Controller）生成了对应的Java代码，并且每一层都包含了详细的Javadoc注释，代码结构清晰，易于维护。Bean层使用了Lombok简化代码，Service层定义了常用的增删改查接口，Impl层实现了这些接口，Mapper层使用MyBatis注解方式完成数据库操作，Controller层实现了RESTful风格的API接口。

6、📌 总结

使用AIGC（人工智能生成内容）可以大大提升工作效率，但要达到最优效果，需要掌握一定的技巧和方法。以下是针对于AIGC使用的一些总结：

---

1. 明确的任务描述至关重要

➡️ 提供清晰的目标：AIGC生成内容时，任务描述必须简洁且明确，避免模糊或过于简短的指令。越详细和具体的描述能够引导AIGC生成更符合预期的内容。

➡️ 示例和上下文：提供相关示例或上下文信息，有助于AIGC理解需求，并生成与业务场景相符的内容。例如，提供接口设计、数据库结构或功能需求等详细信息。

---

2. 迭代优化的过程

➡️ 初步结果：AIGC生成的初步代码或内容可能并不完美，因此，首先生成一个基础的版本进行评估是很有必要的。

➡️ 逐步调整：根据初步生成的结果进行微调和修改，逐步优化内容。可以通过修改提示词、添加更多细节或澄清要求来指导AIGC生成更准确的结果。

➡️ 分步进行：如果需求复杂，建议将任务拆分为多个小任务，逐步指导AIGC完成。这种分步指导可以避免生成的内容过于简单，且更容易控制最终结果。

---

3. 强调代码质量和健壮性

➡️ 明确的质量要求：生成代码时，必须明确要求代码的健壮性、性能和可维护性。例如，明确是否需要考虑异常处理、日志记录、性能优化等。

➡️ 检查错误：AIGC生成的代码虽然能完成基础功能，但可能存在语法错误、逻辑漏洞或不符合最佳实践的地方。务必检查生成代码的正确性，并做必要的手动修改。

➡️ 注释和文档化：注释是生成代码质量的一个关键因素，确保代码中有足够的注释说明功能、参数、返回值等，尤其是使用Javadoc风格的注释，帮助后续维护和协作。

---

4. 处理复杂性和灵活性

➡️ 处理复杂场景：对于复杂的业务逻辑或高度定制的需求，AIGC的生成结果可能不够精细，需要手动调整。明确指出哪些地方需要定制化开发，以减少不必要的重复工作。

➡️ 灵活性需求：AIGC生成内容时，要求它根据上下文灵活调整。例如，对于不同数据库的兼容性要求，或是对某些接口返回格式的灵活处理等，必须通过合适的提示词引导。

---

5. 提供反馈与修正

➡️ 反馈机制：与AIGC交互时，及时提供反馈能帮助系统更好地理解需求，避免重复产生不符合要求的结果。通过提供具体的反馈，AIGC能够逐步优化生成内容。

➡️ 持续改进：AIGC的能力随着使用次数和反馈的增多会不断提升，因此，持续的互动和修正是提高生成质量的有效手段。

---

6. 多样化的应用场景

➡️ 多领域适应性：AIGC不仅可以生成代码，还能应用于文档写作、数据分析、技术文档生成等多个场景。通过结合行业特定知识或技术栈，可以提升AIGC的使用效率。

➡️ 与现有工具结合：将AIGC与其他工具和框架结合使用，可以进一步优化工作流。例如，结合IDE中的插件、自动化测试工具等，能够提升整体开发效率。

---

7. 提高生成效率

➡️ 节省时间：AIGC能极大减少手动编写的时间，尤其是在一些常规的、模板化的代码生成中，如创建标准的CRUD接口、Bean类、Controller层等。

➡️ 自动化生成：在开发流程中，借助AIGC自动生成模板代码、文档等，可以帮助开发者专注于核心业务逻辑，节省大量重复劳动。

---

8. 了解AIGC的局限性

➡️ 不能完全代替人工：尽管AIGC可以提高效率，但它仍然有局限性。对于高度复杂、特定需求的任务，AIGC生成的结果可能不完全符合要求，需要人工进行调整和补充。

➡️ 上下文理解限制：AIGC虽然可以基于给定的提示生成内容，但其对上下文的理解仍然有限。在某些特定情境下，AIGC可能无法充分理解所有的细节，导致生成内容不精准。

---

AIGC是一种强大的工具，可以大幅提高工作效率，但要获得最优的生成结果，需要提供清晰的输入、逐步优化和调整生成内容，并结合人工修正和反馈。在使用过程中，通过逐步完善提示词和增强上下文信息，可以实现AIGC与人工工作的良好协同。