1
00:00:00,280 --> 00:00:02,720
Well, this is a bittersweet moment for sure.
嗯，这肯定是一个苦乐参半的时刻。

2
00:00:02,760 --> 00:00:05,720
It is the final day of our journey with crew.
这是我们与船员一起旅程的最后一天。

3
00:00:06,000 --> 00:00:07,720
Fifth day of week three.
第三周的第五天。

4
00:00:07,760 --> 00:00:12,440
While we complete the work we've got with crew, and it's going to be a great one.
当我们与工作人员一起完成工作时，这将是一项伟大的工作。

5
00:00:12,880 --> 00:00:14,000
We're going to end on a high.
我们将以高点结束。

6
00:00:14,040 --> 00:00:17,440
We are going to build on the project we did last time.
我们将在上次完成的项目的基础上继续进行。

7
00:00:17,480 --> 00:00:21,880
On day four, we're going to turn our coda into an engineering team.
第四天，我们将把我们的尾声变成一个工程团队。

8
00:00:21,920 --> 00:00:28,120
We're going to have an engineering lead depicted here by this person chilling out because, you know,
我们将在这里描绘一位工程主管，这个人会冷静下来，因为，你知道，

9
00:00:28,160 --> 00:00:29,640
that's what what leads do.
这就是潜在客户所做的事情。

10
00:00:29,880 --> 00:00:32,280
Uh, we're going to have a back end engineer.
呃，我们将有一名后端工程师。

11
00:00:32,280 --> 00:00:38,840
We're going to have a front end engineer, and we're going to have a test engineer seen here as someone
我们将有一名前端工程师，我们将有一名测试工程师，这里被视为某人

12
00:00:38,840 --> 00:00:44,600
that's jumping on top, trying to trying to destroy, trying to break everything that they are given.
那是跳到上面，试图摧毁，试图破坏他们所得到的一切。

13
00:00:44,920 --> 00:00:46,440
So this is going to be our team.
这将是我们的团队。

14
00:00:46,440 --> 00:00:48,840
We're going to really use the crew and crew.
我们将真正使用工作人员和工作人员。

15
00:00:48,880 --> 00:00:51,400
I let's get to it.
我让我们开始吧。

16
00:00:51,640 --> 00:00:53,200
And welcome back to cursor.
欢迎回到光标。

17
00:00:53,240 --> 00:00:56,560
Welcome to our final project for crew.
欢迎来到我们为船员准备的最终项目。

18
00:00:57,000 --> 00:01:01,080
Let's bring up a terminal with control and the back tick.
让我们打开一个带有控制和反勾的终端。

19
00:01:01,360 --> 00:01:04,080
Let's go into that third directory.
让我们进入第三个目录。

20
00:01:04,080 --> 00:01:06,880
And now, of course, it is time to do crew.
现在，当然，是时候做船员了。

21
00:01:06,920 --> 00:01:11,000
I create crew and it is engineering.
我创建了船员，这是工程。

22
00:01:11,160 --> 00:01:14,760
Underscore team is the name of our project.
Underscore团队是我们项目的名称。

23
00:01:15,200 --> 00:01:15,880
Let's do it.
我们开始做吧。

24
00:01:15,880 --> 00:01:17,880
Let's choose the options that it tells us.
让我们选择它告诉我们的选项。

25
00:01:17,880 --> 00:01:18,920
We want OpenAI.
我们想要 OpenAI。

26
00:01:19,320 --> 00:01:20,800
We want GPT four or mini.
我们想要 GPT 4 或 mini。

27
00:01:20,800 --> 00:01:23,560
And then we skip making a token.
然后我们跳过制作令牌。

28
00:01:23,560 --> 00:01:26,720
And then there we have our directory structure.
然后我们就有了目录结构。

29
00:01:26,920 --> 00:01:29,880
And now of course we go into engineering team.
现在我们当然要进入工程团队了。

30
00:01:29,920 --> 00:01:35,800
We go into source, we go into config and we open our agents YAML file.
我们进入源代码，进入配置，然后打开代理 YAML 文件。

31
00:01:35,800 --> 00:01:41,280
As usual we see the boilerplate ones there the researcher and the reporting analyst.
像往常一样，我们在研究人员和报告分析师那里看到了样板文件。

32
00:01:41,880 --> 00:01:43,960
So what are we going to do.
那么我们该怎么办呢？

