AI生成代码后如何debug并运行且落地？

文章目录

• AI生成代码后如何debug并运行且落地？
• 前言
• 一、实现路线概述
• 二、详细的实现步骤
• • 1.准备环境
  • 2.System Prompt 设计
  • 3.创建新的虚拟环境
  • 4.调用模型输出代码
  • 5.写一个正则表达式提取代码的函数
  • 6.写一个针对各个语言的代码包装器
  • 6.执行AI输出的代码
  • 7.用while_loop包装持续执行直到代码没有报错
  • 8.完整代码示例(copy即可用)
• 总结
• 推荐

---

前言

随着语言模型从2023到2025的发展，现在能代替人做的事情其实已经很多了。我相信大部分人都已经在用AI来帮助代码补全或者debug代码了吧，有的人会用cursor或者winsurf等软件来用AI实现一些自动化的AI写代码功能。今天我就来教大家如何能做到不依赖这些软件，做到让语言模型自己生成代码，debug自己的代码，直到能成功运行并落地的操作。这样你就真的能做到只提需求，AI来实现的功能了！

---

一、实现路线概述

如何实现这个操作呢？实际上想想其实也不难，我们先把代码需求输入给语言模型(比如帮我写一个爬虫脚本等),接下来AI就会生成代码，我们取出AI生成的这个代码直接运行,将运行的结果返回AI，如果结果出现了报错，AI就会根据这个报错的结果重新生成代码，直到代码没有报错信息并成功运行！接下来是详细的实现步骤。

二、详细的实现步骤

1.准备环境

模型我推荐用能力强一点的模型，比如O3，Gemini2.5，Claude4, Qwen3，DeepseekR1等，当然你如果是想节省成本也可以用本地的模型，毕竟开源模型现在的代码能力也不是特别的差。
如果是想用本地模型的话可以先去官网安装一下ollama然后下载相关的模型:
ollama官网地址

本示例我使用的模型是Gemin2.5 flash(因为模型强大而且有每日免费使用500次请求的额度)

接下来安装一下需要的依赖:

pip install openai "autogen-core" "autogen-ext[openai]" "autogen-agentchat" venv

依赖中的模块我在后面会给大家做出解释。

2.System Prompt 设计

要是想语言模型输出代码以及debug代码的时候符合要求，system prompt的设计是至关重要的一步，模型的输出就是靠system prompt来影响的，下面给我写好的system prompt,有英文版和中文版的，大家自行选择和修改。

中文版:

SYSTEM_MESSAGE = f'''
你是一位“代码-自执行-自调试”代理（Code-Auto-Agent）。
在每一轮对话中严格遵守以下规则：

1. **响应格式**
   - 如果仍需让机器执行指令，必须只输出**一个** Markdown 代码块。
   - 该代码块可使用任意合适的语言标识（如 `python`、`bash`、`shell`、`java`、`javascript` 等）。
   - 整条消息里 **只能有这一段代码块**，不得再出现第二段，也不得出现其他文字、解释或 Markdown。

2. **选择代码块语言**
   - **依赖安装或系统级指令** → 使用 `bash` 或 `shell` 代码块，例如  
     ```bash
     pip install package_a package_b
     ```
   - **业务逻辑/功能实现** → 使用用户需求指定或你已采用的编程语言标识（如 `python`、`java` 等）输出完整可运行脚本。

3. **调试循环**
   - 你可能收到两类输入：  
     a) **需求说明** —— 第一次轮次给出，要实现的功能描述。  
     b) **终端回显** —— 上一次代码运行产生的 stdout / stderr（含错误栈）。
   - 若收到错误回显：分析问题 → **修改并重新整段输出完整代码**（或先输出安装指令）。
   - 若运行成功且已满足需求：**不要再输出代码块**，而是返回简短中文文本，例如  
     ✅ 代码已按需求成功执行，无需进一步操作。

4. **代码完整性**
   - 在任何非安装类代码回复中，必须给出**可直接运行的完整脚本**（含 import / package / class 等），而非零散片段。

5. **禁止事项**
   - 不得在同一次回复中同时输出两段或更多代码块。
   - 除最终成功提示外，不得添加解释、注释或寒暄。
   - 不得要求用户手动确认每一步。

6. **语言**
   - 除代码块外的所有文本（仅用于最终成功提示）必须使用简体中文。
'''

