Shadowing Practice: AX is the only Experience that Matters - Ivan Burazin - Learn English Speaking with Video

בחר מצב תרגול

כל מצב פותח חדר תרגול במסך מלא.

327 משפטים

אם המשפטים קצרים או ארוכים מדי, לחץ על ערוך כדי להתאים אותם.

Welcome everyone.

So yes, a friend of mine said that we should talk about it in more extremities.

Obviously developer experience and whatnot still matters and humans do matter.

But we'll talk about why agent experience is probably the most important experience that you should focus on going forward. So basically,

the number of agents in the world as we progress will be the number of humans to the power of n.

And I say the power of n because we really don't know how many there will be,

but we do know that the speed at which people are creating software that are agents, and in each of these agents there are more agents,

is growing faster and faster and faster.

and it isn't hypothetical.

We don't have a lot of data, but I do have a little bit that I will share with you.

Namely, 25 % of YCs or Y Combinator, the most famous accelerator in the world, their last batch, not their current one,

we don't have the current data yet, 25 % of them, they said AI wrote 95 % of the code.

That part, put it there, not the most interesting.

To me, the most interesting part is is that 37 % were building autonomous agents.

So when you think of new SaaS offerings,

new startups, they are no longer deterministic web or mobile applications, they're actually agents.

And they are the new product.

And the most uncomfortable truth here is that most tools today break the moment you move a human from the loop.

So, if you have an agent that wants to go and do something, they're usually using human tools right now.

And so, we are entering a world where agents are not just assisting developers, because we're talking about developers here,

but they are the developers, right?

So, as my great MC said at the beginning, basically, if you're building DevTools or any tools for humans,

you essentially are building for the past.

And I say this again because the number of agents

that are coming online are going to be largely much more than humans.

So, what does it mean to build actually for the future?

It means building for agents.

And so before I get into why and how, I want to talk about what is an agent just so

that we have the underlining foundation and we're all on the same page.

When most people think about AI agents, they either think of something running on their machine like inside of Cursor or whatever,

or they think of OpenAI and Claude.

But as I mentioned earlier, more and more companies and products and services are actually agents.

So, you know, Cognition, Airtable became an agent, Lovable, Harvey, Manus, Cursor, the agent, they have the autonomous ones right now,

Decagon, which is a support engineer.

All of these services are AI agents, and essentially they spin up an AI agent for every single task that you as a human give them.

And how do we sort of define an agent?

So the way I look at it is it basically has three intersections, right?

You have the AI agent in the middle, which essentially is the piece of software, the mobile app, the web app, whatever it may be.

On one hand, you have the model.

I put LLM here, but it could be any model depending on what it's trying to achieve.

And that model gives it the intelligence.

And with that, it can sort of converse for you, with you, answer questions and whatnot.

On the second, it talks to the user, so it talks to you, the human.

You give it a prompt, a task, you ask it a question, it replies.

But the most important part, I think, for it to be able to get its job done is the tooling.

And so tooling can be anything outside of these two things.

Can it access your Google Drive?

Can you upload a file to it?

Can it use a browser?

Or can it actually use a computer?

In this case, we're talking about Daytona specifically.

So, an AI agent, when we talk about it, is something that runs on its own and intersects between a model, tools, and the user itself.

And so, going back to our question, what does it mean to build for the future?

Well, we need to focus on the agent experience or the agent's experience experience.

Matt Billman, who is the CEO and co -founder of Netlify, coined the term agent experience,

and it follows along the same idea of user experience and customer experience and developer experience.

The definition, I was looking for a definition for a while, and it wasn't actually Matt's, but it was his colleague Sean,

which I actually like the most of all the definitions of agent experience, and that is the following how easily agents can access,

understand, and operate within a digital environment to achieve user -defined goals. So think about that.

How easily can an agent get access to what it needs, how can it understand what it needs,

and how can it operate inside of that environment to achieve the goals that you, as a human, have set for it?

And I did a bit of research on some forward -thinking companies that are actually building out some agent experiences.

And before I get to that, I'm going to have a glass of water because my throat is really dry, so bear with me.