33
00:01:43,960 --> 00:01:46,840
Well we're going to first of all delete what we have here.
好吧，我们首先要删除这里的内容。

34
00:01:47,000 --> 00:01:49,200
And we're going to put in our first agent.
我们将派出第一位特工。

35
00:01:49,360 --> 00:01:54,520
And our first agent is going to be an engineering lead, the engineering lead for the engineering team
我们的第一个代理将成为工程主管，工程团队的工程主管

36
00:01:55,040 --> 00:01:57,640
directing the work of the engineers.
指导工程师的工作。

37
00:01:57,680 --> 00:02:05,480
Let's make that plural, take the high level requirements described here and prepare a detailed design
让我们采用复数形式，采用此处描述的高级要求并准备详细的设计

38
00:02:05,480 --> 00:02:06,920
for the back end developer.
对于后端开发人员。

39
00:02:06,960 --> 00:02:08,520
Maybe we'll leave this singular for now.
也许我们暂时保留这个单数。

40
00:02:08,560 --> 00:02:12,600
If it's just one developer, everything should be in one Python module.
如果只有一名开发人员，那么一切都应该在一个 Python 模块中。

41
00:02:12,600 --> 00:02:15,640
Describe the function the method signatures in the module.
描述模块中的函数和方法签名。

42
00:02:15,680 --> 00:02:21,000
The Python module must be completely self-contained and ready so that it can be tested or have a simple
Python 模块必须完全独立并准备就绪，以便可以对其进行测试或具有简单的功能

43
00:02:21,000 --> 00:02:22,160
UI built.
用户界面已构建。

44
00:02:22,280 --> 00:02:23,480
Here are the requirements.
这是要求。

45
00:02:23,480 --> 00:02:27,800
So this is going to be one of our input attributes that we can pass in.
所以这将是我们可以传入的输入属性之一。

46
00:02:28,200 --> 00:02:30,680
The module should be named module name.
该模块应命名为模块名称。

47
00:02:30,680 --> 00:02:33,320
And the class should be named class name.
并且类应该命名为类名。

48
00:02:33,320 --> 00:02:36,400
So we are going to bring in those as well.
所以我们也将引入这些。

49
00:02:36,400 --> 00:02:38,720
So we're going to have this be a little bit configurable.
所以我们要让它稍微可配置。

50
00:02:39,080 --> 00:02:43,920
And the backstory you're a seasoned engineering lead with a knack for writing clear and concise designs
背景故事您是一位经验丰富的工程主管，擅长编写清晰简洁的设计

51
00:02:43,960 --> 00:02:44,920
okay there we go.
好吧，我们走吧。

52
00:02:44,920 --> 00:02:50,000
So so look, I'm going to put on an LM now and let's have something different to usual.
所以，听着，我现在要穿上LM，让我们来点与平常不同的东西。

53
00:02:50,000 --> 00:02:51,680
I think we're going to go with Gpt4.
我想我们会选择 Gpt4。

54
00:02:51,720 --> 00:02:53,440
We're going to have the big guy you.
我们将迎来你这个大人物。

55
00:02:53,480 --> 00:02:56,720
I've also run this with Gpt4 on many and it runs just fine.
我也在许多设备上使用 Gpt4 运行过它，并且运行得很好。

56
00:02:56,720 --> 00:02:58,280
So you can do that too if you wish.
因此，如果您愿意，您也可以这样做。

57
00:02:58,480 --> 00:03:03,560
And you get, you know, you get a bit more comprehensive, extensive solutions if you use its bigger
如果您使用更大的解决方案，您会得到更全面、更广泛的解决方案

58
00:03:03,560 --> 00:03:04,840
cousin GPT four.
表弟 GPT 四。

59
00:03:04,880 --> 00:03:06,280
Oh okay.
哦好的。

60
00:03:06,600 --> 00:03:06,960
so.
所以。

61
00:03:07,000 --> 00:03:12,520
And whilst that will work, of course the full way to do it is to show this is OpenAI slash like that
虽然这会起作用，但当然，完整的方法是显示这是 OpenAI 斜线，就像这样

62
00:03:12,520 --> 00:03:13,440
with the provider.
与提供商。

63
00:03:14,240 --> 00:03:16,920
That is the first of our agents.
这是我们的第一个代理。

64
00:03:17,600 --> 00:03:17,960
Okay.
好的。

65
00:03:18,000 --> 00:03:22,120
So the next agent is going to be called a backend engineer.
所以下一个代理将被称为后端工程师。

