跟讀練習: What Does an AI Engineer Do Now? - Aparna Dhinakaran, Arize AI - 通過影片學習英語口語

選擇練習模式

每種模式都會開啟全屏練習室。

171 句

如果句子過短或過長，請點選 Edit 進行調整。

Awesome.

Well, welcome to AI Engineer.

I thought given we're at AI Engineer New York, we'd kind of revisit the question of what does an AI engineer do?

I feel like every year we have an idea of what an AI engineer does, and that definition kind of changes.

And as I was putting this talk together, it was super timely,

because Karpathy actually just tweeted something this weekend where he kind of talks about this growing gap between

basically folks at the frontier who are running thousands of agents and swarms of always -on on agents,

and he really kind of drops this funnel where six billion plus users have maybe touched or interfaced with an LLM.

One to two billion are maybe like casual free tier users.

20 million are professionals who have maybe started using it for more, taking some piece of work that would have taken weeks down to days.

But really, those at the Frontier Labs are, which is a super small percentage, it's like 5 ,000 users,

are the ones who are running thousands and thousands of agents at once.

And as I look at this, it really is, I mean, he's kind of dropped a bit of the funnel.

I mean, the first question anyone looks at this is that, where am I on this?

And, you know, he's kind of drawn out a bit of a roadmap of how does everyone get to, in the next couple of years,

one of those 5 ,000 users who are running thousands of agents.

And this has been happening, I'd say, for a couple of decades now, where the abstraction layer has gotten higher and higher.

I mean, definitely faster in the last couple of years, but we've gone from engineers writing higher -level abstraction languages to,

I mean, just copy -pasting code, using local agents, to using cloud agents,

to really the expectation now is how do all of us start running a team of agents?

or factories of agents internally and build toward that.

And what this has led to is essentially what is the then and now of what an AI engineer is.

And this is a bit, I think, of a roadmap for some,

but I think internally this is what we've already started to kind of push towards.

As an AI engineer, your job is no longer to just write the feature, write an AI feature.

It's about how do you build the loop to write that feature.

It's no longer about just reading the diff and actually doing code review.

It's actually how do you set up systems and agents to do the code reviews,

and how do you write evals to actually do the non -deterministic, to review those non -deterministic tasks.

It's actually no longer even about just setting up metrics and software kind of telemetry, but it's actually how do you have agents go through

and read the observability data and and have agents actually consume that telemetry to find patterns.

And so this loop that we've kind of been talking about, which is the build, the eval, ship, you monitor, you improve it,

well, the AI engineer is now actually responsible, not just for doing each of those steps,

but how do you build the loop that actually does each of those steps?

And at Arise, one of the things we've rolled out in our product,

and I'm gonna talk about a bit of what we've learned in building this, is we built

Signal to actually run this loop for AI engineers.

What Signal does is that

Signal actually looks at all of the traces, it reads the telemetry, it identifies patterns in that telemetry,

and it can actually put up a fix or a PR if it has access to the repo.

And Signal, Signal's an always -on agent.

So this is an example of how

Signal starts, but it actually starts off by just reading the traces.

Super simple example, but it goes through, reads, and all this is configurable,

but a certain volume of traces that came in in some cadence,

it reads it, and then the goal is to actually identify issues from that telemetry data.

It has to keep track of issues that it's previously seen.

So we have to consider the memory of did it see something before

that it thought was an issue? did something seem like an issue

but it wasn't actually captured

and now as it collects more data it actually thinks it's much more of a critical critical issue

and so signal actually starts off by reading the traces to identify problems

and so one of the first things that that we realized was

that the future of who's actually consuming telemetry data has really changed

It's no longer about humans consuming telemetry data.

It's not even about humans consuming it and agents kind of taking on the task,

but it really is how do you set up your telemetry data so that agents are the primary consumers of that data?

And what that does is that that observability data can become the trigger for actually running and triggering these always -on agents.

And so the first thing that if you're building a team of, of a factory of really always on agents is,

what triggers these agents to wake up or start?

And there can be a variety of triggers.

For signal, for us, it's configurable to run on an ongoing cadence.

So every three hours, six hours, go pull the last X amount of traces, read them, identify problems.

It can also be triggered by events.

So Slack messages, and some user complains about something.

It can be a metric -based trigger, but these are essentially triggers to kick up the agent actually starting.

Once the agent actually starts, we have to spend some time figuring out, well, what does an agent run actually look like?

For us, we actually pull in all of the context of the traces, any additional third -party data,

so we allow collecting to APM logs, APM metrics, but all of the third -party telemetry data that we want to pull in,

access to the repo, access to the actual,

the access to any keys that are needed to actually run this agent,

but all of this information is put inside of a sandbox, and this is actually what's started up every time the agent wakes up.