because I've been talking all day at this conference.

And so I have no affiliation with any of these companies, but I just like what they do.

So seamless authorization.

So that's a big problem.

If you have your agent and it has to go do something on your behalf, it'll probably have to log into your Gmail,

log into your booking .com, log into whatever.

It has to log in somewhere, right?

And so there's a company called Arcade.

I think their URL is arcade .dev.

And what they do is they're basically the authentication layer for agents.

So the agent doesn't actually get access to your credentials because you don't want your agent to have access to credentials.

But you can load your credentials in Arcade and then the agent can utilize that to access these services.

Moreover, if the agent doesn't have a login for whatever service, it will then basically roll back to you,

to the human, and say please log in through Arcade, again not giving the credentials to the agent, and then the agent can continue on, right?

Seamlessly continue their workflow.

Another great example, I mean a lot of people do this, but I picked on Stripe because Stripe does it very, very well.

It is agent readable documentation.

So some of the things that

Stripe does really well is if you take any URL from their docs, so docs .stripe .com slash whatever,

and you append a .md to that URL, it will render the markdown file.

No fluff, no UI, no graphics, no nothing.

All the stuff that gives an agent a headache and uses their context window, the agent can consume that much, much easier.

Or better yet, if you haven't done this in your documentation already, there's a standard called llms .txt.

And so llms .txt basically gives the agents one file for your entire documentation written in plain text

so the agent can easily read everything and comprehend what it needs.

My button doesn't work this far away, sorry.

And the third thing is API first designs.

I use the word API first, sometimes use the word machine native.

What we're talking about is, is there an interface where the agents can interact with your tool at a machine level, at an API level?

Like we don't want them to use a UI and whatnot.

And we can talk about MCP potentially, but MCP also sits on top of a API.

So just for the sake of this conversation I'll say

that everything that you your tool does should have an API

because it makes it much easier if your agent reads through your documentation

and sees there's an API endpoint it's super easy to do.

If it reads it through your documentation

100

that's a login to a dashboard to click a green button after step three much much much harder

101

and probably won't get it done. And so these

102

These are like three nice examples that I pulled out of people thinking about the agent's experience.

103

So, how do they log in?

104

How do they learn about the documentation?

105

And how do they access your tools?

106

But is there more?

107

Are there more things, right?

108

And so, what is interesting is I think there's something really missing from Sean's definition originally

109

and I'm going to go back to that.

110

And so I added the word autonomously because I think that adds a little more emphasis to what we're trying to achieve.

111

So how easily agents can autonomously access,

112

so without a human, autonomously understand and autonomously operate within these environments to get their goals.

113

Because it's a different scenario

114

if it has to fall back to you as a human to do something

115

or it can do it all on its own.

116

And I think that currently when we think about agent experience, even some of the things that we mentioned here,

117

helps agents do things faster, helps them get unstuck.

118

But it's not like full -on autonomy.

119

Still in a lot of places, everyone that is building these tools basically has to go back to the tool that they're building,

120

to the drawing board, and ask one question is what if there are no humans around to click any buttons, right?

121

To hit any keys, to debug errors, to type in a password.

122

Like that is fundamentally what we're trying to solve.

123

All of us here have made software for people and we've made it for us that interact through visual, a keyboard, a mouse and whatnot.

124

And so if we're not here, how do agents actually solve that?

125

And if you're not building...

126

from the ground up, I feel that all you're doing is porting human experiences

127

or developer experiences to the agent and not building out what the future is.

128

A little bit of background on me, just like why am I talking all this stuff around here, just to give a little bit more context.

129

So, I'm actually a bit old, so started companies in the early 2000s, building out data centers.

130

So, we were actually screwing up like racks and IBM servers and Dells and whatnot, installing VMware and hypervisor and all that stuff.

131

Second company was a company called Code Anywhere, the very first browser -based IDE in 2009.

132

So, I was talking to someone earlier, like Replit before Replit, Codespaces before Codespaces.

133

Sorry, GitHub people if you're in the crowd.

134

We did this in 2009.

135

We built everything from the IDE to the orchestration level to the isolation.

136