66
00:03:22,280 --> 00:03:29,960
So the backend engineer is going to be a Python engineer who can write code to achieve the design described
所以后端工程师将是一名Python工程师，他可以编写代码来实现所描述的设计

67
00:03:29,960 --> 00:03:31,200
by the engineering lead.
由工程主管。

68
00:03:31,200 --> 00:03:36,160
So the engineering lead will do the design will lay out the sort of foundations, and the back end engineer
因此，工程主管将进行设计，奠定基础，后端工程师

69
00:03:36,160 --> 00:03:42,480
will do the coding write Python module that implements the design described by the engineering lead,
将编写Python模块的编码，以实现工程主管描述的设计，

70
00:03:42,480 --> 00:03:44,560
but will also pass in the requirements again.
但也会再次传递要求。

71
00:03:44,560 --> 00:03:49,480
So it's going to get the requirements along with the design and the module name and class name again.
因此它将再次获取需求以及设计以及模块名称和类名称。

72
00:03:49,720 --> 00:03:56,000
And it's given a decent backstory saying that it's a Python engineer with a knack for writing clean,
它有一个不错的背景故事，说它是一位具有干净编写技巧的 Python 工程师，

73
00:03:56,040 --> 00:03:57,480
efficient code.
高效的代码。

74
00:03:57,880 --> 00:04:00,000
Follow the design instructions carefully.
仔细遵循设计说明。

75
00:04:00,400 --> 00:04:01,760
So again, we'll use a different model.
同样，我们将使用不同的模型。

76
00:04:01,760 --> 00:04:06,480
We'll mix things up, and this time I suggest we use Claude 3.7 sonnet latest.
我们会把事情混合起来，这次我建议我们使用最新的 Claude 3.7 十四行诗。

77
00:04:06,520 --> 00:04:10,240
Now sometimes we get an overload error from Claude?
现在有时我们会从克劳德那里得到一个过载错误？

78
00:04:10,280 --> 00:04:11,080
At least I do.
至少我是这样的。

79
00:04:11,120 --> 00:04:11,880
As of now.
截至目前。

80
00:04:12,040 --> 00:04:17,200
So it's a little bit less stable, but nonetheless, it's a great coding model.
所以它的稳定性有点差，但尽管如此，它是一个很棒的编码模型。

81
00:04:17,240 --> 00:04:18,400
Particularly so.
尤其如此。

82
00:04:18,400 --> 00:04:21,160
I think it's a good one to use in this case.
我认为在这种情况下使用它是一个很好的选择。

83
00:04:21,600 --> 00:04:22,080
All right.
好的。

84
00:04:22,080 --> 00:04:24,880
Let's also add a front end engineer.
我们还添加一名前端工程师。

85
00:04:25,360 --> 00:04:26,600
And I say front end engineer.
我说的是前端工程师。

86
00:04:26,600 --> 00:04:32,560
But it's going to be a gradio engineer a gradio expert who can write a simple front end to demonstrate
但这将是一个渐变工程师，一个渐变专家，可以编写一个简单的前端来演示

87
00:04:32,560 --> 00:04:39,360
a back end writer gradio UI that demonstrates the given back end all in one file to be in the same directory
后端编写器 gradio UI，演示给定的后端全部位于一个文件中，位于同一目录中

88
00:04:39,680 --> 00:04:43,440
as the back end module, giving the requirements.
作为后端模块，给出需求。

89
00:04:43,480 --> 00:04:45,040
Giving the back story.
给出背景故事。

90
00:04:45,200 --> 00:04:50,520
A seasoned engineer highly skilled at writing simple gradio UIs for a back end class.
一位经验丰富的工程师，非常擅长为后端类编写简单的渐变 UI。

91
00:04:51,000 --> 00:04:52,400
So there we have it.
所以我们就有了。

92
00:04:53,280 --> 00:05:00,360
We, uh, explained that the UI needs to be in one module, and we'll use again Claude for this too.
我们，呃，解释说 UI 需要位于一个模块中，我们也将再次使用 Claude 来实现这一点。

93
00:05:00,960 --> 00:05:01,320
Okay.
好的。

94
00:05:01,360 --> 00:05:02,320
And one more agent.
还有一名经纪人。

95
00:05:02,360 --> 00:05:08,320
Our final agent is going to be a test engineer, but I'm slightly abusing the word there.
我们的最终代理将是一名测试工程师，但我稍微滥用了这个词。