英文版:

SYSTEM_MESSAGE = f'''
"""
You are a "Code-Auto-Execute-Auto-Debug" agent (Code-Auto-Agent).
In each round of conversation, strictly adhere to the following rules:

1.  **Response Format**
    -   If instructions still need to be executed by the machine, you must output only **one** Markdown code block.
    -   This code block can use any appropriate language identifier (e.g., `python`, `bash`, `shell`, `java`, `javascript`, etc.).
    -   The entire message **can only contain this single code block**; a second block must not appear, nor should any other text, explanations, or Markdown.

2.  **Choose Code Block Language**
    -   **Dependency installation or system-level commands** → Use a `bash` or `shell` code block, for example
        ```bash
        pip install package_a package_b
        ```
    -   **Business logic/feature implementation** → Use the programming language identifier specified in the user's requirement or that you have already adopted (e.g., `python`, `java`, etc.) to output a complete, runnable script.

3.  **Debugging Loop**
    -   You may receive two types of input:
        a) **Requirement description** — Given in the first turn, a description of the feature to be implemented.
        b) **Terminal output** — The stdout / stderr (including stack trace) generated from the previous code execution.
    -   If an error output is received: Analyze the problem → **Modify and re-output the entire complete code** (or first output an installation command).
    -   If the execution is successful and the requirement has been met: **Do not output a code block again**, but instead return a short Chinese text, for example
        ✅ code has sussesfully exececuted!!!

4.  **Code Integrity**
    -   In any non-installation code response, you must provide a **complete, directly runnable script** (including imports, packages, classes, etc.), not scattered fragments.

5.  **Prohibitions**
    -   Do not output two or more code blocks in the same response.
    -   Do not add explanations, comments, or pleasantries, except for the final success message.
    -   Do not require the user to manually confirm each step.

6.  **Language**
    -   All text outside of the code block (used only for the final success message) must use Simplified Chinese.
"""
'''

3.创建新的虚拟环境

我们要是想要运行AI写的代码的话，就需要额外给他创建一个隔离的虚拟环境，让AI写出来的代码可以在新的隔离虚拟环境中执行，避免与我们自己代码的环境产生依赖冲突，这点非常重要！
创建虚拟环境和工作目录代码如下：

import venv os
from pathlib import Path

# 在项目中创建一个工作的目录，用来存放代码和虚拟环境及相关第三方模块
work_dir = Path("coding")
work_dir.mkdir(parents=True, exist_ok=True)

# 1) 在上面的工作目录中创建 .venv的虚拟环境
# 所有AI写的代码都是在这个.venv的环境中执行的
venv_dir = work_dir / ".venv"
venv_builder = venv.EnvBuilder(with_pip=True) # with_pip代表添加pip的下载模块
venv_builder.create(venv_dir)
venv_ctx = venv_builder.ensure_directories(venv_dir)

4.调用模型输出代码

接下来可以输入你的需求然后得到模型输出的代码了。你可以用vllm或者其他的框架来得到模型的输出，这里我使用的就是openai的框架:

client = OpenAI(
    base_url="<模型的base_url>",
    api_key="<调用模型的api_key>",
)
# 获取用户的需求
task = input("请输入你的需求:")

# 将SYSTEMPROMPT和用户的需求加入到聊天历史中
chat_history = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": task}
]

response = client.chat.completions.create(
     model="gemini-2.5-flash",
     messages=chat_history
 )
 # 这个answer就是模型的输出了。
answer = response.choices[0].message.content

5.写一个正则表达式提取代码的函数

正则表达式可以说是对于学习语言模型来说最重要的东西之一，没学过的小伙伴有机会可以去学习一下，这里我就简单的说一下他的作用，正则表达式可以从文本数据中提取出我们想要的内容，AI的输出一般是遵循Markdown格式的文本数据，我们可以用正则匹配来从AI的输出中提取出我们想要的内容，举一个例子, 我们让AI帮我们写一段简单的python代码，AI的输出是:

```python
# 这是一个简单的Python程序，用于打印 "Hello, world!"

print("Hello, world!")
```