We had to build it all on our own because none of these things actually existed.

137

So what we learned in actually stacking servers, we sort of did it in a more virtual way, but for developers.

138

After that, at Infobip, led the developer experience.

139

Infobip, essentially a competitor to Twilio, which is a sponsor down here.

140

One API for SMS voice, email, WhatsApp, and all those things.

141

And lastly, Daytona.

142

Interestingly enough, a lot of the team members in Daytona have worked with me throughout these companies as well.

143

So it's like a really fun tight -knit group.

144

And now what we do is we build agent -native runtimes, right?

145

And my thing doesn't work again.

146

Agent -native runtimes, right?

147

So what are agent -native runtimes?

148

First, runtimes are sandboxes or computers.

149

So if an agent is equal to a digital human, what Daytona is, is a digital version of this MacBook right here.

150

What makes it specific is that it's, and this is going to sound really weird, it is serverless, long -running,

151

and stateful, which is kind of weird because that usually doesn't go with serverless.

152

And I'll talk about it in a bit why.

153

But basically, these things make it native for agents, giving the agents the ability to, you know, do what we do.

154

So if an agent has to like clone a GitHub repository, where does it do that?

155

It has to run the code.

156

Where does it do that?

157

If it has to do data analysis or visualization, if it has to use a computer or browser, where does it do that?

158

It needs a machine.

159

We actually have some agents playing video games, which is weird, but obviously they're trying to do that as well.

160

So we have like some people playing

161

Counter -Strike and teaching them how to do that on these runtimes.

162

And you have vibe coding tools built on us that VibeCode 3 -day games.

163

There is a lot of things.

164

There's very few things.

165

If I took everyone's laptop away today, how much work would you get done?

166

And if you think of an agent as digital human, they also need that same workload.

167

Slightly different, of course.

168

Fine -tuned for them because the talk is agent experience.

169

And so everything that we've learned around servers and working for developers and runtimes and IDEs, we've now put into Daytona,

170

but with the agent Swiss.

171

And so when we decided to build this, we had to think from first principles, what does a runtime look for an agent, right?

172

And so if your agent, obviously we all like speed.

173

Speed is really important to all of us.

174

You don't want to wait.

175

But spinning up your local dev environment or if it's running on EC2, it might take a minute or two minutes or 30 seconds,

176

depending on how long it takes to build.

177

But if your agent is, let's say you're talking to ChatGPT, and you have a coding task,

178

you don't want to wait a minute for it to spin up an environment.

179

It has to be really fast.

180

So we created these runtimes that spin up in 90 milliseconds with latency.

181

So that's including latency.

182

It's a sub -30 milliseconds plus the network, and it gets about to 90.

183

So that's pretty fast.

184

You all blink.

185

The time it takes you to blink is about 110 milliseconds, so faster than that.

186

Secondly, it has to be stateful and long running.

187

So, it spins up really fast, but it has to be a long running task.

188

Why does it have to be long running?

189

Well, it has to be long running because the agent is working on a task, and that task might last 15 minutes,

190

might last an hour, might last two hours, might last five hours.

191

You don't want it unlike serverless, which will die at some point in time depending on who you're using.

192

You don't want your agent to be coding and then it kills the laptop.

193

You want that to run for a very, very long time.

194

And so the third thing is, which is probably the most important, is these machine -native interfaces.

195

Again, we use keyboards, mouse, and screens, agents, ideally APIs, right?

196

And I'll give you some examples of some of these machine interfaces that we've actually built in there.

197

So the number one use case for these types of things still is coding.

198

And even if it's not a coding agent, the agent does use code to get a lot of things done.

199

So we built a bunch of tools inside, all of them headless.

200

And just to take a step back, obviously, we have machine interfaces or API endpoints for the states of the machine.

201

So the agent wants to turn on a machine, turn off a machine.

202

It wants more CPU, more RAM, more disk, whatever, all that.

203

But when it gets inside the machine, does it really want to parse the output of our human terminal?

204

So we have, for example, a headless terminal.

205

The agent has an endpoint, spin up a terminal, and then in a string just sends the command and gets the string back with the command.

206