96
00:05:08,320 --> 00:05:08,600
It's not.
它不是。

97
00:05:08,600 --> 00:05:10,000
It's not like a QA engineer.
它不像 QA 工程师。

98
00:05:10,000 --> 00:05:16,360
This is going to be a Python coder who knows how to write unit tests for a given backend module, because
这将是一个知道如何为给定后端模块编写单元测试的 Python 编码员，因为

99
00:05:16,360 --> 00:05:20,000
I want to see unit tests being built out here.
我希望看到在这里构建单元测试。

100
00:05:20,200 --> 00:05:22,000
So that's what the test engineer is going to do.
这就是测试工程师要做的事情。

101
00:05:22,040 --> 00:05:26,800
They're going to create a test which is going to be called test underscore.
他们将创建一个称为测试下划线的测试。

102
00:05:26,800 --> 00:05:30,800
And the name of the module which will be the backend module.
以及将成为后端模块的模块的名称。

103
00:05:30,960 --> 00:05:35,720
And they're a seasoned QA engineer and software developer who writes great unit tests for Python.
他们是经验丰富的 QA 工程师和软件开发人员，为 Python 编写了出色的单元测试。

104
00:05:35,720 --> 00:05:38,000
Code is the backstory.
代码是背景故事。

105
00:05:38,160 --> 00:05:42,600
And you know, for for all of the coding part, we'll use anthropic.
你知道，对于所有编码部分，我们将使用人类。

106
00:05:42,840 --> 00:05:43,880
Maybe we should shake it up.
也许我们应该改变它。

107
00:05:43,880 --> 00:05:44,320
Why don't we?
我们为什么不呢？

108
00:05:44,360 --> 00:05:45,760
Why don't we take a risk?
我们为什么不冒险一下呢？

109
00:05:45,760 --> 00:05:47,480
We'll use deep seek instead.
我们将使用深度搜索来代替。

110
00:05:47,520 --> 00:05:48,240
Deep seek.
深寻。

111
00:05:48,480 --> 00:05:54,600
I'm just going to stick with deep seek chat because deep seek chat is has is also able to write terrific
我只会坚持使用深度搜索聊天，因为深度搜索聊天也能够写出很棒的文章

112
00:05:54,600 --> 00:05:55,440
code as well.
代码也是如此。

113
00:05:55,440 --> 00:05:59,680
So we'll we'll stick with that model and that will be our test engineer.
因此，我们将坚持使用该模型，这将是我们的测试工程师。

114
00:05:59,720 --> 00:06:01,640
Now it's time for us to go on to the tasks.
现在是我们继续执行任务的时候了。

115
00:06:02,440 --> 00:06:03,680
So look it's a bit repetitive.
所以看起来有点重复。

116
00:06:03,720 --> 00:06:05,200
We're going to let me get rid of the gunk.
我们会让我摆脱那些黏糊糊的东西。

117
00:06:05,240 --> 00:06:08,200
We're going to have a task for each agent.
我们将为每个代理分配一项任务。

118
00:06:08,200 --> 00:06:08,680
And it's funny.
这很有趣。

119
00:06:08,680 --> 00:06:14,720
This is one of those times when it feels like OpenAI's agents SDK is sort of more straightforward that
这是感觉 OpenAI 的代理 SDK 更简单的时候之一

120
00:06:14,720 --> 00:06:20,480
they don't have this extra indirection, this idea of a task being a separate first class object, because
他们没有这种额外的间接性，即任务是一个单独的第一类对象的想法，因为

121
00:06:20,480 --> 00:06:24,840
there's a lot of times that you will have this 1 to 1 mapping between a task and an agent.
很多时候，任务和代理之间会存在这种一对一的映射。

122
00:06:24,880 --> 00:06:29,240
Obviously, crew has built this up because they really want you to think in terms of situations where
显然，工作人员建立了这个，因为他们真的希望你考虑以下情况：

123
00:06:29,240 --> 00:06:33,280
you will have series of tasks that will be given to the same agent.
您将有一系列任务被分配给同一个代理。

124
00:06:33,280 --> 00:06:35,720
And we did see that and at least one of our examples.
我们确实看到了这一点，并且至少看到了我们的一个例子。

125
00:06:35,720 --> 00:06:41,120
But in this case, we are again going to have the case that there's going to be a task for each of our
但在这种情况下，我们将再次遇到这样的情况：我们的每个人都会有一个任务