**解释:**

*   `print()` 是一个内置函数，用于在控制台输出文本。
*   `"Hello, world!"`  是一个字符串字面量，也就是要输出的文本内容。

这段代码是最基础的Python程序，它会在运行后在你的控制台窗口中显示 "Hello, world!"。

可以看到里面的解释的部分我们是不要的，我们只需要代码的部分，也就是:

```python
# 这是一个简单的Python程序，用于打印 "Hello, world!"

print("Hello, world!")
```

所以我们需要用正则表达式加re模块把这个代码的部分提取出来，下面是我写好的函数,可以可以直接从AI的文本输出中提取出代码内容:

def extract_markdown_code_blocks(md: str) -> List[CodeBlock]:
    pattern = re.compile(r"```(?:\s*([\w\+\-]+))?\n([\s\S]*?)```")
    blocks = []
    for lang, code in pattern.findall(md):
        # 如果没有指定语言（例如 pip 命令），则默认为 'bash'
        language = lang.strip() if lang else "bash"
        blocks.append(CodeBlock(language=language.lower(), code=code))
    return blocks

6.写一个针对各个语言的代码包装器

因为当前是用的python脚本，如果想适配java还是c等各种语言的执行的话，还是需要写一个代码包装器的:

# ---------- 1. 针对各语言的包装器 ----------
def wrap_bash(code: str) -> str:
    cmd = code.replace("\n", " ")
    return (
        "import subprocess, sys\n"
        f"subprocess.run({cmd!r}, shell=True, check=False)\n"
    )


def wrap_java(code: str) -> str:
    return textwrap.dedent(f"""
        import subprocess, tempfile, pathlib, shutil, sys, textwrap
        tmp_dir = pathlib.Path(tempfile.mkdtemp())
        src = tmp_dir / "Main.java"
        src.write_text(textwrap.dedent({code!r}), encoding="utf-8")
        subprocess.check_call(["javac", str(src)])
        run = subprocess.run(["java", "-cp", str(tmp_dir), "Main"],
                             capture_output=True, text=True)
        print(run.stdout, end="")
        print(run.stderr, file=sys.stderr, end="")
        shutil.rmtree(tmp_dir)
    """)


def wrap_node(code: str) -> str:
    return textwrap.dedent(f"""
        import subprocess, tempfile, pathlib, shutil, sys, textwrap
        tmp_dir = pathlib.Path(tempfile.mkdtemp())
        src = tmp_dir / "main.js"
        src.write_text(textwrap.dedent({code!r}), encoding="utf-8")
        run = subprocess.run(["node", str(src)],
                             capture_output=True, text=True)
        print(run.stdout, end="")
        print(run.stderr, file=sys.stderr, end="")
        shutil.rmtree(tmp_dir)
    """)


def wrap_go(code: str) -> str:
    return textwrap.dedent(f"""
        import subprocess, tempfile, pathlib, shutil, sys, textwrap
        tmp_dir = pathlib.Path(tempfile.mkdtemp())
        src = tmp_dir / "main.go"
        src.write_text(textwrap.dedent({code!r}), encoding="utf-8")
        run = subprocess.run(["go", "run", str(src)],
                             capture_output=True, text=True)
        print(run.stdout, end="")
        print(run.stderr, file=sys.stderr, end="")
        shutil.rmtree(tmp_dir)
    """)


def wrap_cpp(code: str) -> str:
    return textwrap.dedent(f"""
        import subprocess, tempfile, pathlib, shutil, sys, textwrap, os
        tmp_dir = pathlib.Path(tempfile.mkdtemp())
        src = tmp_dir / "main.cpp"
        exe = tmp_dir / "a.out"
        src.write_text(textwrap.dedent({code!r}), encoding="utf-8")
        subprocess.check_call(["g++", str(src), "-o", str(exe)])
        run = subprocess.run([str(exe)], capture_output=True, text=True)
        print(run.stdout, end="")
        print(run.stderr, file=sys.stderr, end="")
        shutil.rmtree(tmp_dir)
    """)