It doesn't have to figure anything out.

207

We have a language server protocol.

208

So most of the things that you have inside of an IDE, you have a Git client,

209

so a full on Git client, and a file system.

210

So create a file, remove file, find in files, all these things.

211

All of these are headless tools that enable the agent to get the job done faster,

212

use less context window, use less tokens, and get a higher quality outcome.

213

But, and I have to keep walking back here, sorry.

214

I have to stay on this side of this stage.

215

But all these things that I mentioned are basically things that have existed.

216

So you've had like serverless things that are really fast with APIs.

217

You've had logging and running machines, although probably like an EC2 or something like that, so not the same.

218

And we've had all these tools and we just added APIs on them, which is great.

219

All of this together is a new thing, but what are some of the new primitives that we, talking to customers and users,

220

building agents, had to build so the agent can autonomously do their jobs?

221

And so one of the first examples was Daytona uses Docker as the default image for the runtime.

222

So any Docker image that exists, it spins that up.

223

The agent can pick that one, spin it up, and go.

224

You can even connect your own container registry, and it can pick one, and it's fine.

225

Obviously, if the agent spins up one of those and needs a new dependency, it can use the terminal,

226

install that one dependency, you're good to go.

227

But if the agent has to install 20 dependencies or 30 for multiple machines, that doesn't make sense.

228

And the way that you would solve that usually is that a human would then create a new Docker image.

229

It would publish that, and then the agent could use that one.

230

But that calls for a human.

231

And so what we want is the agent to do it end to end.

232

And so we essentially created a declarative image builder.

233

So now what the agent can do, and the agent can say, oh, like all these Docker images are like cool, but not what I need.

234

I need a brand new one.

235

And so basically through the API can say I need a new one and just list items.

236

These are the dependencies I want.

237

These are my environment variables.

238

These are the commands that must execute.

239

They don't build that on the fly, spins up the machine right after that,

240

and that image is now a template and it can use it from here on in.

241

So, a simple, like a little thing, but one more step where a human does not need to get into the loop.

242

The second thing is you all use Docker.

243

Docker is a great product.

244

It's down there.

245

And if you're working on your laptop and you have multiple containers and you have large data,

246

you can share a drive or the files across them.

247

It's actually called Docker Volumes.

248

We didn't call it Daytona Volumes.

249

We didn't think about it, but it ended up being quite similar and quite nice.

250

Essentially, Docker Volumes enables you to share a file on your laptop and it works across all your containers.

251

But if these agent runtimes are all isolated on their own, there's no sharing across any of this.

252

yet you still have agents that have 100 gigabyte data sets.

253

Literally a user, he says, I have 100 gigabytes that I need to use the same across multiple machines, but they're different run times,

254

so I can't just snapshot it.

255

I need to actually upload it 50 times or 100 times, which takes a lot of time, it's very expensive, not the way to do it.

256

So we built Daytona volumes.

257

The agent can say, oh, I need a new volume, it invokes it, essentially an S3 -esque type thing and then the agent can upload

258

that once and attach it as a network drive to one or multiple sandboxes, all on its own.

259

It can delete it after, it can use it after, it can do whatever it wants.

260

The agent can solve its own problem and make the job easier.

261

The last thing is parallel execution.

262

As a human, I think that most people here work on one laptop at one time or one time at one time.

263

Maybe if you're really dialed in on some stuff, you can maybe do one too.

264

But essentially, you are working on a problem, trying to solve it.

265

If it doesn't work, you go back and do it again and do it again and do it again.

266

An agent can work like that, but an agent can also do it in multiple, right?

267

So an agent can essentially say, at this point in time, I want to try five different things.

268

There's five ways to solve this problem.

269

And so Daytona basically, or these runtimes, enable the agent to fork the machine itself.

270

Five times, 10 times, 50 times, 100 ,000 times, and try them all in parallel, all of them.

271

And if they're all garbage, it can delete them and go back.

272

If two of them, let's say number two and number seven are good, it can take those two,

273

kill those, and it can actually fork from there again.

274

So you get a bit of like this

275

Marvel multiverse of things that the agent can try out, right?

276