And so the agent's triggered, we build a sandbox, We put everything that we need inside of that sandbox.

There's a proxy.

The only way to get information in and out of the sandbox is by the single proxy.

And everything that happens inside of that sandbox is actually already getting traced.

And every output, so the issues that are generated and created are all getting saved to some kind of memory.

And so this happens every single time the agent actually runs.

Every time the agent finishes running, so it's sweep through all of the traces, it either found something or it didn't.

There's what actually stays and what actually gets thrown away.

What stays is that if it found any issues, all of the output is actually saved off in some kind of memory

so that the next time an agent gets spun up, it doesn't have to start from ground zero.

It has a history of what are the issues that it actually found.

The agents are traced.

So all of the telemetry data of what the agent called, you know, if it actually put up a PR,

all of those things are actually traced.

And any skills that it may have learned while actually doing a run can also get saved to the actual repo.

But the things that go away is the sandbox gets torn down.

Any credentials, you know, obviously get removed.

The repo access is removed and so all of the stuff

that doesn't need to be saved kind of gets torn down after the run of Signal. And we've designed

Signal in a way to actually keep this agent durable.

So that means that either if the sandbox fails or if the harness fails,

then it shouldn't have to start everything from scratch in the middle of the run.

It should actually just be able to pick up from the step

that it failed and all of the state

so -called is kind of saved off in kind of a memory outside of the sandbox.

And so we've designed this to actually be a very durable agent so that if it fails, it can spin it back up.

You can launch a new sandbox, launch a new harness to kind of pick back up where it started.

100

So all of this is essentially the underpinnings of how we built signal to run every single run.

101

Agent gets triggered, agent gets started, loaded with all the context, the evidence, it sweeps through the telemetry data, it either finds something or it doesn't,

102

all of that gets saved to memory.

103

If something fails in the middle, the agent can get reset up.

104

And we built

105

Signal to also be agnostic of the model or the harness.

106

So today, Signal supports not just cloud code, which is what we started with, but it also supports cursor and codecs,

107

and the goal is to actually support all of the major, even the open source harnesses out there.

108

And Signal actually also supports multiple, will support kind of multiple models.

109

So even if you're using cloud code, you can pick any of the models inside the anthropic family.

110

And this is really important to us because,

111

one, it's.. an awesome way for us to evaluate the quality of the agent every time we spin it up.

112

It helps us control costs so we can see as we use more powerful models the better quality maybe the PRs are,

113

but can we reduce the quality of the, can we reduce the cost and actually still maintain the rigor

114

and maintain the quality of issues that are actually detected by signal?

115

So this is something we deeply thought about from first principles when we were designing signal.

116

And this is actually a pretty good segue into what does an AI engineer need to do.

117

Well, an AI engineer really needs to kind of learn how to write evals.

118

And so we actually, every time signal runs, signal finds an issue, it puts up a PR.

119

Well, there's evals that are run on top of the agent to test that PR.

120

And an eval can be as simple as testing something as part of your development workflow, you have a data set,

121

you can be a simple prompt with outputs that you're testing to make sure that there's no regressions.

122

But these evals can also, they need to be kind of aligned with human judgment.

123

And I'd argue

124

that this is actually probably where an AI engineer should be

125

spending a lot of their time as they're building the system to actually run the loop.

126

They should be actually spending time looking at the traces with their agents, identifying what the common errors are.

127

And there's a lot of skills.

128

I think I was hearing

129

Lance yesterday talk about the Claude skill to build evals.

130

We have a skill with Arise Evaluator to actually help you build and write evals, as well as align those evals with the human judgment.

131

but this is probably where the shift to defining what is good becomes really, really important for an AI engineer to actually do.

132

And for a lot of teams I think we speak with and we work with, their question becomes, well, how do I trust the evaluator?

133

And do I really trust that the eval is going to catch

134

or how do I trust that it's as good as my judgment?

135

And I'd say what we spend a lot of our own time doing for our own products is

136

that we actually evaluate the evaluators.

137

We spend a decent amount of time on actually building these data sets, golden fruit data sets.

138

We run evals, verify them against the human output, and then try to align to make sure

139

that the judge actually agrees with the human and they're in agreement before we actually ship out a new evaluator.

140

And these evals can then be used both in an offline testing as well as in an online testing manner.

141

And this is probably what I would say as an AI engineer is more and more of what the job is becoming.

142

And so what I'm going to leave you guys with is as an AI engineer, you've built this agent.

143

You've built this agent to actually run, be always on you run evals before you actually ship it into production.

144

You can ship it, and then once it goes into production, the goal is to actually trace everything.

145

And tracing everything now means not just tracing the agents, but also tracing the coding agents behind the agents that built this.

146