126
00:06:41,120 --> 00:06:45,640
agents, and it gives us an opportunity to spell out very clearly what's required.
代理，它使我们有机会非常清楚地阐明需要什么。

127
00:06:46,360 --> 00:06:54,120
So the description of the task is to take the high level requirements described and prepare a detailed
所以任务的描述就是要把描述的高层次需求准备好一份详细的

128
00:06:54,120 --> 00:06:55,440
design for the engineer.
为工程师设计。

129
00:06:55,440 --> 00:07:00,520
This is the design task that, of course, is going to be assigned to our engineering lead.
当然，这是将分配给我们的工程主管的设计任务。

130
00:07:00,840 --> 00:07:03,800
And the output is a detailed design for the engineer.
输出的是工程师的详细设计。

131
00:07:04,320 --> 00:07:09,280
You'll notice that I make it important that it should only output the design in markdown format.
您会注意到，我强调它应该只以 Markdown 格式输出设计。

132
00:07:09,320 --> 00:07:14,120
Otherwise it just wants to start writing the code, which is not exactly what we want.
否则它只是想开始编写代码，这并不是我们想要的。

133
00:07:14,360 --> 00:07:19,440
And here we specify the the output as the module name underscore design.
而这里我们指定输出为模块名下划线设计。

134
00:07:19,440 --> 00:07:25,440
And it's worth noting that you can have these templated tags in the output file name as well.
值得注意的是，您也可以在输出文件名中包含这些模板化标签。

135
00:07:25,440 --> 00:07:31,480
You can have it anywhere in this YAML, and it will get substituted in for the actual name of the the
您可以将其放在此 YAML 中的任何位置，并且它将替换为实际名称

136
00:07:31,640 --> 00:07:33,120
module that we're building here.
我们在这里构建的模块。

137
00:07:33,960 --> 00:07:36,480
So that is the design task.
这就是设计任务。

138
00:07:36,520 --> 00:07:39,120
My next one cursor wants it to be called coding task.
我的下一个光标希望将其称为编码任务。

139
00:07:39,120 --> 00:07:41,760
But when I wrote it I wrote code task.
但我写的时候写的是代码任务。

140
00:07:41,800 --> 00:07:42,320
There we go.
我们开始吧。

141
00:07:42,600 --> 00:07:44,280
Uh, I'd like to be unpredictable.
呃，我想变得不可预测。

142
00:07:44,520 --> 00:07:51,280
Uh, so the description is write a Python module that implements the design as described by the engineering
呃，所以描述是编写一个Python模块来实现工程描述的设计

143
00:07:51,280 --> 00:07:53,560
lead in order to achieve the requirements.
从而达到要求的领先地位。

144
00:07:53,800 --> 00:07:59,920
And then here I'm saying important output only the Python code without any markdown formatting or code
然后在这里我说重要的是仅输出Python代码，没有任何markdown格式或代码

145
00:07:59,960 --> 00:08:02,080
block delimiters or backticks.
块分隔符或反引号。

146
00:08:02,280 --> 00:08:05,560
And that's important because these models love to output markdown.
这很重要，因为这些模型喜欢输出降价。

147
00:08:05,560 --> 00:08:09,680
And if you don't put that note in there, it's going to put that tick, tick, tick python at the top
如果你不把那个注释放在那里，它就会把那个勾号，勾号，勾号 python 放在顶部

148
00:08:09,680 --> 00:08:12,320
of the file, which means it won't be a valid Python file.
文件的名称，这意味着它不是有效的 Python 文件。

149
00:08:12,440 --> 00:08:14,080
And it just loves doing that.
它就是喜欢这样做。

150
00:08:14,080 --> 00:08:17,240
So unless you really highlight this is important, it's going to do it.
因此，除非你真的强调这很重要，否则它就会做到这一点。

151
00:08:17,600 --> 00:08:19,400
And so that is the task.
这就是任务。

152
00:08:19,400 --> 00:08:25,120
And we're saying context design task, which you remember is going to make sure that that information
我们说的是上下文设计任务，你记得它会确保该信息

153
00:08:25,120 --> 00:08:27,000
is made available to it.
可供其使用。

154
00:08:27,320 --> 00:08:32,360
And generally speaking you can think of the tasks as being the user prompts and the agents as defining
一般来说，您可以将任务视为用户提示，将代理视为定义