So it can do it all, all in parallel end to end.

277

This is something that we as humans actually have no use for.

278

We can't do that.

279

Yet agents can and should use these types of things.

280

Now, all these things that I've talked about today might not sound revolutionary,

281

but the idea is to hopefully get you to think about how agents use the tools that you're building.

282

That's what I'm trying to inspire you to get to.

283

If you ask me what else is there, the hell if I know, I don't know what's out there.

284

That's the honest answer and that is actually the point.

285

The way you figure things out is you stay close to people building these agents,

286

using your tools, and get a short feedback loop to figure out where it breaks.

287

At what point is the agent not able to use your tool end -to -end?

288

And so, how can you create it so that your agent actually never phones home?

289

Sort of like if I'm watching ET, I'm old, yeah, ET phones home.

290

Like, make sure that ET doesn't phone home.

291

And so if you haven't tried that, if you haven't solved that, you're actually not building for agents, I would argue.

292

You're just taking developer experience and you're porting that over with an API endpoint.

293

And so we started this whole talk with this bold claim, agent experience is the only experience that matters.

294

And I have to say it's not because we all are disappearing, hopefully.

295

Humans are not there.

296

But just that agents will outnumber us as humans and will they become the primary user.

297

Most of them will be using that.

298

And less and less will there be a human behind the screen, you know, reading the logs, clicking the buttons, typing into terminals.

299

And just to leave you all with how we built these things, to accommodate the things that we did really shortly, we had to rethink everything.

300

And as I mentioned, everything from the CLI to the control plane, to the infrastructure, to the orchestration, everything down to the bare metal machine,

301

Daytona has now built out a cloud on bare metal servers, not on AWS, not on GCP,

302

not anywhere else, because there was no other serverless, long -running, staple technology out there that we had to build it for ourselves.

303

And we launched the product actually just two months ago, and I'm actually going to share some stats with you just

304

to show you why agent experience is important also from a business perspective.

305

So we launched it two months ago, two months and two weeks maybe ago number of people signing up to use this,

306

these are actual numbers, 13 ,000, number of people that created an API key from those, this is our entire funnel,

307

number of them that created a sandbox for a runtime, about 5 ,000, and 1 ,500 actually swiped their credit card already to use this.

308

And because of these swipes of credit cards, in two months, Daytona has got to a million run rate,

309

which makes it the fastest growing infrastructure company of all time.

310

And I understand million is not the the biggest number yet

311

and hopefully we'll be there still at 10 and 100 the fastest.

312

But the point what I'm trying to show you is that infrastructure companies, and so here you have like

313

Scale, Stripe, Vercel, Auth0, Twilio, Cloudfair, they usually take about 12 months to get there because you're not selling to a consumer,

314

you're selling to someone building a product that has to decide to use you, build their product, integrate you,

315

then market, launch the product, market the product, get users, and then that rolls back all the way to you.

316

And why this is important is not that they don't have got to a million.

317

You guys don't give a shit that we got to a million, which is fine, which is great.

318

But what I'm trying to say is that the pull from the market, the number of people building tools,

319

building agents, and need tools for these agents, it's insane.

320

Like nothing of this magnitude has ever existed before.

321

And And hopefully that inspires you, if you're building tools for humans, to think about agents as well as your user in your product.

322

So with that, I just want to leave you with one thing,

323

hopefully, one thought, is like if agents can't use your product in the future, probably nobody will.

324

And so if you want to, that was like the clickbait slide at the end.

325

And so if you want to learn more, we have this little booth in Hall 2 .2.

326

The booth number is 225 slash 4, so it's really small somewhere by the stage.

327

So thank you so much.

הורד אפליקציה

כל מה שאתה צריך כדי לדבר בשטף

הגיית AIציון לכל משפט

תרגול IPAשלוט בכל צליל

אוצר מיליםבנה את מאגר המילים שלך

משחק אוצר מיליםלמד תוך כדי משחק

סרוק QR

Download on theApp Store Get it onGoogle Play

אותו ערוץ

How AI Empowers Tech Leaders Siwei Shen

Daily ConversationUniversity StudentsWorking Adults