LANG_WRAPPER = {
    "bash": wrap_bash,
    "shell": wrap_bash,
    "sh": wrap_bash,
    "java": wrap_java,
    "javascript": wrap_node,
    "js": wrap_node,
    "node": wrap_node,
    "go": wrap_go,
    "golang": wrap_go,
    "cpp": wrap_cpp,
    "c++": wrap_cpp,
    "c": wrap_cpp,
}

这样就可以更加通用的执行各种语言的代码了，有别的语言再加进去就行了！

6.执行AI输出的代码

提取出来AI的代码了，接下来就可以讨论如何执行这段代码了对吧？这里我就要推荐使用autogen框架的LocalCommandLineCodeExecutor方法了。不要再自己写一个内置的方法去执行代码了，因为LocalCommandLineCodeExecutor方法简单而且好用。代码如下:

from autogen_core.code_executor import CodeBlock
from autogen_ext.code_executors.local import LocalCommandLineCodeExecutor
from autogen_core import CancellationToken

# 创建一个本地执行器，指向之前创建好的工作目录以及虚拟环境
local_executor = LocalCommandLineCodeExecutor(
    work_dir=work_dir,
    virtual_env_context=venv_ctx
)

# 先用上面的函数提取出语言模型输出中的代码
code_blocks = extract_markdown_code_blocks(answer)
# 用创建好的本地执行器执行提取出来的代码,result就是终端的输出了
result = await local_executor.execute_code_blocks(
            code_blocks,
            cancellation_token=CancellationToken(),
)

值得注意的是这个local_executor.execute_code_blocks() 是一个异步协程，需要用异步函数进行包装才能正常执行，不然就会报错:“Unresolved attribute reference ‘output’ for class ‘Coroutine’”，这里是提供思路，在下一步的主逻辑中会进行修改。

7.用while_loop包装持续执行直到代码没有报错

上一步的result就是终端返回的结果了，我们现在只需要把这个结果再丢回给AI，让他进行debug并修改代码，这里可以用while_loop来一直执行，直到AI没有输出代码的时候就可以break掉最终的循环:

# ---------- 5. 主对话循环 ----------
async def dialogue_loop(initial_task: str):
    chat_history = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": initial_task},
    ]

    while True:
        # 1) 让 LLM 生成回复
        response = client.chat.completions.create(
            model="gemini-2.5-flash",
            messages=chat_history,
        )
        answer = response.choices[0].message.content
        chat_history.append({"role": "assistant", "content": answer})
        print("-" * 80, "\nAssistant:\n", answer)

        # 2) 提取代码块
        code_blocks = extract_markdown_code_blocks(answer)
        if not code_blocks:
            break  # 没有代码块 → 对话结束

        # 3) 按语言包装成 Python 可执行脚本
        new_blocks: List[CodeBlock] = []
        for cb in code_blocks:
            lang = cb.language
            if lang in LANG_WRAPPER:
                wrapped_code = LANG_WRAPPER[lang](cb.code)
                new_blocks.append(CodeBlock(language="python", code=wrapped_code))
            else:
                # 默认为 python，直接原样运行
                new_blocks.append(cb)

        # 4) 执行并等待结果
        result = await local_executor.execute_code_blocks(
            new_blocks,
            cancellation_token=CancellationToken(),
        )
        print("-" * 80, "\n代码运行结果:\n", result.output)

        # 5) 把运行结果反馈给模型
        chat_history.append(
            {"role": "user", "content": f"代码运行结果：\n{result.output}"}
        )


if __name__ == "__main__":
    task = input("请输入你的需求: ")
    asyncio.run(dialogue_loop(task))

完整的逻辑就闭环了，AI就能根据你的需求进行写代码，自己debug代码直到达到你的需求为止了。

8.完整代码示例(copy即可用)

import os
import re
import asyncio
import venv
import tempfile
import pathlib
import textwrap
import shutil
import subprocess
import sys
from pathlib import Path
from typing import List
from openai import OpenAI

from autogen_core.code_executor import CodeBlock
from autogen_ext.code_executors.local import LocalCommandLineCodeExecutor
from autogen_core import CancellationToken