155
00:08:32,360 --> 00:08:35,520
the system prompts, and that that's kind of how it all comes together.
系统提示，这就是一切的组合方式。

156
00:08:35,520 --> 00:08:40,400
And this context is showing us what kind of information is going to be included in that prompt from
这个上下文向我们展示了什么样的信息将包含在来自

157
00:08:40,440 --> 00:08:41,040
others.
其他的。

158
00:08:41,720 --> 00:08:42,200
Okay.
好的。

159
00:08:42,240 --> 00:08:44,560
So that is the code task.
这就是代码任务。

160
00:08:44,560 --> 00:08:47,080
How about the front end task.
前端任务怎么样。

161
00:08:47,480 --> 00:08:49,560
So this is where the plot thickens.
所以这就是情节变得复杂的地方。

162
00:08:50,000 --> 00:08:58,360
The front end has got to write a Gradio UI in a module App.py that demonstrates the given back end class.
前端必须在模块 App.py 中编写一个 Gradio UI，以演示给定的后端类。

163
00:08:58,400 --> 00:09:03,280
Assume there's only one user and keep the UI very simple indeed.
假设只有一个用户，并保持 UI 确实非常简单。

164
00:09:03,320 --> 00:09:05,000
Just a prototype or demo.
只是原型或演示。

165
00:09:05,160 --> 00:09:06,520
Here are the requirements.
这是要求。

166
00:09:06,680 --> 00:09:08,720
And so yeah, we keep it.
所以，是的，我们保留它。

167
00:09:08,760 --> 00:09:10,200
Keep it nice and simple.
保持美观和简单。

168
00:09:10,840 --> 00:09:12,800
Maybe I'm going to take out the very simple indeed.
也许我会剔除那些确实非常简单的东西。

169
00:09:12,800 --> 00:09:16,280
Let's just say keep the UI simple and keep the UI clean.
我们只是说保持 UI 简单并保持 UI 干净。

170
00:09:17,040 --> 00:09:18,080
Let's leave it at that.
我们就这样吧。

171
00:09:18,960 --> 00:09:21,120
So, um, important.
所以，嗯，它们很重要。

172
00:09:21,120 --> 00:09:23,400
Only output the raw Python code again.
只再次输出原始Python代码。

173
00:09:23,440 --> 00:09:26,720
The agent is the front end engineer agent, obviously.
显然，该代理是前端工程师代理。

174
00:09:26,920 --> 00:09:32,720
And of course, for its context, it needs to get the output from the code task because it's going to
当然，对于它的上下文，它需要从代码任务中获取输出，因为它将

175
00:09:32,760 --> 00:09:38,240
write a user interface, which is going to directly use what the code task has written.
编写一个用户界面，它将直接使用代码任务编写的内容。

176
00:09:38,360 --> 00:09:43,440
So that's going to be very interesting to see how how it's able to keep that context so well that it's
因此，看看它如何能够很好地保持这种背景，这将是非常有趣的

177
00:09:43,480 --> 00:09:44,840
actually able to do this.
实际上能够做到这一点。

178
00:09:45,200 --> 00:09:51,680
And then cursor is correct that the last one is indeed called test task, but it's got a little bit
然后光标是正确的，最后一个确实称为测试任务，但它有一点

179
00:09:51,680 --> 00:09:53,680
more detail than cursor was suggesting.
比光标建议的更详细。

180
00:09:53,880 --> 00:09:58,560
Write unit tests for the given back end module and create a test in the same directory.
为给定的后端模块编写单元测试并在同一目录中创建测试。

181
00:09:58,880 --> 00:10:00,400
And this is.
这是。

182
00:10:00,440 --> 00:10:07,080
Got more information one more time about outputting raw Python without clever tags.
再次获得有关在没有巧妙标签的情况下输出原始 Python 的更多信息。

183
00:10:07,120 --> 00:10:09,640
And of course it also depends on the code task.
当然这也取决于代码任务。

184
00:10:09,680 --> 00:10:12,960
The unit tests are not going to test the user interface, it's going to test the code.
单元测试不会测试用户界面，而是测试代码。

185
00:10:13,200 --> 00:10:15,280
And that will be the output file.
这将是输出文件。

186
00:10:15,280 --> 00:10:20,800
And that is it for our tasks our 1 to 1 again between the task and the agent.
这就是我们任务和代理之间的 1 对 1 关系。