So you can trace cloud code, you can trace cursor, you can trace codecs, but all these coding agents can be traced

147

so you can understand what happened in the factory of agents that you all are building.

148

And then these agents that all the traces can then also be evaluated online.

149

So there's an offline evaluation when you're actually testing what a new change is,

150

but as it goes into production these become your online evals that you're running on top of the telemetry data.

151

This for us ends up becoming the new data that then gets pulled back into the agents to read the telemetry data,

152

the evals, and surface up kind of problems inside of the traces.

153

So the system really becomes, how do you go from collect data, eval that data,

154

run agents on top of it so that you can find problems

155

and figure out where the gaps are to actually improve your systems?

156

So if I go back to kind of the question that we started this whole thing with, It's what does an AI engineer do?

157

I mean the gap between,

158

I think there's a pretty big gap between what's happening in the labs today and what's happening with a lot of businesses.

159

And some of it could just be the data inside of

160

businesses are a lot more messy than what is very constrained and testable inside of a lab.

161

But AI engineers are kind of the role to close that gap.

162

And I think it really starts with tracing everything, tracing the agents you're actually building.

163

running evals, being able to learn how to test these products that we're really building, and then how do you build a system so

164

that agents can actually improve from the telemetry that's actually being collected so that you're no longer just building individual features,

165

but you're actually building the system to improve your products.

166

If you want to learn more, come check out.

167

We have a booth.

168

You can check out

169

Signal, learn more.

170

But thank you so much for listening to us.

171

Thank you.

下載應用

流利口語所需的一切

AI 發音評分逐句打分

音標練習掌握每個音

詞彙學習建立你的詞庫

詞彙遊戲邊玩邊學

掃碼

Download on theApp Store Get it onGoogle Play

同頻道

The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory

Business EnglishUniversity StudentsWorking Adults

Anthropic's CCA Exam as a Field-Guide for Agentic Engineering — Frank Coyle, UC Berkeley

Business EnglishInterview EnglishUniversity Students

Why Software Factories Fail

Daily ConversationUniversity StudentsWorking Adults

How I deleted 95% of my agent skills and got better results — Nick Nisi, WorkOS

Business EnglishUniversity StudentsWorking Adults

Beyond Code Coverage: Functionality Testing with Playwright — Marlene Mhangami, Microsoft

Business EnglishUniversity StudentsWorking Adults

"Software Fundamentals Matter More Than Ever" — Matt Pocock

Business EnglishUniversity StudentsWorking Adults

Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic

Business EnglishUniversity StudentsWorking Adults

FOR YOU

本課的詞彙與口語要點

這節口語課以影片“What Does an AI Engineer Do Now? - Aparna Dhinakaran, Arize AI”為素材。影片中反覆出現的詞有：agent, signal, eval, engineer, telemetry。這段影片共有 171 個句子、2536 個單詞可供跟讀。講話部分時長為 15:12。說話人語速自然，每分鐘約 167 個詞，接近日常對話。 86% 的單詞屬於英語最常用的 3,000 詞，其餘的詞建議在練習前先學一下。

影片中的重點詞彙

影片中 15 個值得學習的單詞，附發音和釋義：

單詞	發音	釋義
trace 名詞	/tɹeɪs/	痕跡 /痕跡
trigger 名詞	/ˈtɹɪɡɚ/	扳機 /扳機
evaluate 動詞	/ɪˈvaljʊeɪt/	評價 /評價
loop 名詞	/luːp/	圈, 環 /環
evaluation 名詞	/ɪˌvæljuˈeɪʃn̩/	評價 /評價
cloud 名詞	/ˈklaʊ̯d/	йүн, 雲 /雲
output 名詞	/ˈaʊtpʊt/	輸出 /輸出
skill 名詞	/skɪl/	技巧, 技能
collect 動詞	/ˈkɑlɪkt/	庋藏, 收藏
consume 動詞	/kənˈsum/	耗費 /耗費, 消耗
essentially 副詞	/ɪˈsɛnʃəli/	本質上 /本質上, 基本上
spin 動詞	/spɪn/	轉動 /轉動, 自轉 /自轉
judgment 名詞	/ˈd͡ʒʌd͡ʒ.mənt/	判斷 /判斷
metric 形容詞	/ˈmɛt.ɹɪk/	公制
align 動詞	/əˈlaɪn/	對齊 /對齊

影片中出現的短語動詞

單詞	發音	釋義
check out 動詞		退房
figure out 動詞		弄清楚
go through 動詞		通過 /通過
wake up 動詞	/ˌweɪk ˈʌp/	醒, 醒來 /醒來
draw out 動詞		拖延, 延長 /延長
end up 動詞		到達
go away 動詞		離開 /離開, 走
throw away 動詞		棄置 /棄置, 扔