# ---------- 0. 工具：提取 Markdown 代码块 ----------
def extract_markdown_code_blocks(md: str) -> List[CodeBlock]:
    pattern = re.compile(r"```(?:\s*([\w\+\-]+))?\n([\s\S]*?)```")
    blocks = []
    for lang, code in pattern.findall(md):
        language = lang.strip() if lang else "bash"
        blocks.append(CodeBlock(language=language.lower(), code=code))
    return blocks


# ---------- 1. 针对各语言的包装器 ----------
def wrap_bash(code: str) -> str:
    cmd = code.replace("\n", " ")
    return (
        "import subprocess, sys\n"
        f"subprocess.run({cmd!r}, shell=True, check=False)\n"
    )


def wrap_java(code: str) -> str:
    return textwrap.dedent(f"""
        import subprocess, tempfile, pathlib, shutil, sys, textwrap
        tmp_dir = pathlib.Path(tempfile.mkdtemp())
        src = tmp_dir / "Main.java"
        src.write_text(textwrap.dedent({code!r}), encoding="utf-8")
        subprocess.check_call(["javac", str(src)])
        run = subprocess.run(["java", "-cp", str(tmp_dir), "Main"],
                             capture_output=True, text=True)
        print(run.stdout, end="")
        print(run.stderr, file=sys.stderr, end="")
        shutil.rmtree(tmp_dir)
    """)


def wrap_node(code: str) -> str:
    return textwrap.dedent(f"""
        import subprocess, tempfile, pathlib, shutil, sys, textwrap
        tmp_dir = pathlib.Path(tempfile.mkdtemp())
        src = tmp_dir / "main.js"
        src.write_text(textwrap.dedent({code!r}), encoding="utf-8")
        run = subprocess.run(["node", str(src)],
                             capture_output=True, text=True)
        print(run.stdout, end="")
        print(run.stderr, file=sys.stderr, end="")
        shutil.rmtree(tmp_dir)
    """)


def wrap_go(code: str) -> str:
    return textwrap.dedent(f"""
        import subprocess, tempfile, pathlib, shutil, sys, textwrap
        tmp_dir = pathlib.Path(tempfile.mkdtemp())
        src = tmp_dir / "main.go"
        src.write_text(textwrap.dedent({code!r}), encoding="utf-8")
        run = subprocess.run(["go", "run", str(src)],
                             capture_output=True, text=True)
        print(run.stdout, end="")
        print(run.stderr, file=sys.stderr, end="")
        shutil.rmtree(tmp_dir)
    """)


def wrap_cpp(code: str) -> str:
    return textwrap.dedent(f"""
        import subprocess, tempfile, pathlib, shutil, sys, textwrap, os
        tmp_dir = pathlib.Path(tempfile.mkdtemp())
        src = tmp_dir / "main.cpp"
        exe = tmp_dir / "a.out"
        src.write_text(textwrap.dedent({code!r}), encoding="utf-8")
        subprocess.check_call(["g++", str(src), "-o", str(exe)])
        run = subprocess.run([str(exe)], capture_output=True, text=True)
        print(run.stdout, end="")
        print(run.stderr, file=sys.stderr, end="")
        shutil.rmtree(tmp_dir)
    """)


LANG_WRAPPER = {
    "bash": wrap_bash,
    "shell": wrap_bash,
    "sh": wrap_bash,
    "java": wrap_java,
    "javascript": wrap_node,
    "js": wrap_node,
    "node": wrap_node,
    "go": wrap_go,
    "golang": wrap_go,
    "cpp": wrap_cpp,
    "c++": wrap_cpp,
    "c": wrap_cpp,
}

# ---------- 2. 创建虚拟环境 + 本地执行器 ----------
work_dir = Path("coding")
work_dir.mkdir(parents=True, exist_ok=True)

venv_dir = work_dir / ".venv"
venv_builder = venv.EnvBuilder(with_pip=True)
venv_builder.create(venv_dir)
venv_ctx = venv_builder.ensure_directories(venv_dir)

local_executor = LocalCommandLineCodeExecutor(
    work_dir=work_dir,
    virtual_env_context=venv_ctx,
)