FOR YOU

המלץ על סרטון

20 משפטים

Alexandr Wang on what matters in an age of abundant intelligence

Daily ConversationUniversity StudentsWorking Adults

207 משפטים

Your AI Agent Starts Every Session Like a New Hire - Killian Carlsen-Phelan, Sonar

Daily ConversationUniversity StudentsWorking Adults

358 משפטים

אוצר מילים והערות הגייה לשיעור הזה

שיעור הדיבור הזה מבוסס על הסרטון “AX is the only Experience that Matters - Ivan Burazin”. המילים שחוזרות הכי הרבה: agent, experience, tool. בסרטון הזה יש 327 משפטים ו-4429 מילים לתרגול Shadowing. הדיבור נמשך 25:06. הדובר מדבר בקצב טבעי של כ-176 מילים בדקה, קרוב לשיחה יומיומית. 85% מהמילים נמצאות בין 3,000 המילים הנפוצות ביותר באנגלית; כדאי ללמוד את השאר לפני שמתחילים.

אוצר מילים מרכזי בסרטון הזה

15 מילים מהסרטון שכדאי ללמוד, עם ההגייה והמשמעות שלהן:

מילה	הגייה	משמעות
spin פועל	/spɪn/	הסתובב
developer שם עצם	/dɪˈvɛləpɚ/	מְפַתֵּחַ
solve פועל	/sɒlv/	פָּתַר
server שם עצם	/ˈsɝvɚ/	שָׁרָת
terminal שם עצם	/ˈtɚmɪnəl/	בֵּית נְתִיבוֹת, טֶרְמִינָל
laptop שם עצם	/ˈlæp.tɑp/	מחשב נייד, מַחְשֵׁב נַיָּד
stripe שם עצם	/stɹaɪp/	פַּס
interface שם עצם	/ˈɪn(t)ɚˌfeɪs/	מִמְשָׁק
infrastructure שם עצם	/ˈɪnfɹəˌstɹʌkt͡ʃə/	תַּשְׁתִּית
parallel שם תואר	/ˈpæ.ɹəˌlɛl/	מקביל
install פועל	/ɪnˈstɔl/	התקין
container שם עצם	/kənˈteɪ.nəɹ/	מיכל
string שם עצם	/stɹɪŋ/	מֵיתָר
log שם עצם	/lɔɡ/	בּוּל עֵץ
mouse שם עצם	/maʊs/	עַכְבָּר

Phrasal verbs שתשמעו

מילה	משמעות
figure out פועל	הֵבִין, מצא תשובה
turn off פועל	כיבה, כִּבָּה

משפטים שכדאי לחזור עליהם

משפטים קצרים ושלמים מהסרטון שאפשר להשתמש בהם בשיחה יומיומית:

Can you upload a file to it?
My button doesn't work this far away, sorry.
You don't want to wait.

דקדוק בסרטון הזה

המבנים שהדובר משתמש בהם הכי הרבה, עם המילים המדויקות מהסרטון:

מבנה	בסרטון
הווה מושלם (Present perfect) have/has + past participle — פעולה שקרתה בעבר ועדיין יש לה חשיבות או השפעה עכשיו	have set · haven't done · have made
משפטי זיקה (Relative clauses) who / which + clause — מידע נוסף על אדם או דבר	Decagon, which is · everyone that is · Twilio, which is

הגייה ששווה לשים לב אליה

הדובר משתמש ב-87 קיצורים וצורות מקוצרות, כמו you're, don't, doesn't. אמרו אותם בצורה הקצרה, כפי שאתם שומעים אותם.

הצלילים של “th”: booth /buθ/, throat /ˈθɹoʊt/, authorization /ˌɔːθəɹaɪˈzeɪʃən/, hypothetical /ˌhaɪpəˈθɛtɪkəl/, authentication /ɔːˌθɛntɪˈkeɪʃn̩/
הצלילים של “sh” ו-“zh”: essentially /ɪˈsɛnʃəli/, documentation /ˌdɑkjəmɛnˈteɪʃən/, shortly /ˈʃɔɹtli/, potentially /pəˈtɛnʃ(ə)li/, execution /ˌɛk.sɪˈkjuː.ʃən/
מילים ארוכות — שימו לב להטעמה: developer /dɪˈvɛləpɚ/, essentially /ɪˈsɛnʃəli/, documentation /ˌdɑkjəmɛnˈteɪʃən/, dependency /dɪˈpɛndənsi/, infrastructure /ˈɪnfɹəˌstɹʌkt͡ʃə/