影片中的語法

說話人最常用的結構，並附上影片中的原話：

結構	影片中的用法
現在完成時 have/has + 過去分詞 — 過去發生但與現在仍有關聯的事	has gotten · we've gone · has led
被動語態 be + 過去分詞 — 強調發生了什麼，而不是誰做的	wasn't actually captured · be triggered · are needed
定語從句 who / which + 從句 — 補充說明人或事物	are, which is · ones who are · about, which is

需要注意的發音

說話人用了 34 次縮略和弱讀形式，例如 you're, we've, doesn't。請按聽到的簡短形式來說。

“th” 音: booth /buθ/, anthropic /ænˈθɹɒp.ɪk/
“sh” 和 “zh” 音: evaluation /ɪˌvæljuˈeɪʃn̩/, essentially /ɪˈsɛnʃəli/, capture /ˈkæp.(t)ʃɚ/, casual /ˈkæʒ(u)əl/, expectation /ˌɛk.spɛkˈteɪ.ʃən/
長單詞——注意重音位置: evaluation /ɪˌvæljuˈeɪʃn̩/, essentially /ɪˈsɛnʃəli/, internally /ɪnˈtɜːnəli/, expectation /ˌɛk.spɛkˈteɪ.ʃən/, telemetry /tɪˈlɛm.ɪ.tɹi/

中文母語者容易讀錯的音：

/v/ — 不要讀成 /w/，上齒輕觸下唇: evaluate /ɪˈvaljʊeɪt/, evaluation /ɪˌvæljuˈeɪʃn̩/, verify /ˈvɛɹɪfaɪ/, eval /ˈiː.væl/, revisit /ɹiːˈvɪzɪt/
詞尾子音 — 要讀清楚，後面不要加母音: trace /tɹeɪs/, evaluate /ɪˈvaljʊeɪt/, loop /luːp/, cloud /ˈklaʊ̯d/, output /ˈaʊtpʊt/
/r/ 和 /l/ 的區別: durable /ˈdʊɹəbəl/, principle /ˈpɹɪn.sɪ.pəl/, telemetry /tɪˈlɛm.ɪ.tɹi/, configurable /kənˈfɪ.ɡə.ɹə.bəl/, credential /kɹɪˈdɛnʃəl/

如何用這段影片練習

先完整聽一遍影片，不要開口，記下不認識的單詞。
先用 0.75 倍速逐句跟讀，熟練之後再回到正常速度。
錄下自己的聲音並與原聲對比，特別注意 trace, trigger, evaluate 這類單詞。

什麼是跟讀法？

跟讀法 (Shadowing) 是一種有科學依據的語言學習技巧，最初開發用於專業口譯員的培訓，並由多語言者Alexander Arguelles博士普及。這個方法簡單而強大：您在聽英語母語原聲的同時立即大聲重複——就像是一個延遲1-2秒緊跟說話者的影子。與被動聽力或語法練習不同，跟讀法強迫您的大腦和口腔肌肉同時處理並模模擬實的講話模式。研究表明它能顯著提高發音準確性，語調，節奏，連讀，聽力理解和口語流利度——使其成為雅思口語備考和真實英語交流最有效的方法之一。

影子跟讀法: 閱讀完整分步指南 →

跟讀練習: What Does an AI Engineer Do Now? - Aparna Dhinakaran, Arize AI - 通過影片學習英語口語

選擇練習模式

下載應用

同頻道

The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory

Anthropic's CCA Exam as a Field-Guide for Agentic Engineering — Frank Coyle, UC Berkeley

Why Software Factories Fail

How I deleted 95% of my agent skills and got better results — Nick Nisi, WorkOS

Beyond Code Coverage: Functionality Testing with Playwright — Marlene Mhangami, Microsoft

"Software Fundamentals Matter More Than Ever" — Matt Pocock

Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic

推薦影片

A Practical Guide To Becoming An AI Engineer (2026)

The Only SaaS Moats Left in 2026

Is AI Killing Human Fashion Design? Who Will Shape the Future of Design? Fashion Tea #6

Agentic AI Frameworks Explained: Workflows, Multi-Agent, & Production

How to Be More Articulate - Basics of Real Intelligence by Ansh Mehra

Inside the secret race to build artificial intelligence | The Gray Area

When AIs act emotional

Harnessing generative AI in architecture, engineering & construction

Why the Arab World never united

Alexandr Wang on what matters in an age of abundant intelligence

Jack Dorsey’s New Dessa AI Voice Sounds Scary Human

AI Governance Explained: Ethical, Transparent & Accountable AI for the Future

本課的詞彙與口語要點

影片中的重點詞彙

影片中出現的短語動詞

影片中的語法

需要注意的發音

如何用這段影片練習

什麼是跟讀法？