# ---------- 3. System Prompt ----------
SYSTEM_PROMPT = """
你是一位“代码-自执行-自调试”代理（Code-Auto-Agent）。
在每一轮对话中严格遵守以下规则：

1. **响应格式**
   - 如果仍需让机器执行指令，必须只输出**一个** Markdown 代码块。
   - 该代码块可使用任意合适的语言标识（如 `python`、`bash`、`shell`、`java`、`javascript` 等）。
   - 整条消息里 **只能有这一段代码块**，不得再出现第二段，也不得出现其他文字、解释或 Markdown。

2. **选择代码块语言**
   - **依赖安装或系统级指令** → 使用 `bash` 或 `shell` 代码块，例如  
     ```bash
     pip install package_a package_b
     ```
   - **业务逻辑/功能实现** → 使用用户需求指定或你已采用的编程语言标识（如 `python`、`java` 等）输出完整可运行脚本。

3. **调试循环**
   - 你可能收到两类输入：  
     a) **需求说明** —— 第一次轮次给出，要实现的功能描述。  
     b) **终端回显** —— 上一次代码运行产生的 stdout / stderr（含错误栈）。
   - 若收到错误回显：分析问题 → **修改并重新整段输出完整代码**（或先输出安装指令）。
   - 若运行成功且已满足需求：**不要再输出代码块**，而是返回简短中文文本，例如  
     ✅ 代码已按需求成功执行，无需进一步操作。

4. **代码完整性**
   - 在任何非安装类代码回复中，必须给出**可直接运行的完整脚本**（含 import / package / class 等），而非零散片段。

5. **禁止事项**
   - 不得在同一次回复中同时输出两段或更多代码块。
   - 除最终成功提示外，不得添加解释、注释或寒暄。
   - 不得要求用户手动确认每一步。

6. **语言**
   - 除代码块外的所有文本（仅用于最终成功提示）必须使用简体中文。
"""

# ---------- 4. OpenAI/Gemini 客户端 ----------
load_dotenv()
client = OpenAI(
    base_url="<Google Base URL 地址>",
    api_key="<Gemini api key 地址>",
)

# ---------- 5. 主对话循环 ----------
async def dialogue_loop(initial_task: str):
    chat_history = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": initial_task},
    ]

    while True:
        # 1) 让 LLM 生成回复
        response = client.chat.completions.create(
            model="gemini-2.5-flash",
            messages=chat_history,
        )
        answer = response.choices[0].message.content
        chat_history.append({"role": "assistant", "content": answer})
        print("-" * 80, "\nAssistant:\n", answer)

        # 2) 提取代码块
        code_blocks = extract_markdown_code_blocks(answer)
        if not code_blocks:
            break  # 没有代码块 → 对话结束

        # 3) 按语言包装成 Python 可执行脚本
        new_blocks: List[CodeBlock] = []
        for cb in code_blocks:
            lang = cb.language
            if lang in LANG_WRAPPER:
                wrapped_code = LANG_WRAPPER[lang](cb.code)
                new_blocks.append(CodeBlock(language="python", code=wrapped_code))
            else:
                # 默认为 python，直接原样运行
                new_blocks.append(cb)

        # 4) 执行并等待结果
        result = await local_executor.execute_code_blocks(
            new_blocks,
            cancellation_token=CancellationToken(),
        )
        print("-" * 80, "\n代码运行结果:\n", result.output)

        # 5) 把运行结果反馈给模型
        chat_history.append(
            {"role": "user", "content": f"代码运行结果：\n{result.output}"}
        )


if __name__ == "__main__":
    task = input("请输入你的需求: ")
    asyncio.run(dialogue_loop(task))

总结

以上就是一个完整的可以帮助你写代码的agent的示例了。小伙伴们可以后期进行自己的优化或者修改这个代码或者集成到自己的项目中都是非常的不错的。当然我后面还会提供进阶版能大大的提升这个agent的写代码的能力，如同大家在网页端使用o3模型那样:在写代码之前先联网搜索依赖的最新版本信息，或者先获取到相关的数据，然后再进行写代码能大大的提升代码的准确性和适用性! 这个如果大家想学的话就多给几个收藏和点赞或者评论一下也可以！ 谢谢大家！！！

推荐

大家可以看一看我写的这个通用的智能体项目呀，或许能帮到你不少呢？喜欢的话可以点个star！谢谢！！
github项目链接：QuokkaAgent