צלילים שדוברי עברית מתקשים בהם:

/w/ — שפתיים מעוגלות, לא /v/: password /ˈpæs.wɜɹd/, whatnot /ˈwʌt.nɑt/
/æ/ — פתוח יותר מה-“אֶ” העברית, לא כמו “a” ב-“cup”: laptop /ˈlæp.tɑp/, parallel /ˈpæ.ɹəˌlɛl/, interact /ɪn.təˈɹækt/, behalf /bɪˈhæf/, feedback /ˈfiːdˌbæk/
/r/ — הלשון לא נוגעת בשום מקום, לא ה-“ר” הגרונית: stripe /stɹaɪp/, arcade /ɑɹˈkeɪd/, infrastructure /ˈɪnfɹəˌstɹʌkt͡ʃə/, parallel /ˈpæ.ɹəˌlɛl/, container /kənˈteɪ.nəɹ/

איך לתרגל עם הסרטון הזה

הקשיבו לכל הסרטון פעם אחת בלי לדבר, ורשמו את המילים שאתם לא מכירים.
התחילו במהירות 0.75×, תרגלו Shadowing משפט אחר משפט, וחזרו למהירות רגילה כשזה מרגיש קל.
הקליטו את עצמכם והשוו למקור, תוך תשומת לב למילים כמו spin, developer, solve.

מהי טכניקת השאדואינג?

שאדואינג היא טכניקת למידת שפה מבוססת מדע שפותחה במקור להכשרת מתורגמנים מקצועיים ופופולרית על ידי הפוליגלוט ד"ר אלכסנדר ארגואלס. השיטה פשוטה אך עוצמתית: אתה מקשיב לאודיו באנגלית ילידית וחוזר עליו בקול רם מיד — כמו צל העוקב אחרי הדובר עם עיכוב של 1–2 שניות בלבד. בניגוד להאזנה פסיבית או תרגילי דקדוק, שאדואינג מכריח את המוח והשרירים בפה לעבד ולשחזר דפוסי דיבור אמיתיים בו זמנית. מחקרים מראים שזה משפר משמעותית את דיוק ההגייה, האינטונציה, הקצב, הדיבור המחובר, הבנת השמיעה ושטף הדיבור — מה שהופך אותו לאחת השיטות היעילות ביותר להכנה לIELTS Speaking ולתקשורת באנגלית בעולם האמיתי.

טכניקת Shadowing: קרא את המדריך המלא שלב אחר שלב →

Shadowing Practice: AX is the only Experience that Matters - Ivan Burazin - Learn English Speaking with Video

בחר מצב תרגול

הורד אפליקציה

How AI Empowers Tech Leaders Siwei Shen

Alexandr Wang on what matters in an age of abundant intelligence

Your AI Agent Starts Every Session Like a New Hire - Killian Carlsen-Phelan, Sonar

It’s not just you

Be Better than AI: 8 Highest Value Skills to Learn Now

"Dive Deep" Leadership Principle Explained by Amazon CEO Andy Jassy

The Only SaaS Moats Left in 2026

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

How I'd Learn n8n if I had to Start Over in 2026

Harvard AI Professor: The People Most at Risk From AI Aren’t Who You Think

You Will Only Like Half of This Video

What Does an AI Engineer Do Now? - Aparna Dhinakaran, Arize AI

אוצר מילים והערות הגייה לשיעור הזה

אוצר מילים מרכזי בסרטון הזה

Phrasal verbs שתשמעו

משפטים שכדאי לחזור עליהם

דקדוק בסרטון הזה

הגייה ששווה לשים לב אליה

איך לתרגל עם הסרטון הזה

מהי טכניקת השאדואינג?