Newshot

用 AI 智能体做 TDD:先设计测试,再让智能体实现

Translation(model translation, not the source's own text)

目录

  • 前置条件
  • 使用 AI 智能体进行 TDD 的循环
  • 第 1 步:定义契约并编写第一个测试 搭建项目 定义契约 手写第一个测试
  • 搭建项目
  • 定义契约
  • 手写第一个测试
  • 第 2 步:让智能体起草测试
  • 第 3 步:审查并加固测试 加固测试遗漏的规则 加固失败用例
  • 加固测试遗漏的规则
  • 加固失败用例
  • 第 4 步:让智能体实现 隔离测试 移交实现
  • 隔离测试
  • 移交实现
  • 第 5 步:审查差异
  • 故障排查

当你的测试套件通过时,你就知道代码与测试相符。然而,如果 AI 智能体既写了测试又写了代码,那么你所知道的只是智能体自己认同自己。使用 AI 智能体进行 TDD 能让你保持控制权。首先,你设计定义该功能应做什么的测试,然后智能体编写代码使这些测试通过。

测试驱动开发(TDD)是一个循环:你编写一个失败的测试,让它通过,然后重构。与 AI 智能体协作不会改变这个循环,但会改变谁来负责哪一部分。你来做设计决策,智能体负责起草:

包含五个步骤的循环图,展示你的步骤(定义契约、加固测试、审查差异)和智能体的步骤(起草测试、实现),并循环回到下一个功能。
包含五个步骤的循环图,展示你的步骤(定义契约、加固测试、审查差异)和智能体的步骤(起草测试、实现),并循环回到下一个功能。

这个循环就是你在让 AI 智能体编写实现时应用 TDD 的方式。

在本教程中,你将通过构建一个小型 Python 版本比较器来练习这个循环。Python 有它自己的版本规则,定义在版本说明符规范中,其中 1.0.dev1 排在 1.0a1 之前,而 1.0a1 又排在 1.0 之前。在生产环境中,你通常会使用 packaging 库,但在这里你将构建自己的实现,以便处理一个真正值得测试的契约。

获取代码:点击此处下载免费示例代码,你将用它通过先设计测试、再让 AI 智能体编写实现的方式,构建一个 Python 版本比较器。

参加测验:用我们的互动测验“使用 AI 智能体进行 TDD:先设计测试,让智能体实现”检验你的知识。完成测验后你会获得分数,帮助你追踪学习进度:

一个人拿着清单站在一个贴有 TESTS 标签的上锁测试柜旁,一扇标有 BLOCKED 的门将它和一个机械臂及机器隔开。
一个人拿着清单站在一个贴有 TESTS 标签的上锁测试柜旁,一扇标有 BLOCKED 的门将它和一个机械臂及机器隔开。

互动测验

检验你对 Python 中使用 AI 智能体进行 TDD 的掌握程度。先编写契约和测试,然后让编码智能体实现能通过它们的代码。

前置条件

要跟随本教程操作,你需要在机器上准备几个工具:

  • Python 3.11 或更新版本,以及 pytest
  • 一个能读取和写入项目文件的编码智能体

示例项目除了 Python 标准库之外不导入任何东西,因此 pytest 是你唯一需要安装的包。先创建并激活一个虚拟环境,然后在其安装 pytest。

你应该熟悉 pytest,包括如何参数化测试。有测试驱动开发的经验也有帮助,但并非必需。如果你想先做些练习,Real Python 的《使用 pytest 进行测试驱动开发》视频课程会向你展示如何编写单元测试、运行它们,并在用户之前发现 bug。本教程将一步步带你走完这个循环。

这个演示使用 Claude Code,但这个循环并不依赖它。其他具备仓库感知能力的智能体,比如 GitHub Copilot CLI、Antigravity CLI 和 OpenCode,也可以遵循同样的工作流。如果你以前没有用过这类工具,那么 Real Python 的 AI 编码智能体指南解释了 IDE、终端、拉取请求和云端智能体如何各自融入 Python 工作流。

Building With AI Agents Live Course:想在更大的项目上练习这个工作流吗?在 Real Python 的 Building Python Projects With AI Agents 直播课程中,你会构建一个真实项目,由智能体写出每一行代码,而你负责编写规格说明、评判返回的结果,并磨炼你的测试判断力。加入候补名单,以便获知下一期日期。

使用 AI 智能体进行 TDD 的循环

这个循环的每一轮都有五个步骤。你负责其中三个,让智能体负责两个:

  • 定义契约并编写第一个测试:你决定这个功能在外部应该如何表现,并手写第一个测试。
  • 让智能体起草测试:智能体阅读你的契约和你的第一个测试,然后以相同风格生成更多测试用例。
  • 审查并加固测试:你对照契约检查生成的测试,并补充任何缺失的边界情况。
  • 让智能体实现:智能体编写代码直到测试通过,同时你阻止对 tests/ 的写入。
  • 审查差异:你检查代码变更,然后进入下一个功能。

第 2 步正是这个循环与把整个功能交给智能体的不同之处。智能体在起草测试时只阅读你的契约和你的第一个测试。如果你在实现代码已经存在之后才要求生成测试,那么测试描述的就是那段代码,连同 bug 一起。

第 1 步:定义契约并编写第一个测试

第一步由你完成。在智能体写下任何内容之前,你决定这个功能做什么,并把这一决定锁定到一个测试中。智能体之后产出的所有内容都必须符合你在这里设定的形态。

你将构建用来练习 TDD 工作流的功能是一个 Version 类,它把版本字符串转换成可以用 < 和 > 比较的对象。你会先铺设项目结构,然后定义 Version 承诺了什么,并编写把这个承诺固定下来的测试。

设置项目

你会构建一个采用扁平布局的小项目。你的实现将放在 core.py 中,测试将放在单独的 tests/ 目录中:


        version-check/
│
├── version_check/
│   ├── __init__.py
│   └── core.py
│
└── tests/
    └── test_core.py
      

现在创建这些目录和文件,包括一个空的 core.py,智能体之后会填充它。然后从 __init__.py 导出公开的 Version 名称:


        from version_check.core import Version

__all__ = ["Version"]
      

这种再导出让你的测试可以直接从 version_check 导入 Version,因此它们不依赖于是哪个模块定义了这个类。

定义契约

在你编写任何代码之前,先决定你的功能对调用方承诺了什么。

契约描述调用方可以期待什么:他们提供的输入、他们得到的结果,以及他们可能遇到的错误。它完全不说明这些内容在内部如何运作。

当智能体在下一步编写测试时,这种分离很重要。智能体应该看到你的契约和你的测试,然后决定如何实现它们。如果你把实现计划也交给它,那么你得到的测试只会检查你的计划,而不是你想要的行为。那些测试会在你每次改动内部实现时失败,即使功能的行为仍然相同。

现在,为你的版本比较器编写契约。这个功能回答一个问题:给定两个版本字符串,哪一个排在前面?每当软件处理发布版本时,这个问题就会出现,比如当你检查已安装的包是否满足最低要求,或从列表中选择最新发布版本时。

Python 的版本规则比这个 TDD 示例所需的更广泛,所以你会聚焦于一个子集:

  • Release segments:像 1.2.0 这样的数字版本
  • Pre-releases:像 1.0a1、1.0b1 和 1.0rc1 这样的早期版本
  • Developmental releases:像 1.0.dev1 这样的进行中构建
  • Post-releases:像 1.0.post1 这样的后续更新

规范的其他部分,例如 epochs、local versions 和 v 前缀,不在范围内。不过,你之后可以通过重复这个循环来扩展契约,这是一个练习更多内容的好机会!

详细描述所有这些边界,包括什么应该排在什么之前,会给你的 agent 一个坚实的契约来处理。不过,在本教程中,你想和 AI agent 一起练习 TDD 循环,包括修订和潜在的陷阱,所以你会写一个故意规格不全的契约,只包含三个具体承诺:

  • Version(text) 将字符串解析为可比较的对象。
  • Version 实例使用 Python 的标准比较运算符进行比较。
  • 无效字符串引发 ValueError。

每个承诺都描述了调用方看到的内容。它们都没有说明内部解析如何工作,这是故意的。agent 需要在不知道实现细节的情况下获得契约,这样它才能生成测试来检查你承诺的行为。

手写第一个测试

现在你自己写第一个测试。它命名类、传入字符串并比较结果。如果你只在提示中描述行为,那么你会留下更多解释空间,特别是当契约没有完全充实的时候。如果你还在测试中表达该行为,那么你会让它更清晰。从两个断言开始:


        from version_check import Version

def test_equal_versions_compare_equal():
    assert Version("1.2.0") == Version("1.2.0")

def test_smaller_release_sorts_first():
    assert Version("1.2.0") < Version("1.3.0")
      

这两个断言支持你的契约。你不是调用单独的解析函数,而是通过传入字符串来实例化一个 Version 对象。你还使用标准 Python 比较运算符(这里是 == 和 <)比较两个实例,而不是编写自定义方法。

现在从项目根目录运行 python -m pytest。通过 python -m 运行 pytest 会把项目放到导入路径上。由于 core.py 仍然是空的,预计运行会失败:


        (.venv) $ python -m pytest
...
E   ImportError: cannot import name 'Version' from 'version_check.core'...
=========================== short test summary info ===========================
ERROR tests/test_core.py
!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
      

像这样的失败运行就是 TDD 所说的红色状态,每个新行为都从这里开始。当测试描述了代码尚不具备的行为时,测试套件会失败。一旦代码让测试通过,套件就会变绿,然后你进行重构。这就是为什么 TDD 也被称为红-绿-重构循环。

现在,测试因 ImportError 失败,因为 Version 不存在。你的契约作为测试存在,但还没有构建任何东西来满足它。当你在 Step 4 中移交实现时,agent 会填充 core.py。

Step 2:让 Agent 起草测试

现在轮到 agent 了。它读取你的契约和第一个测试,然后在 core.py 仍为空时扩展测试套件。agent 没有实现可读,所以你的测试是它唯一能看到的东西。你的提示告诉 agent 要写什么、不要动什么。从 version-check/ 项目根目录启动你的 agent,并给它这个提示:


        My Version class has tests in tests/test_core.py but no implementation yet.

The contract is:
- Version(text) parses a string into a comparable object.
- Version instances compare with Python's standard comparison operators.
- Invalid strings raise ValueError.

Add more tests to the same file, in the same style, covering the contract.
Don't write the implementation, and don't change the existing test cases.
      

注意提示中遗漏了什么。它没有列出要覆盖的用例,也没有说明 Version 内部应如何工作。契约列出了承诺,测试展示了形态。以下是某次运行中智能体生成的内容:


        # ...

def test_versions_with_different_lengths_compare():
    assert Version("1.2") < Version("1.2.1")

def test_greater_than_works():
    assert Version("2.0.0") > Version("1.9.9")

def test_unequal_versions_are_not_equal():
    assert Version("1.0.0") != Version("1.0.1")

def test_double_digit_segments_sort_numerically():
    assert Version("3.9") < Version("3.10")

def test_sorting_a_list_of_versions():
    versions = [Version("1.10.0"), Version("1.2.0"), Version("1.9.0")]
    assert sorted(versions) == [
        Version("1.2.0"),
        Version("1.9.0"),
        Version("1.10.0"),
    ]

def test_empty_string_raises_value_error():
    with pytest.raises(ValueError):
        Version("")

# ...
      

你的运行结果会有所不同,因为智能体很少两次产生相同输出,尤其当契约比较宽松时。在这次运行中,智能体覆盖了比较运算符、不同长度的版本,以及像 3.9 对 3.10 这样的多位数段。

有些测试超出了你的契约。例如,智能体添加了一个用 sorted() 对版本列表排序的用例,即使你的契约没有提到排序。为了避免引入你原本不打算遵守的承诺,你需要在下一步仔细审查生成的测试。

第 3 步:审查并加固测试

又轮到你了。加固是扩展测试套件的过程,以覆盖你最初契约中遗漏的决策,或智能体可能对规格做出不同解释的边界情况。

首先,对照你的契约阅读起草的测试。如果某个测试重述了契约,就可以保留。如果某个测试添加了你没有要求的行为,那么智能体已经替你做了一个设计决策,你需要决定是否想要它。

在 test_sorting_a_list_of_versions() 中,智能体测试了你的契约未指定的行为。你承诺两个实例可以比较,但这个测试断言整个列表会落入一种一致的顺序。仅靠两两比较并不能保证这一点,保留这个测试会把一致性排序变成一项承诺。

暂时删除它。如果你想承诺排序可用,就在循环的下一轮把它加入契约。

还有两个测试悄悄替你决定了行为:

  • test_versions_with_different_lengths_compare() 断言 1.2 < 1.2.1,这意味着较长的发布版本可以排在较短版本之前
  • test_double_digit_segments_sort_numerically() 断言 3.9 < 3.10,这会按数值而不是按字典序对段进行排序

这两条规则都与你对版本比较器的最初计划一致,所以应保留它们。不过,重要的是要注意,你刚刚接受了智能体做出的两个设计决策——通过不反对它们。

不过,请仔细看第一个测试。按照 Python 的版本号规则,缺失的段按零计算,所以 1.2 和 1.2.0 是同一个版本。但无论实现是否遵循该规则,1.2 < 1.2.1 都成立。一个测试可以看起来固定了某条规则,却没有真正测试它。稍后你会补上这个缺口。

注意:在本教程中,你让智能体基于一个故意规格不足的契约工作,以便更清楚地凸显流程和可能遇到的坑。当你为现实项目编写契约时,应尽量让初始契约尽可能完整,以便给智能体清晰的工作准则。

你应该始终亲自读一遍起草出来的测试,而不是只扫一眼通过数量。它们可能暴露出一些行为决策,需要你审阅后决定保留还是否决。默默接受起草的测试——尤其是在规格不足的契约下起草的测试——可能会悄悄地把代码实现的基准从你的本意上挪开。

你还可能发现未被覆盖的情况。由你决定保留或补充哪些,本步骤余下部分对两者都适用。

加固测试遗漏的规则

你在第 1 步中已经恰当地界定了预发布版本(pre-release)、开发版本(developmental release)和后发布版本(post-release)的范围。然而,如果你回头看看你实际发出的 prompt,会发现它只列出了那三个承诺,别的什么都没说。agent 从未见过这些发布类型,因此很可能没有生成任何阶段排序的测试。

请记住:不完整的契约会产生不完整的测试套件。你将用新的手写测试来补上这些遗漏。

从你在第一份起草测试中发现的缺口开始。如果一个版本在末尾补零,它应当等于未补零的版本:


        import pytest

# ...

@pytest.mark.parametrize(
    "shorter, longer",
    [
        ("1.2", "1.2.0"),          # One missing segment
        ("1", "1.0.0"),            # Two missing segments
        ("1.0a1", "1.0.0a1"),      # Padding with a pre-release
    ],
)
def test_missing_segments_count_as_zero(shorter, longer):
    assert Version(shorter) == Version(longer)
      

与 1.2 < 1.2.1 不同,这个测试只有在实现把缺失的段视为零时才会通过。

接下来是发布阶段。按照规范,Python 对这些阶段的排序如下:


        1.0.dev1  <  1.0a1  <  1.0  <  1.0.post1
      

起草的测试套件可能已经覆盖了这一点,也可能没有。无论哪种情况,你都应该确认。一个参数化测试就能把整个序列钉在一个地方:


        # ...

@pytest.mark.parametrize(
    "lower, higher",
    [
        ("1.0.dev1", "1.0"),       # Dev before final
        ("1.0a1", "1.0"),          # Pre-release before final
        ("1.0", "1.0.post1"),      # Post-release after final
        ("1.0.dev1", "1.0a1"),     # Dev before pre-release
        ("1.0a1", "1.0b1"),        # Alpha before beta
        ("1.0b1", "1.0rc1"),       # Beta before release candidate
        ("1.0.dev1", "1.0.post1"), # Dev before post, spanning the release
    ],
)
def test_phase_ordering(lower, higher):
    assert Version(lower) < Version(higher)
      

如果起草的测试还没有导入 pytest,那么就在文件顶部加上 import pytest。最后一个用例横跨整个序列,从 1.0.dev1 到 1.0.post1。只检查相邻对的测试套件,即使实现完全忽略了某个阶段也照样能通过。

既然 agent 可能猜对顺序,为什么还要手写这个测试?虽然有可能,但未经核验的猜测终究只是猜测,而测试正是你验证它的方式。没有针对性的测试,实现可能用了不同的排序规则却仍然通过套件。

加固失败用例

你的契约规定,无效字符串应抛出 ValueError。这是第三个承诺,但你的测试套件可能没有完全覆盖它。想一想调用者实际可能输入什么。

像 1.x.0 这样的字符串具有版本的外形,因此实现可能接受它,并拿它去和真实版本比较。抛出明确的错误,比返回一个看起来有效却不正确的结果更安全。要落实这个承诺,你可以用 pytest.raises() 来钉住无效输入下的行为:


        # ...

@pytest.mark.parametrize(
    "text",
    [
        "",           # Empty string
        "   ",        # Whitespace only
        "1.x.0",      # Non-numeric segment
        "banana",     # Not a version at all
        "1..0",       # Empty segment
    ],
)
def test_invalid_input_raises(text):
    with pytest.raises(ValueError):
        Version(text)
      

每个用例都代表一个设计决策。检查空字符串和空白,有助于处理可能来自空表单字段或文件空行的输入。其余用例定义了有效版本与只是看起来像版本的字符串之间的边界。如果草拟的测试中有任何用例与这些无效输入用例重复,就可以删掉它们。

再次运行测试套件。它仍因同样的 ImportError 保持红色,因为 core.py 仍为空。但现在你契约里的三项承诺都有测试了,agent 也掌握了下一步所需的全部信息。

第 4 步:让 Agent 实现

现在又轮到 agent 了。它读取失败的测试并编写代码直到测试通过,而测试保持不动。

你可以在提示词里要求 agent 不要动你的测试,但请求不是规则。在移交实现之前,你需要给 tests/ 围上围栏,阻止 agent 在那里写入。

给测试围上围栏

你会通过权限规则来建立这道围栏。大多数编码 agent 都有权限系统,可以拒绝写入某个路径,所以查一下你的 agent 文档里的等效选项。下面的示例使用 Claude Code,它从项目设置中读取权限规则。

注意:如果你的 agent 没有权限系统,可以跳到下一节直接移交实现。在那里给提示词加一行类似 Don't modify anything in tests/. 的内容。由于请求不会被强制执行,之后要检查测试是否有改动。

在项目根目录创建 .claude/settings.json:


        {
  "permissions": {
    "deny": ["Edit(/tests/**)"]
  }
}
      

前导斜杠会把模式锚定到项目根目录,因此规则匹配的是 version-check/tests/,而不是其他位置的 tests/ 目录。一个斜杠指向你的项目,两个斜杠则会指向文件系统根目录。

这一条规则覆盖的范围不止 Edit 工具。它会阻止所有写入文件的内置工具,以及 Claude Code 在 Bash 中能识别的文件命令和输出重定向。更多细节见权限参考。

注意:这条 deny 规则阻止的是 agent 的工具,而不是 agent 运行的程序。如果 agent 写了一个 Python 脚本并在你的终端里运行它,这个脚本仍然可以修改你的测试。如果你想连这类脚本也一并阻止,可以使用 Claude Code 的沙箱功能。

运行 /permissions,确认 Edit(/tests/**) 出现在 deny 规则下。如果没有,检查你是否从项目根目录启动 Claude Code,因为它会在那里查找 .claude/settings.json。

这道围栏只在 agent 实现期间保持生效。循环的下一轮,agent 又需要编写测试,所以记得在要求它写测试之前禁用该规则。你可以用 /permissions 命令切换规则,而无需编辑文件。

移交实现

围栏就位后,你的提示词可以很短。测试承载契约,围栏承载约束,所以你只需要说明要构建什么:


        Implement the Version class so my tests pass.
Use only the standard library.
Keep it minimal.
      

agent 读取失败的测试和空的 core.py,然后编写实现。下面是某次运行产生的结果:


        import re
from functools import total_ordering

_VERSION = re.compile(
    r"^\s*(?P<release>\d+(?:\.\d+)*)"
    r"(?:(?P<pre_label>a|b|rc)(?P<pre_num>\d+))?"
    r"(?:\.post(?P<post>\d+))?"
    r"(?:\.dev(?P<dev>\d+))?\s*$"
)
_PRE_ORDER = {"a": 0, "b": 1, "rc": 2}
      

文章标题:TDD with AI Agents: Design the Tests First, Let the Agent Implement

正文: @total_ordering class Version: def __init__(self, text): match = _VERSION.match(text) if match is None: raise ValueError(f"invalid version string: {text!r}") self._release = tuple( int(part) for part in match["release"].split(".") ) if match["pre_label"] is not None: self._pre = ( _PRE_ORDER[match["pre_label"]], int(match["pre_num"]) ) else: self._pre = None self._post = int(match["post"]) if match["post"] else None self._dev = int(match["dev"]) if match["dev"] else None

def _key(self): release = self._release while len(release) > 1 and release[-1] == 0: release = release[:-1] if self._dev is not None and self._pre is None: phase = (0, self._dev) elif self._pre is not None: phase = (1, self._pre) elif self._post is not None: phase = (3, self._post) else: phase = (2, 0) return (release, phase)

def __eq__(self, other): if not isinstance(other, Version): return NotImplemented return self._key() == other._key()

def __lt__(self, other): if not isinstance(other, Version): return NotImplemented return self._key() < other._key()


        
现在运行测试套件:

      

(.venv) $ python -m pytest ...

tests/test_core.py ..................... [100%]

======================= 21 passed in 0.03s =======================


        
这次运行中,测试全部通过!`._key()` 方法用数字给每个阶段排序:0 表示开发版本,1 表示预发布版本,2 表示正式版本,3 表示后发布版本。这个顺序是你在参数化测试中决定的,agent 必须与之匹配。它还会去掉发布版本号末尾的零,因此 1.2 和 1.2.0 会构建出相同的键。这就是你的补零测试所强制的规则。

在下面选择两个版本,看看 `._key()` 为每个版本构建的元组,以及它如何决定哪个版本排在前面:

然而,测试全部通过只能告诉你你所指定的行为。它对 diff 中的其余部分只字未提,而那些仍然需要你审查。

## 第 5 步:审查 Diff

最后一步由你来做。你的测试确认实现与你写下的行为一致,但 diff 中的任何其他代码都是在没有你指示的情况下生成的。

你应该仔细阅读 diff。寻找你未曾要求的导入和依赖、没有测试覆盖的分支,以及你的契约未涵盖的额外行为。虽然其中一些添加可能无害甚至有用,但它们代表了 agent 替你做出的决定。

如果你发现值得保留的生成代码,那就为它写一个测试。否则,那段代码将处于无保护状态,循环的下一次迭代可能会悄悄地把它移除。

在所示的这次运行中,生成的 `.__eq__()` 方法在另一个对象不是 Version 实例时返回 NotImplemented。你的运行可能不包含这个检查:

      

...

def __eq__(self, other): if not isinstance(other, Version): return NotImplemented return self._key() == other._key()

...


        
你的测试套件没有要求这个检查,但这是一个合理的设计选择。返回 NotImplemented 允许 Python 尝试比较另一个操作数,而不是抛出一个令人困惑的 AttributeError。如果你想保留这个保护措施,那就用一个测试来记录它:

      

...

def test_comparing_against_other_types_returns_notimplemented(): assert Version("1.0").__eq__("1.0") is NotImplemented

再运行一次测试套件。这个测试会立即通过,因为该行为已经存在于 core.py 中。

这也是你可以进行重构的地方。如果你发现值得清理的代码,那就趁测试全部通过、围栏仍然立着的时候现在就做。在第一次迭代中,实现足够小,可以保持原样。

这就完成了循环的第一轮。在开始下一轮之前,请注意你的契约——即承诺加上固定这些承诺的测试——已经扩展了。三个承诺仍然存在,并且你添加了一些测试。第二轮的工作方式略有不同,因为 core.py 不再是空的。你仍然先设计,所以让 agent 根据你的契约而不是实现来起草测试。

排查问题

在运行这个循环时,经常会出现三个问题:

  • Agent 为了让测试通过而修改了测试:检查防护栏是否已启用。在 Claude Code 中,运行 /permissions 确认规则存在。
  • 测试通过了,但实现是错误的:你的测试套件所覆盖的内容比你想象的少。回去加固测试。添加暴露缺口的用例,并在再次运行循环之前观察它失败。
  • 起草的测试只是重述了实现:在第二轮及之后,代码已经存在供 agent 阅读。对照你的契约而不是代码来检查每个起草的测试,并删除那些只描述已有内容的测试。

当循环中出问题时,先阅读你的测试,再阅读实现。

后续步骤

你的 Version 类覆盖了你在第 1 步中划定范围的子集。它对 developmental、pre-、final 和 post-release 进行排序,并拒绝不是版本的字符串。

你现在有了一个可重复的 TDD 循环,用于借助 AI agent 构建功能。你定义了契约,编写了第一个测试,让 agent 起草其余的测试,加固了输出,并审查了生成的代码。只有你能为你的功能定义正确的行为,而测试就是你写下它的地方。

你的测试套件在功能发布后继续工作。每当代码发生变化时,无论变化是你还是 agent 做出的,它都能捕获回归。

从这里开始,你可以更深入:

  • 通过 Real Python 的测试教程来磨练你的测试技能,或跟随 Testing and Continuous Integration 学习路径。
  • 通过 Agentic Engineering in Python: From Vibes to Evidence 将循环扩展到测试之外。
  • 通过 How to Set Up a Python Project for Agentic Coding 让 agent 从 linter、类型检查器和 pre-commit 钩子获得快速反馈。
  • 通过 How to Review AI-Generated Python Code Efficiently 将 agent 引入审查步骤。
  • 通过探索 Real Python 的 Python Coding With AI 学习路径,借助 AI 提高你的编码技能。

你可以将这个循环应用于你接下来构建的任何东西。Agent 在编写代码方面会越来越好,但设计决策仍然属于你。

获取你的代码:点击此处下载免费示例代码,你将通过先设计测试并让 AI agent 编写实现来构建一个 Python 版本比较器。

参加测验:通过我们的交互式“TDD With AI Agents: Design the Tests First, Let the Agent Implement”测验来测试你的知识。完成测验后你将获得分数,以帮助跟踪你的学习进度:

交互式测验

检查你在 Python 中借助 AI agent 进行 TDD 的掌握程度。先编写契约和测试,然后让编码 agent 实现通过它们的代码。

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by HN AI
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