The Tessl Agent: Build Your Software Factory on Autopilot

1 - > SPEAKER_03: But ultimately, your goal should be that agents are 2 - > doing a lot of this work in the background. 3 - > And so the Tesla agent is built to sort of almost get you to 4 - > stop using it, right? 5 - > So you work with it, and at the end it'll sort of say, hey, I 6 - > could set some of these up as recurring actions, I could 7 - > create a CI CD check for this. 8 - > So in that regard, you might see that the Tesla agent is actually 9 - > pushing you a little bit more towards this idea of loop 10 - > engineering and automating its own work in addition to your 11 - > coding agent work.

12 - > And at some point you might say, like, wow, 40-50% of our PRs 13 - > don't even have a human looking at it. 14 - > We never had to do a big initiative to make that happen. 15 - > We got started, we focused on doing what we were doing, and 16 - > over time it could just delegate more to the agent. 17 - > SPEAKER_02: The AI Native Dev is a podcast with developers and 18 - > engineering leads at the cutting edge of AI and agentic coding.

19 - > Join your hosts, Guy Fajani, and meet Simon Maple every week as 20 - > we chat with the most exciting voices in AI and tackle the 21 - > biggest questions we're facing developers today. 22 - > This is the AI Native Dev. 23 - > We just wrapped up two amazing days at AI DevCon in London. 24 - > SPEAKER_00: But the great thing is that we get to do it all over 25 - > again in New York City this November.

26 - > SPEAKER_02: You're absolutely right. 27 - > We're gonna be back in the city that never sleeps on November 28 - > 3rd and 4th for more amazing sessions, really engaging, 29 - > hands-on workshops, and much more. 30 - > SPEAKER_00: Yep, all that great networking, partying, eating and 31 - > drinking that you've come to expect from AIDEVCON. 32 - > We think we have one of the best hallway tracks in the business, 33 - > and it's the perfect compliment to our incredible speakers and 34 - > presenters.

35 - > SPEAKER_02: We'll both be in person and virtual with 36 - > live-streamed access to all mainstage keynotes and talks. 37 - > SPEAKER_00: Sign up right now for our Super Blind Bird ticket 38 - > for just$100, only available for a limited time. 39 - > SPEAKER_02: We're really excited to be headed back to the Big 40 - > Apple. 41 - > We hope to see you all there.

42 - > SPEAKER_01: Hello everyone, welcome back to the AI Native 43 - > Dev. 44 - > Today I am excited to announce that we're launching a new 45 - > product from TESL, the TESL agent. 46 - > We're gonna spend a good portion of this podcast talking about 47 - > what this agent is and what it is, but don't worry, we're not 48 - > just gonna sort of talk about our products over here. 49 - > We'll also talk about loop engineering and what that is and 50 - > why we think you know it's a thing that you should know about 51 - > as well.

52 - > Uh we'll talk about the the importance of ease of use and UX 53 - > in DevTools, even in the AI era, uh, and maybe some learnings 54 - > from a company perspective about building a product in this era. 55 - > Um so to do all of that, we have Drew, our head of product here 56 - > from TESL. 57 - > Thanks for joining us here, Andrew. 58 - > SPEAKER_03: Glad to be here.

59 - > Finally, my MOI onto the podcast. 60 - > It's been only a year and a half. 61 - > SPEAKER_01: Well, you know, don't take it personally. 62 - > SPEAKER_03: See how long it is till the next one.

63 - > SPEAKER_01: We'll see. 64 - > We're uh we're inspecting. 65 - > SPEAKER_03: Yeah, yeah, yeah. 66 - > SPEAKER_01: Performance review.

67 - > So Drew, uh tell us a little bit about what this Tesla agent is 68 - > and you know, what is it that we've just launched? 69 - > SPEAKER_03: Yeah. 70 - > So there's sort of two pieces to it. 71 - > First is that the Tesla agent is a new agentic interface to all 72 - > of Tesla's tools.

73 - > So everything Tesla does today, helping you scale skills, make 74 - > them sort of work organization-wide. 75 - > Tesla agent is just going to help you set that up, put it 76 - > together in more flexible, intelligent workflows, sort of 77 - > connecting the tools. 78 - > The second, the Tesla agent is sort of a first step towards a 79 - > broader vision of loop engineering or factory building. 80 - > So the idea is that the Tesla agent is a factory-building 81 - > agent.

82 - > So it helps you go from scaling skills across your org to 83 - > building your software factory piece by piece, setting up these 84 - > loops that will talk about how you engineer them to make agents 85 - > more effective over time. 86 - > SPEAKER_01: Aaron Powell Very cool. 87 - > And this is um I guess you know you'd still run it with sort of 88 - > the Tesla agent command in the terminal. 89 - > It sort of has a little bit of a kind of you know clawed codex, 90 - > you know, sort of similar to uh feel for it.

91 - > But you know, while you can ask it to write code, we don't 92 - > recommend you do, right? 93 - > Like it is focused on sort of, I guess. 94 - > SPEAKER_03: Pinning agents down these days is always so hard 95 - > because at the end of the day, you know, you can ask the Tesla 96 - > agent to write a poem for you, and it will, but I wouldn't 97 - > recommend it. 98 - > It's certainly not built for that.

99 - > SPEAKER_01: It's not part of our evaluation. 100 - > SPEAKER_03: No, it's not part of our evals. 101 - > So ultimately, though, yeah, using the Tesla agent will feel 102 - > quite familiar. 103 - > It's uh terminal-based CLI agent.

104 - > Uh you work with it just feels like clawed code in that sense, 105 - > right? 106 - > Like you just type some commands, it'll pick the right 107 - > skills and actions to take uh on top of that. 108 - > But in addition to that, we've also designed the Tesla agent to 109 - > be very automation friendly. 110 - > So, you know, as we'll get into with the idea of loop 111 - > engineering, with much of the work that you put into making 112 - > agents successful and building up a software factory, you kind 113 - > of want to get out of these interactive sessions, right?

114 - > Those are sort of a transitionary period where you 115 - > are figuring out what works, figuring out where you can 116 - > delegate tasks and sort of what are the workflows you want. 117 - > But ultimately your goal should be that agents are doing a lot 118 - > of this work in the background. 119 - > And so the Tesla agent is built to sort of almost get you to 120 - > stop using it, right? 121 - > So you you work with it, and at the end it'll sort of say, hey, 122 - > I could set some of these up as recurring actions, I could 123 - > create a CI CD check for this.

124 - > Um in that regard, you might see that the Tesla agent is actually 125 - > pushing you a little bit more towards this idea of loop 126 - > engineering and automating its own work in addition to your 127 - > coding agent work. 128 - > SPEAKER_01: Right. 129 - > Okay, so we're gonna dig a lot uh into that and we talk about 130 - > sort of factory building, factory manager. 131 - > Let's start though, just from a concrete use case.

132 - > So, you know, I picked up the agent. 133 - > You know, what are some examples of things you can do? 134 - > Maybe walk us through a bit of a storyline here. 135 - > SPEAKER_03: Yeah, yeah.

136 - > I'll give a couple just of how it works. 137 - > So probably the one I'm most excited about that we uh are 138 - > using a lot here at TESL is using a TESIL agent to set up 139 - > your agentic code review harness. 140 - > So maybe what I'll do is quickly walk through how you can use the 141 - > TESIL agent to create an agentic code review, uh, agree with your 142 - > team on a risk policy for when humans need to review it, uh, 143 - > and then ultimately set up a recurring loop that will 144 - > optimize that code review over time so that you can just spend 145 - > time reviewing code, shipping features, and know that 146 - > everything's gonna get better as you go.

147 - > And so there's a few components of this that I think are pretty 148 - > illustrative of uh how the Tesla agent works. 149 - > So the first, you'd come in and just type something like setup 150 - > agent at code review, or I want to spend less time reviewing 151 - > code. 152 - > Uh and the Tesla agent is gonna start by reviewing and creating 153 - > evidence-backed findings. 154 - > So the Tesla agent is trained or instructed to look through all 155 - > of your PRs, look through all of your issues in your issue 156 - > tracker, uh, and then also to look through coding agent 157 - > session logs that it has access to.

158 - > Those can be either local, or if you've been using Tesla for a 159 - > while and you've been sort of uploading those logs, we can 160 - > look through those. 161 - > Yep. 162 - > SPEAKER_01: We'll try to find latent knowledge that already 163 - > exists in your code. 164 - > SPEAKER_03: Exactly, exactly.

165 - > So it's the kinds of information that you might want to review 166 - > against. 167 - > So it's looking for things like what is your style guide, what 168 - > are common failure cases that agents might have, what are 169 - > comments that your team seems to provide frequently in code 170 - > review. 171 - > And then once it's gathered all this information, uh first it 172 - > will tell you what it's found. 173 - > That information is uh, as is often the case, what's useful 174 - > for agents is also useful for humans.

175 - > Yeah. 176 - > So writing that down, it gives you a chance to correct anything 177 - > that may be uh off base there. 178 - > And then what it will do is it will walk you through a few 179 - > concrete components. 180 - > So the first is that it will set up a general skill-based agentic 181 - > PR code review.

182 - > And skill-based here is kind of interesting because it's uh 183 - > unlike a lot of tools that are just sort of one click, you put 184 - > it in production, you forget about it. 185 - > One of the core principles of TESL agent and of TESL generally 186 - > is that we think people are going to want to own and build 187 - > their own factories, right? 188 - > That this is the kind of thing that will be part of your 189 - > software engineering discipline, not something you buy off the 190 - > rack and just take as given.

191 - > And so for code review, we give you, uh we'll help create a 192 - > skill that we think maps to your code review best practices. 193 - > But it's a skill that you own. 194 - > So you can update it, you can augment it, you can share it 195 - > with other people, put it in other parts of your workflow. 196 - > So we'll set that up, and that kind of immediately gets you 197 - > going.

198 - > Now every PR that goes up, uh, you'll get a gentic review. 199 - > So once it's created that skill, the next thing that it will do 200 - > is set up an actual automated flow so that when a PR goes up, 201 - > uh an agent with that skill will be run. 202 - > Uh so there's a few things that we, the Tesla agent and Tesla, 203 - > can help you with there, which is we provide basic primitives 204 - > for running an agent through CI, for having it leave inline 205 - > comments on a GitHub flow, just the sort of niceties that every 206 - > team ends up building to get a flow that actually works for 207 - > them.

208 - > But TESL is built to be modular by design. 209 - > So if there's things you already have or things you already like, 210 - > the Tesla agent is fine working with those as well. 211 - > As part of setup, it will try to learn your preferences. 212 - > Right.

213 - > And we have defaults that we think are great, but it works 214 - > with whatever you you want to bring in. 215 - > SPEAKER_01: Yeah. 216 - > So this already, like at this point, you've already used the 217 - > Tesla agent to figure out what it should have in a review 218 - > process to create a unit, a skill, a plugin to be able to uh 219 - > to execute that code review. 220 - > And it it is it kind of specializes a little bit in all 221 - > these like repo automations or whatever other tools.

222 - > Yeah. 223 - > So let's say, for example, here it created a kind of a GitHub 224 - > action to run that for you, or it uses our app, and we have a 225 - > little app to sort of help you as I pointed out. 226 - > So you're already just like with a relatively simple command set 227 - > up automated code review right now that is based on your 228 - > historical learnings. 229 - > SPEAKER_03: Yes, yeah.

230 - > And if you're using the Tesla default primitives, you will get 231 - > a lot of nice things out of the box. 232 - > So uh one will have helped you create that code review skill. 233 - > We have a cloud sandbox that you can run the review from, uh, 234 - > which will have log observability, so you can go in 235 - > and look at the coding agent logs as it ran. 236 - > Uh it's also agent and model agnostic, so you can switch 237 - > easily between any number of coding agents like Codex, Cloud 238 - > Code, Gemini, et cetera, uh, without having to configure all 239 - > of them.

240 - > You just log into TESIL and then set which agent you'd like it to 241 - > use. 242 - > Includes open models and open agents as well, which is great 243 - > for sort of minimizing costs, which is a big one for code 244 - > review because it's running all the time. 245 - > It's an area that's really valuable to optimize. 246 - > SPEAKER_01: Aaron Powell That's probably a point uh worth 247 - > emphasizing, which is the actual review in this setup isn't 248 - > happening with uh TESEL uh itself or with a Tesla agent.

249 - > As we said, that is not a coding agent. 250 - > Yeah. 251 - > It is running your agent of choice and sets you up so you 252 - > can actually swap that agent of choice over time. 253 - > Yeah.

254 - > And we'll talk a little bit more about how e-vales can help you 255 - > guide to pick the right ones. 256 - > SPEAKER_03: Exactly, exactly. 257 - > So we help you get it set up. 258 - > So a lot of what Tesla agent does is actually just helping 259 - > you orchestrate other coding agents.

260 - > So sometimes the Tesla agent orchestrates itself, which is 261 - > always getting a little bit meta. 262 - > Um, but once you have that uh generic code review set up, the 263 - > next thing that the Tesla agent will help you do is set up a PR 264 - > review sort of human gate. 265 - > And what this means is that we found a lot of companies when 266 - > they adopt uh agentic code review, the next question they 267 - > have is when do I have to review it now versus when can the agent 268 - > review it?

269 - > Uh and they would like to, for simple PRs, for ones that they 270 - > have deemed to be not risky, be able to just let a good agentic 271 - > review handle it, and then they can sort of focus on the more 272 - > complicated or riskier PRs with their human review time. 273 - > This is a common practice. 274 - > Uh basically what we found most teams get to is you want to 275 - > agree on some sort of policy across your organization with 276 - > your security team, with privacy team, anyone who might uh who 277 - > might be involved.

278 - > And then you want to set up an analysis of every PR to decide 279 - > based on this policy, does it need a human or does it not? 280 - > Right. 281 - > And so the TESL gives you uh, we call it the change risk 282 - > verifier. 283 - > You can configure it with your own policy, but it also comes 284 - > with a relatively uh straightforward one out of the 285 - > box that you can tune between either more permissive if you'd 286 - > like to do as much as possible through a genetic code review or 287 - > more strict.

288 - > So you can say, I still want humans to review most of the 289 - > PRs. 290 - > So it'll again help you set that up as an action that will just 291 - > run within your CI CD pipeline. 292 - > Uh and then the last thing that we'll do is we'll go through all 293 - > of your existing skills and context in your repository, and 294 - > we will create what we call verifiers out of those. 295 - > So you can think of these as very small, targeted, and fast 296 - > LLM linting rules that look at a change, look at the sort of code 297 - > that's coming into your code base, specifically against 298 - > different aspects that you've codified in your skills.

299 - > So let's say that you have a uh design guidelines that says how 300 - > uh accessibility traits should be handled on new elements. 301 - > There will be a verifier that we can create for that that looks 302 - > at specifically files that touch front end and looks just for do 303 - > they apply those ARIA properties correctly. 304 - > And if you stack a bunch of those up and keep them very 305 - > focused, you can keep them small, fast, cheap, and you 306 - > basically run them like linting against every change that comes 307 - > in.

308 - > Catches a lot of the mistakes where agents just don't adhere 309 - > to what you've codified in your skills. 310 - > SPEAKER_01: Yeah, I love that. 311 - > So we've now kind of without command set up three different 312 - > types of reviews. 313 - > You review uh the code itself, I guess, that you're sort of 314 - > invoking a coding agent for.

315 - > You're reviewing the risk of the change so you can make some 316 - > smarter decisions about whether you merge them or auto-merge or 317 - > like a little bit of a flag uh for people. 318 - > So you kind of codify your policy. 319 - > Uh and then you know we introduce this verifiers theory, 320 - > which probably kind of you know is worthy of a podcast episode 321 - > on its own. 322 - > But really what that does is it reviews whether the agent has 323 - > adhered to the uh context that you've given it.

324 - > Like the sort of the skills, the attempts you've already made 325 - > within the repo to sort of define how it should behave. 326 - > It checks whether it adheres to those. 327 - > SPEAKER_03: The verifiers, in my opinion, are the thing that 328 - > really closes the loop between skills and plugins and like the 329 - > sort of instructions, the control plane you have over 330 - > agents to the actual code that is generated. 331 - > So it's a way of saying, I told an agent to do these things, but 332 - > did it actually do them in a way that is fast and scalable and 333 - > doesn't require uh a million tokens every time you wanna you 334 - > wanna ask that question.

335 - > Uh and then the last piece, uh you know, I mentioned the Tesla 336 - > agent will always push you towards the loop. 337 - > We sort of believe in loop engineering. 338 - > Yeah, exactly. 339 - > Getting loopy.

340 - > So the uh what the final thing that will be set up is a 341 - > recurring daily or weekly, depending on what you'd like, 342 - > automation where the Tesla agent will scan, again, all of your 343 - > PRs, uh CI checks, PR comments, coding agent sessions, and try 344 - > to find new mistakes that are slipping through. 345 - > So for example, you might start with a more strict humans still 346 - > must review most PRs. 347 - > And as humans are leaving review feedback, the Tesla agent is 348 - > basically observing those and creating new verifiers or 349 - > updating your review skill to try and capture those issues.

350 - > And then it'll use the TESL platform to create evaluation 351 - > scenarios to sort of run back and say, okay, I've seen this 352 - > problem, I've created what I think is affixed to it, I've now 353 - > sort of simulated this PR a few more times. 354 - > Yes, now you wouldn't have had to provide that feedback. 355 - > And so that's where you get into the automated loop of every day, 356 - > every week, you're just getting a couple PRs from the Tesla 357 - > agent that make you just a little more AI native, right?

358 - > Like your skills are a little more robust, your uh PR review 359 - > is catching a few more errors. 360 - > Uh over time, you don't even realize you're necessarily 361 - > investing in it this way, but you'll see just sooner code 362 - > review completion, less time on code review. 363 - > Uh and at some point you might say, like, wow, 40, 50% of our 364 - > PRs don't even have a human looking at it. 365 - > We never had to do a big uh big push or initiative to make that 366 - > happen.

367 - > Just sort of we got started, we focused on doing what we were 368 - > doing, and over time it could just delegate more to the agent. 369 - > SPEAKER_01: Yeah, and and I I think a core principle that 370 - > you're describing here is that you set it up to be a loop uh 371 - > time. 372 - > And so we've defined a thing that would run recurringly, the 373 - > the skill over here, uh we're running it in some sort of 374 - > recurring location in an automation that runs again and 375 - > again, and now we're surveying it uh over and over again.

376 - > And so because it's a loop, you can observe and you can kind of 377 - > voice an opinion of saying, okay, has it gotten better, has 378 - > it gotten worse? 379 - > And you just figure out what is that sort of uh feedback loop 380 - > that it uh that it gets. 381 - > SPEAKER_03: Yeah, exactly. 382 - > It's I'd say the loop is probably one thing if somebody 383 - > was you know just waking up to agents today in 2026 and looking 384 - > to get started.

385 - > I think uh interestingly, the building these loops, doing the 386 - > sort of loop engineering, it feels maybe like an advanced 387 - > topic to start. 388 - > But I think in our own experience, in our own um you 389 - > know, working with customers or building our own sort of 390 - > software factory, it actually is feels like the right place to 391 - > start. 392 - > Uh when you get going with these loops, they solve a major 393 - > problem with agentic development.

394 - > In fact, this was like one of the main reasons we chose to 395 - > build the Tesla agent, is that building your software factory, 396 - > making agents more effective, uh, getting them to run more 397 - > autonomously, delegating work to them, all of that is unplanned 398 - > work. 399 - > You have no way of anticipating where agents will fail, when 400 - > they'll fail, how much work it's going to take to get them to 401 - > stop failing. 402 - > And so when most teams get started with like the 403 - > traditional, you know, boot up an agent, you start interacting 404 - > with it, uh, they basically find this place where the agent will 405 - > have made a mistake and they have to choose between do I push 406 - > through and ship the feature, or do I pause, roll back, and do 407 - > some science to try and make the agent able to do this in the 408 - > future.

409 - > Uh and so people fall into one or two categories. 410 - > They either focus on shipping, in which case they just get 411 - > stuck in this local maximum where they they never take the 412 - > time to fix the agents and get them to a higher level of 413 - > autonomy. 414 - > Uh, or they fall into the second category, they are disciplined, 415 - > they do focus on that autonomy, but you're left with this gulf 416 - > of like several months or or longer, depending. 417 - > It's forever to build that.

418 - > Exactly. 419 - > And it's like, all right, can you eat that sort of a velocity 420 - > drop as you basically shift all your work into internal tooling? 421 - > And so moving to a loop early does two big things. 422 - > The first is that these loops run in very legible ways.

423 - > So instead of having a bunch of your insights into how agents 424 - > are failing, locked away in pr local coding agent session logs, 425 - > if it's running through a PR review. 426 - > It extracts it out. 427 - > Exactly, exactly. 428 - > It's all of it's all available to you.

429 - > So you can start making these improvements. 430 - > And then the loop handles the that grunt work, right? 431 - > Actually putting up the PR that says, I saw this mistake, I 432 - > think this fixes it. 433 - > Yeah.

434 - > And it allows you to focus just on, oh yeah, that makes sense, 435 - > except, right? 436 - > And so it gets the it matches the sort of investment and the 437 - > time scale so that you just stay focused on shipping. 438 - > Agents will get better naturally as you engage with them. 439 - > SPEAKER_01: As you go.

440 - > So I love this sort of uh loop interaction. 441 - > And I guess the uh we we talked about the sort of the loop 442 - > improvement when it comes to the the code review and the inspect 443 - > of those things, but there's also a loop around the agentic 444 - > process, right? 445 - > And I I really like how in the process of that, you know, we 446 - > you know we oftentimes sort of preach here the importance of 447 - > evals and you know how you do that. 448 - > Uh and so uh one of the challenges I guess is we've been 449 - > encountering is that uh you know, like what do developers 450 - > not like doing?

451 - > They don't like you know, writing docs and writing tests, 452 - > and lo and behold, you know you kind of need to do that. 453 - > So uh I I think uh what I also like about the the concept of of 454 - > the loop is that it moves the at least the test authoring into 455 - > something that is uh done through observation. 456 - > So instead of uh you know having the the human write down you 457 - > know, sort of the developer and review things, which you know 458 - > again, sometimes you still need to do.

459 - > You still need to define those tests up front. 460 - > Uh but hidden behind the scenes, if you sort of use the Tesla 461 - > flow, you know, we will have created some evals for that 462 - > plugin that you have, because we've looked at issues. 463 - > But as you do the loop, you know, you can now say, okay, 464 - > let's extract an eval out of that uh out of that uh process 465 - > of it. 466 - > Uh and you know, again, you can kind of debate about how much do 467 - > you do you let you know, how much do you accept those, you 468 - > know, uh autonomously or not, but you extract test cases based 469 - > on real-world scenarios.

470 - > So you still get yourself into a place in which you're not only 471 - > modifying continuously, but you're also building more 472 - > confidence in your changes because you're creating evals as 473 - > you go. 474 - > Yeah. 475 - > But at the same time, you are uh you're not making an effort, 476 - > like you're not really asking developers to do this thing. 477 - > Uh and we can probably we should towards the end talk a little 478 - > bit about ease of use and sort of its importance, but it's one 479 - > of those things where eventually eventually it might be right, 480 - > but if it's not easy, people won't do it.

481 - > Yeah. 482 - > Uh so I like that. 483 - > Yeah. 484 - > Which I guess kind of maybe I'll ask one more question about the 485 - > review thing and then we'll expand to some other use cases.

486 - > But uh you mentioned cost uh in passing, and I guess I guess 487 - > that comes down to that sort of eval process over here, right? 488 - > So like what happens over time as I run these things? 489 - > What do I need to do to be able to make it cheaper? 490 - > SPEAKER_03: Yeah, yeah, yeah.

491 - > Cost certainly uh a much hotter topic these days than it was. 492 - > It used to be it's amazing. 493 - > SPEAKER_01: Yeah. 494 - > Like a month ago, if you were talking about cost, you were a 495 - > Luddite, you know, you're like, yeah, you're not believing not 496 - > an AI believer, you're not sufficiently ADI build on it.

497 - > And now you're like a forerunner, you know, you're 498 - > thinking about it. 499 - > You like open models on it. 500 - > So it's amazing how these things twist. 501 - > SPEAKER_03: Aaron Powell It is.

502 - > It's uh you know certainly makes it hard to build products that 503 - > are forward-looking and meet people where they are today. 504 - > But uh I'd say that there's maybe two big pieces to this. 505 - > So again, to your point, we get a lot of questions from folks 506 - > internally or externally working with customers on how do I think 507 - > about cost, how do I make these things cheaper, but without sort 508 - > of unnecessarily slowing my devs down. 509 - > People are willing to pay if it has good ROI, but they also 510 - > don't want to just pay because.

511 - > So I think the first thing this is I'm sure going to become a 512 - > broken record of like pulling it back to loop engineering. 513 - > But the first piece of advice I always give, and the Tesla agent 514 - > really tries to especially. 515 - > This philosophy is don't try to optimize your general cost, 516 - > right? 517 - > If you're thinking about how do I make it so that every time 518 - > someone opens Claude Code, they're picking the right model, 519 - > they're planning with Opus, and then delegating to haiku or 520 - > things like that.

521 - > That's going to be a bit of a losing game, I think, for two 522 - > reasons. 523 - > The first is humans. 524 - > Nobody really wants to think about that kind of stuff as 525 - > they're getting going. 526 - > And they'll kind of always default to whatever their 527 - > preference is.

528 - > But the second is that it's also very hard to anticipate up front 529 - > when a job is going to become complicated. 530 - > You might hit an unexpected issue, snag, part of the code 531 - > base that you thought this was a haiku task or you thought this 532 - > was a GPT-4.1 or something like that, but it actually is a 5.5 533 - > task.

534 - > That is just hard. 535 - > And I'd say for most people, you're going to get the best 536 - > results in your daily interactive driver of just use 537 - > the best model that you're comfortable using and let it be 538 - > flexible. 539 - > But then alongside that, if you are good about identifying 540 - > recurring tasks and structuring them into workflows and really 541 - > relentlessly carving them off of that general purpose path into a 542 - > dedicated skill or plugin that codifies this is how we add a 543 - > new command to our CLI, or this is how we do version bumping, or 544 - > anything like that.

545 - > Those become great targets for optimization. 546 - > And so what I generally say is the work of delegating and sort 547 - > of caught putting a box around a certain task and setting it up 548 - > to run automated is also the work of cost optimization. 549 - > Because then you can find where your bottlenecks are, say, like 550 - > this is a workflow that runs, for example, code review. 551 - > Every single PR.

552 - > So it's 50, 60, 70 times a day, and it's really important to us. 553 - > We really need to strike the right balance of cost versus 554 - > quality. 555 - > That's where you can bring in the rest of Tesla's tools to 556 - > say, I have this skill. 557 - > It codifies my workflow for code review, create a bunch of 558 - > hypothetical PRs for it to review, run it through its 559 - > paces, try it on a small model, try it on an open model, help me 560 - > make that trade-off of, you know, maybe it's 5% worse, but 561 - > 80% cheaper, I'm willing to pay that cost.

562 - > And so the Tesla agent basically is built to help you do that 563 - > process. 564 - > It watches you as you work with agents, it watches the PRs you 565 - > put up, and it's going to try and sort of bit by bit move 566 - > repetitive tasks into structured workflows. 567 - > And then once that's in place, it can help you optimize them. 568 - > Right.

569 - > SPEAKER_01: Yeah. 570 - > And I think we've always observed how our evals could 571 - > help you know, for instance, that you can use whatever it is, 572 - > Deep Seek, you know, instead of Sonnet or instead of GPT-5.5. 573 - > And that's fine.

574 - > But one of the struggles was like, how do I, again, from a 575 - > kind of reasonable ease of use, you know, do you really expect 576 - > people to every time you know spawn a subagent with that or 577 - > change it and remember what they're doing it? 578 - > Um and so uh I I think one of the sort of the hidden wiring 579 - > that we do when you set up the agent is when you run that 580 - > environment, we don't just set up the skill in the plugin, but 581 - > we also run it uh under this command call tester launch, 582 - > which again we'll probably sort of write more about, uh which is 583 - > more of like an environment management uh uh setup, uh which 584 - > allows you to then modify that sort of uh uh project or that 585 - > plugin that it runs.

586 - > So once you've concluded that, you can also switch easily. 587 - > And it's all about just sort of the the gradual path, right? 588 - > And the evolution. 589 - > SPEAKER_03: This is I'd say a big uh so in many ways the Tesla 590 - > agent is an interface to uh and a driver of a lot of these 591 - > workflows that without the agent, uh we found that just 592 - > building up towards a factory was too hard, right?

593 - > There's knowledge that you don't have that's changing every few 594 - > weeks. 595 - > People would try to build their own harnesses and then update 596 - > their harnesses and then update them again, and then you know, 597 - > cobbling everything together. 598 - > So a lot of what we're doing to your point is just trying to 599 - > bring into one place a vertical agent focused specifically on 600 - > this task with good tools, the right sort of latest 601 - > cutting-edge knowledge kept up to date on your behalf.

602 - > But you could probably take a bunch of this and use it 603 - > elsewhere if you want it, right? 604 - > We we like to work with any agent that you bring, but we 605 - > also want to make it easy for users. 606 - > But there's a second component that you alluded to with uh one 607 - > of the new commands we're launching, Tesla launch, which 608 - > is basically allowing you to create an environment for agents 609 - > to run in. 610 - > When you get into this task of, okay, I have my sort of skills 611 - > platform in place, I have the governance, the security, the 612 - > standardization that I want, I'm ready to start scaling and 613 - > building these loops.

614 - > Teams immediately start building the same few primitives over and 615 - > over again. 616 - > Like you need a way to wire your issue tracker up to some kind of 617 - > agent environment to kick off tasks. 618 - > You need a whole suite of agentic code review. 619 - > Uh, you have things like when a task finishes, I want to post 620 - > back to the issue tracker.

621 - > And so alongside the Tesla agent, we're releasing a whole 622 - > bunch of building blocks that make those parts easy. 623 - > So the big one that you mentioned, Tesla launch, is just 624 - > a sort of dead simple drop-it in coding agent environment, runs 625 - > in the cloud, gathers all the logs for you to review, and do 626 - > that sort of optimization loop against. 627 - > Uh but it also just has good defaults. 628 - > It can run for longer than 60 minutes.

629 - > It doesn't have to refresh its GitHub action token all the 630 - > time. 631 - > Easy to switch between agents. 632 - > There's a few others that I'm sure will detail in the in the 633 - > launch blog post. 634 - > But all these things come together to your point to make 635 - > it really easy to just start building your factory one piece 636 - > at a time.

637 - > You don't have to pause and do a foundational investment to build 638 - > a linear app and a GitHub app that can talk to each other and 639 - > then think about the polling semantics. 640 - > You can just find a task, put it in automation, and then find the 641 - > next task, find the next task. 642 - > And it's never going to feel like you're stopping to do this 643 - > big initiative. 644 - > You're just slowly working towards automation.

645 - > SPEAKER_01: Yeah, so I I love I love that definition. 646 - > And I guess also probably as people think about sort of Tesla 647 - > as a whole, you know, we increasingly think about Tesla 648 - > as this sort of composable factory, right? 649 - > And you run the agent and you can use the TESL tools, and 650 - > clearly, you know, we're sort of quite familiar. 651 - > We built the tools for a reason, you know, we have those.

652 - > Uh whether those are the existing tools like our ability 653 - > to eval and gather logs and uh and analyze them, uh, but also, 654 - > you know, or these sort of newer capabilities that we're that 655 - > we're introducing. 656 - > Uh but the idea of the agent is you know it can help pull that 657 - > together and provide you these different services to help you. 658 - > So we said a lot about code review uh in the process of it. 659 - > Can you just sort of quickly name a few other examples of 660 - > loops or use cases that the agent can help you with?

661 - > SPEAKER_03: So there's sort of infinite, which is what always 662 - > makes it hard to talk about these products, but I will I 663 - > will control myself. 664 - > Yeah, just a few. 665 - > Uh so after setting up code review, I think my next few 666 - > favorite uh first is you can just ask the agent, what could I 667 - > delegate to agents? 668 - > And it will go and look through recurring tasks that seem to 669 - > succeed with a high rate for you, uh, and suggest creating 670 - > automated uh CI CD actions around that.

671 - > Another thing that you can do is if there is a certain component 672 - > or type of feature that agents have been struggling with, you 673 - > can just ask the Tesla agent, you know, help agents work in my 674 - > front end, or make agents more effective at designing layouts. 675 - > And it will go and it will analyze fine failures, pull them 676 - > in. 677 - > Uh another great one to get started is just make my repo 678 - > agent ready. 679 - > Uh this will do a bunch of things, but one of the main 680 - > things is we have a bunch of default repo maintenance tasks 681 - > like uh daily architecture review, uh test quality checks, 682 - > things like that that we'll just set up for you.

683 - > It's a great way to get going of just immediately hand off a 684 - > bunch of work to agents in a sort of general purpose way. 685 - > So I'd say those are probably the ones that get started, just 686 - > set up code review, fix a thorny issue where agents have just 687 - > been messing up in your code base, set up repo maintenance 688 - > tasks, or just ask the Tesla agent to help you delegate more 689 - > work to AI, and then it'll go from there. 690 - > SPEAKER_01: Yeah, I love those.

691 - > I also uh I like uh recurring things around all of those 692 - > activities. 693 - > And so like each of those things, once you get them loopy, 694 - > uh you you start saying, okay, run a kind of recurring 695 - > architecture review. 696 - > You know, fix my flaky tests uh on a recurring fashion. 697 - > Yeah.

698 - > SPEAKER_03: Uh and once you have one set of loops, then you can 699 - > make loops around those loops. 700 - > So you set up your daily architecture review, but then 701 - > eventually you can set up a loop that monitors your daily 702 - > architecture review and makes it more effective every single day 703 - > or week. 704 - > And all of this, I know it can seem a bit overwhelming, just 705 - > you know, loops on loops on loops. 706 - > Tesla agent is designed to handle all of this.

707 - > So you just give it the task, give it the problem you're 708 - > seeing. 709 - > And uh one of the main things that the Tesla Agent does is 710 - > think about how to break it down into a loop and suggest an 711 - > automation so that you never have to do the same task more 712 - > than once or twice. 713 - > SPEAKER_01: Yeah. 714 - > And maybe I'll also highlight that many of these automations 715 - > and these loops, they will uh oftentimes be focused on the 716 - > repo itself.

717 - > So like the other flexible aspect of it is do you uh like 718 - > oftentimes you will set up those uh optimizations and they will 719 - > land uh as let's say a GitHub action, right, that runs on a 720 - > schedule or things like that if you're sort of doing something 721 - > that's in the repo. 722 - > And then of course you can kind of set up uh automations that 723 - > are that are a bit more broadly. 724 - > So lots and lots to do. 725 - > SPEAKER_03: So much to do.

726 - > SPEAKER_01: So a common question that that we kind of get and 727 - > sort of discuss with customers around this notion of like 728 - > building a factory versus buying one, right? 729 - > I think uh today it's sort of a non-controversial statement to 730 - > say that everybody needs to kind of work towards a factory. 731 - > I've read it when you're gonna do it. 732 - > Yeah.

733 - > Maybe you can say a few words about sort of our philosophy 734 - > when it comes to kind of factory building and kind of you know, 735 - > own it versus buy it. 736 - > SPEAKER_03: Yeah, of course. 737 - > So uh I'll I'll bligh some of my roots here. 738 - > I started my career working on open web platform, uh web 739 - > standards, so certainly have a bit of a bleeding heart for this 740 - > as well.

741 - > But I also think it's it makes good sound business sense. 742 - > Uh at TESL, we think that the factory that you build is gonna 743 - > be a piece of technology. 744 - > It's gonna be a differentiator that your team owns. 745 - > It's part of your software discipline is building and 746 - > maintaining this factory, and that there will be repeating 747 - > components to a factory, but that everyone's factory will 748 - > look slightly different based on your preferences and the 749 - > services that you use.

750 - > So factory uh platforms will be much more like platforms, less 751 - > like frameworks or like end-to-end solutions that you 752 - > just buy off-the-shelf black box. 753 - > Uh, and we think that for a few reasons. 754 - > I think the most important one is that when you think about the 755 - > grand total of building software products, right? 756 - > There's a lot that goes into it.

757 - > It just seems hard to imagine how a single provider, a single 758 - > company could be best in breed at every single component that 759 - > goes into that, right? 760 - > Design, mock-ups, code review, actually generating code, uh 761 - > working with your legal team, sales, like all those things 762 - > need to be brought into the factory over time. 763 - > And buying into a single solution, somewhere in that 764 - > stack, you're gonna be buying into not the best version of 765 - > that component.

766 - > And so we think that being open, modular, like Tesla wants to 767 - > provide good defaults, so you don't have to think about it if 768 - > you don't care about it. 769 - > But for the parts that you care about, you need to be able to 770 - > plug in either your own built solution or the best of breed so 771 - > that you can uh be getting the results that you need. 772 - > Yeah. 773 - > That's a that's an important one.

774 - > I think the other is that when you think of how critical this 775 - > factory is going to be to your company, I mean, in effect, it 776 - > is the thing that produces your product. 777 - > SPEAKER_01: But you're developing that. 778 - > SPEAKER_03: Exactly. 779 - > And so it's a very sensitive place to be bought into a fully 780 - > integrated solution that now has complete pricing leverage over 781 - > you, right?

782 - > If you think about just the sorts of processes and workflows 783 - > that you bake in, right, they're very specific, and that's part 784 - > of what becomes your IP, your moat against competitors. 785 - > But imagine if then all of that work you've built to 786 - > differentiate yourself is now owned by someone else. 787 - > And so they say, hey, everything that makes your company you is 788 - > in our ecosystem, and so we're going to crank up the token 789 - > cost, the token spend, et cetera.

790 - > And so we think that your factory needs to be built on an 791 - > open modular framework that you can sort of trust to assess its 792 - > own work, right? 793 - > Fact optimizing the factory is like an important component of 794 - > the factory, and so you need to trust it when it says, hey, this 795 - > time you really do need to use the biggest model and you do 796 - > need to spend 50% more on tokens. 797 - > You don't want to be questioning those kinds of suggestions.

798 - > Uh and then finally, it's like a big part of TESIL is we like to 799 - > think of there's the rails that your factory runs on, and then 800 - > there are the artifacts and knowledge, the context basically 801 - > that powers those rails in the factory. 802 - > And for that, we believe that you should own those artifacts 803 - > so that you can always pick up and move to another provider. 804 - > Uh you basically own the secret sauce, right? 805 - > So a great example of this with code review.

806 - > We think that there is a general harness that should provide code 807 - > review, but you don't want the brain of your code review to be 808 - > locked inside that harness. 809 - > You want to be able to say, look, we found a better tool, 810 - > we're going to move to it. 811 - > All of the work we've put into finely crafting our workflow, 812 - > our style guide, the things that we've worked for. 813 - > That's just a skill checked into our repo.

814 - > So we can go plug that into any brain. 815 - > SPEAKER_01: Aaron Powell And I think so. 816 - > This is very consistent with how we've generally been thinking 817 - > about sort of context and skills and building those out, which 818 - > is, you know, we we believe in the future you will have many 819 - > agents because agents will specialize in different things. 820 - > Uh we think you will need to sort of share context with them.

821 - > Uh and similarly, we think you'll actually have multiple 822 - > factories. 823 - > You know, you'll have different factory lines or different sort 824 - > of uh aspects that optimize for uh different different parts and 825 - > different sort of you know stages of uh of development. 826 - > And and really we're talking a lot about software factories 827 - > over here, uh, but we expect very much that this sort of 828 - > expands into uh agentic factories. 829 - > Yeah.

830 - > Um and also like maybe it's worth pointing out that uh you 831 - > know what while like all of this stuff it it could sound a little 832 - > bit like a like a change from what we have been discussing uh 833 - > all this time, right? 834 - > Like we uh we've been talking about sort of scaling skills and 835 - > governing them and uh and securing them, uh, and a lot 836 - > about you know context and context is the new code, you 837 - > know, and how do we think about that?

838 - > Um so I guess it's uh it's worth maybe taking a moment a little 839 - > bit to say, like this is we don't perceive this as a pivot, 840 - > we see it as an expansion. 841 - > I guess how how does all of this conversation around scaling 842 - > context, scaling skills, uh that you know, again, customers have 843 - > a real pain around it? 844 - > Yeah. 845 - > How does that relate to the agent?

846 - > You know, like over here we're starting saying loop 847 - > engineering, you kind of alluded to harness engineering on it, 848 - > which again probably needs like its own kind of conversation on 849 - > the podcast. 850 - > Um how uh how do you see the two interacting? 851 - > Yeah. 852 - > SPEAKER_03: Uh on the product team, there's always have this 853 - > question of sort of what is our field to play on or not.

854 - > And so you're always asking the question for a new feature. 855 - > Like, does it make sense for us to solve this problem? 856 - > And this is actually one of the easier choices or easier 857 - > decisions. 858 - > Uh, when we think of TESL's mission of agent enablement, we 859 - > want to help you actually bring coding agents and you know all 860 - > agents in the future to do real productive work for you.

861 - > This just feels like a very natural extension of that. 862 - > So in that regard, I think it's all part of the same goal, which 863 - > is help you actually deploy and delegate work to agents 864 - > effectively and get real productive work done. 865 - > Maybe from a more mechanical perspective, I think all of 866 - > these are aspects of the same solution. 867 - > So it really just sort of depends on where you're 868 - > starting.

869 - > So most companies uh that have gotten started with agents, 870 - > they're starting to feel skill sprawl, they have hundreds, 871 - > thousands of skills, they don't know which ones are good, they 872 - > don't know where the duplicates are. 873 - > Right. 874 - > Those folks want to get started on the governance end of the 875 - > spectrum. 876 - > They're gonna say, help me inventory all of my skills, uh, 877 - > use TESL to do a security review, find any 878 - > vulnerabilities, then create policies to make sure that we 879 - > never have this issue again.

880 - > They're gonna start doing review, quality review on 881 - > skills, codifying their best practices. 882 - > You can think of this as taking charge of a sort of grounds up 883 - > upswell that you want to now make sure scales effectively 884 - > across your company. 885 - > Right. 886 - > SPEAKER_01: And it's worth noting that that's also the the 887 - > whole world of non-dev skills is where we've seen a lot of pickup 888 - > and adoption, which is uh we help a lot of customers deal 889 - > with kind of that world of they have their sales skills, their 890 - > marketing skills, their product skills on it.

891 - > Uh those worlds are generally not ready for words like 892 - > factory. 893 - > There are sort of a lot more around just I just want to sort 894 - > of share best practices, basically usage packaged up in 895 - > the form of skills and rules. 896 - > SPEAKER_03: I think of this as the very sort of bottoms-up form 897 - > of factory building. 898 - > I increasingly I think of all of this as factory building.

899 - > Uh the question is do you build a factory by focusing on the 900 - > components first, right? 901 - > Like finding your workflows, putting them into skills, 902 - > getting uh your team trained up on how to work with agents, how 903 - > to review their work? 904 - > Or are you a bit more on the leading edge of things? 905 - > You want to start factory first, and then as you get automated 906 - > workflows running, you're gonna go in and decompose the 907 - > components that matter that you then want to add in, things like 908 - > governance or standardization.

909 - > So coming from this other direction, you might come in 910 - > immediately with setup agentic code review, or agents can't 911 - > work with our front-end layout, make it better, and then make 912 - > sure they never get worse at it again, right? 913 - > And so you're starting with these loops. 914 - > And I think it's a great way to get started if you are 915 - > introducing your team for the first time to agents, because 916 - > this is very focused on making agents effective and delegating 917 - > work to them.

918 - > It's a quick path to value. 919 - > Exactly. 920 - > SPEAKER_01: And you're actually setting yourself up in a good 921 - > spot. 922 - > SPEAKER_03: Yeah.

923 - > And it helps you also uh isolate the change as you work, right? 924 - > You can have one team just get started with agents, make 925 - > themselves a bit more effective. 926 - > Uh you don't have to worry about the governance and the security 927 - > parts at this point, because it's just a one team working on 928 - > it. 929 - > But at some point you're gonna want to start scaling that out, 930 - > right?

931 - > Like you'll have proven it with one team, they're effective, 932 - > they've automated a lot of their work. 933 - > They want to start interfacing with other teams in this 934 - > automated fashion, and that's where these governance and 935 - > standardization primitives come in. 936 - > We say, okay, now I'm gonna start hat letting everyone in 937 - > the company throw skills into this registry. 938 - > We see again and again is all of these things run at the pace of 939 - > agents.

940 - > And so the first week you'll say, Oh, I'm just getting 941 - > started with skills. 942 - > And then the second week, you're like, I have 15,000 skills. 943 - > What happened? 944 - > Right.

945 - > So you kind of have to get these primitives in earlier than you 946 - > probably would normally, but it really just depends on what are 947 - > you trying to do first. 948 - > Are you trying to bring agents across your organization, or are 949 - > you trying to sort of go deep on some agentic flows and get them 950 - > automated? 951 - > Yep. 952 - > SPEAKER_01: Cool, cool.

953 - > Yep. 954 - > So I I think um, you know, for for us, we try to build all of 955 - > that in that type of kind of composable approach uh to uh to 956 - > you know, kind of helping you build kind of that factory, that 957 - > estate. 958 - > So it's always in your control. 959 - > It's your context, it's your plugins, it's your kind of 960 - > workflows, and now it is sort of your loops and your uh your set 961 - > of harnesses that we help you optimize.

962 - > Um and I guess just as a side comment, you know, we focus very 963 - > much here on sort of the agent's um uh uh advantages and the sort 964 - > of new competency from terms of like Tesla helping you with 965 - > engineering and uh uh harness engineering. 966 - > But you know the agent is also an interface for many other 967 - > things, and we you know we love sort of seeing you know 968 - > customers use it for customizing and defining their policy, for 969 - > handling that inventory processes, for sort of building 970 - > those out.

971 - > So excited about the agent. 972 - > And it's interesting how you know we we kind of grew to to 973 - > accept and get used to uh in the web interface having a little 974 - > agent chat uh on the side. 975 - > And to say, fine, yeah, you have you know all of these things 976 - > that you can invoke, but then you can have the agent to just 977 - > perform a bunch of actions for me, whether it's on my sort of 978 - > slide deck or in my analytics portal or whatever it is.

979 - > Yeah. 980 - > Um but we we still think it's a slightly kind of bigger deal or 981 - > change when it's on the command line interface. 982 - > So in that sense, like it is also just a command line 983 - > interface, and it will eventually make its way to the 984 - > uh to the uh to the web interface as well. 985 - > SPEAKER_03: Starting with the local CLI, it just kind of gives 986 - > you the most flexibility.

987 - > And so given TESL's overall approach to factory building, it 988 - > just it seemed like a no-brainer. 989 - > Let's start with the thing that gives people the most power, and 990 - > then exactly to your point, coming very soon we'll have much 991 - > more streamlined interfaces for folks who aren't comfortable 992 - > with a command line or who just want something in a simpler, GUI 993 - > interface, things like that. 994 - > SPEAKER_02: Hey everyone, hope you're enjoying the episode so 995 - > far.

996 - > Our team is working really hard behind the scenes to bring you 997 - > the best guests so we can have the most informative 998 - > conversations about agentic development. 999 - > Whether that's talking about the latest tools, the most efficient 1000 - > workflows, or defining best practices. 1001 - > But for whatever reason, many of you have yet to subscribe to the 1002 - > channel. 1003 - > If you're enjoying the podcast and want us to continue to bring 1004 - > you the very best content, please do us a favor and hit 1005 - > that subscribe button.

1006 - > It really does make a difference and lets us continue to improve 1007 - > the quality of our guests and build an even better product for 1008 - > you. 1009 - > SPEAKER_01: Alright, back to the episode. 1010 - > So uh we're kind of running uh running up on time here. 1011 - > Uh I want to maybe share kind of one learning uh from uh from the 1012 - > product building side of this, which I think is sort of useful 1013 - > and it's interesting.

1014 - > Uh or maybe even two, you know, one is it's just sort of 1015 - > reiterating the importance of ease of use, right? 1016 - > We're we're seeing this like in uh I I I I like talking about 1017 - > how you know even like in SNCC days, I would talk about uh ease 1018 - > of use for security and you know how uh for everything in life, 1019 - > there's how much you care about something and and how hard it 1020 - > is. 1021 - > And you need to care more than it is hard. 1022 - > Uh and then and then you act.

1023 - > Um and so it's interesting to see the action over here. 1024 - > And I I I think one of the things we're trying to address 1025 - > in terms of ease of use. 1026 - > Is uh is is just by the ease of use of getting into this 1027 - > business. 1028 - > It it has kind of a newer problem, and it it's not a new 1029 - > problem that you can't keep up, but it's a much bigger problem 1030 - > right now on it.

1031 - > So the agent kind of embodies a bunch of that knowledge. 1032 - > So, you know, yes, technically you can run it with whatever, 1033 - > you know, with your codex, with your cloud, with your sort of 1034 - > Gemini, but it's uh it's uh it's you need to know what you're 1035 - > doing and it's a lot of work, and then whatever it is you 1036 - > thought you knew, you know, like loop engineering is like a few 1037 - > weeks old and my best you know, in terms of a uh a term.

1038 - > And so capture that knowledge, it's about ease of use of uh of 1039 - > the of the UX, being able to run a bunch of these things. 1040 - > It's about ease of use with sort of a Tesla providing a bunch of 1041 - > these tools around it, so you don't need to say, okay, you can 1042 - > do this, but now you need to equip yourself with seven 1043 - > different sort of foundations on it, which again over time you 1044 - > might modify, you might switch, you know, you sort of push us to 1045 - > sort of build better tools.

1046 - > Uh and and I guess it's about the ease of use feedback loop, 1047 - > right? 1048 - > Because what we've seen is we we created tools, we gave them to 1049 - > users, we wanted to make it easy, so we gave them skills as 1050 - > well, and they ran, but as they would run them in their sort of 1051 - > coding agent of choice, uh it was it was hard for us to fix 1052 - > problems like we've seen. 1053 - > It's hard to see visibility, like as a product developer, you 1054 - > want to be able to see what's going on so that you can 1055 - > improve.

1056 - > Uh, it was hard to fix issues, you know, if the agents went 1057 - > sideways or a new whatever uh anthropic model sort of uh you 1058 - > know suddenly became less obedient, which we've had many 1059 - > uh uh many uh many cases of that, uh, or tuning it. 1060 - > And so the harness gives us that. 1061 - > So I guess as I as I think about uh uh and that this kind of 1062 - > spills a bit into my sort of second view, is that 1063 - > increasingly I think that the the shape of a product in the AI 1064 - > era is sort of these like four components, which is a set of 1065 - > tools that you build, which we used to call in like the pre-AI 1066 - > era products.

1067 - > Those are kind of the capabilities, but now we think 1068 - > about them as tools, a set of skills, a kind of embodied 1069 - > expertise, uh, a harness to be able to provide a UX and a 1070 - > bundle, all of those things. 1071 - > You know, this is our harness, we also help you build your 1072 - > harness and the likes. 1073 - > Uh, and then some form of control center or like central 1074 - > repository for collaboration, especially as you go across time 1075 - > and across people to do that, uh, which we offer with a 1076 - > platform.

1077 - > So it was an interesting kind of learning process here. 1078 - > SPEAKER_03: The way that I've sort of brought it together when 1079 - > thinking about designing new products and maybe like a very 1080 - > concrete way is that like you said, ease of use has always 1081 - > mattered, but agents have added a few new layers, especially if 1082 - > you're thinking about DevTool products, which is that 1083 - > historically I think DevTools have focused a lot more on 1084 - > providing expressive power.

1085 - > Like make sure that you have really modular, composable 1086 - > primitives to do high-value tasks. 1087 - > And there was just sort of an expectation that the value is 1088 - > going to be enough that as a developer, you will learn my new 1089 - > vocabulary, you will stitch them together, you will do a lot of 1090 - > building on your own. 1091 - > And I think the first thing to really internalize about agents 1092 - > is that they've really made all of us insatiable, like 1093 - > outcome-oriented machines, right?

1094 - > Gone are the days where you say, oh yeah, to do this, just call 1095 - > this m-call this command, then this command, then this command, 1096 - > and you know, they're all like you got to learn a bit, but no, 1097 - > it's worth it. 1098 - > And then now it's like, I'm gonna tell you what I want and I 1099 - > expect everything to happen. 1100 - > And so that sort of end-to-end, I want to speak in outcomes, I 1101 - > don't want to speak in the language of your product is has 1102 - > never been more extreme in this moment.

1103 - > I think the the second is the usability of knowledge become is 1104 - > like supercharged, right? 1105 - > Agents are changing so fast, they're changing the industry so 1106 - > fast that not only is there just a lot to learn because there's 1107 - > all these new concepts coming out, but learning is no longer a 1108 - > one-time event. 1109 - > I mean, we've always had continual learning, but now it's 1110 - > continual learning means like daily or weekly. 1111 - > And so I think a significant portion of usability that you 1112 - > can provide is handling that on behalf of your users, keeping 1113 - > things up to date for them.

1114 - > Uh and then maybe an outshoot of that, as you yourself become 1115 - > more agent-enabled as a product company, one thing that we have 1116 - > found is quickly your rate of shipping features will start to 1117 - > outstrip your GTM motions, eventually just your user's 1118 - > ability to ingest the changes. 1119 - > And so you sort of end up getting back into this place 1120 - > where you have to provide an agentic interface that is 1121 - > keeping up with the change of your product so that users can 1122 - > stay focused on the thing that is stable, which is their 1123 - > business and what they want to be doing.

1124 - > And then the agent is constantly updating and translating that 1125 - > into the latest and greatest in your product. 1126 - > SPEAKER_01: Yeah. 1127 - > Yeah, it's agents all the way down. 1128 - > Yeah, yeah, yeah.

1129 - > SPEAKER_03: The answer is always more agents. 1130 - > SPEAKER_01: Yeah, yeah, indeed. 1131 - > So, you know, lots of exciting things. 1132 - > And it's worth in the talking about learning and talking about 1133 - > sort of knowledge on it, uh, worth noting that we're actually 1134 - > also launching uh just now uh TESL.

io slash learn, which has 1135 - > some interesting agentic patterns and has sort of 1136 - > education capabilities. 1137 - > Uh so hopefully people check that out. 1138 - > This episode was dedicated to the TESL agent, but you know, 1139 - > there's sort of uh more uh more that you know we've been uh 1140 - > we've been chipping as the as the pace picks up. 1141 - > Um so before we close off, uh Drew, just uh a couple of words 1142 - > about what what happens next.

1143 - > Now we're so we launched the agent, you know what uh what 1144 - > happens next. 1145 - > And then how can people get started? 1146 - > SPEAKER_03: Yeah, uh so number one, we've just launched, we're 1147 - > really excited to get feedback from folks. 1148 - > Uh sort of always the name of the game is you can expect the 1149 - > Tesla agent to get faster, cheaper, smarter at everything 1150 - > we've talked about here.

1151 - > Uh and then from there, I think we're really just focused on how 1152 - > do we make it easier, more seamless to go from any starting 1153 - > point you may be at with scaling skills or exploring a few 1154 - > automations to how can we get you towards that factory vision 1155 - > faster with less effort, less uncertainty, lack of confidence 1156 - > as you go. 1157 - > Uh but really focused on that incremental path. 1158 - > I think that's the main thing to expect from Tesla is we're the 1159 - > we want to be the tool that helps you go from where you are 1160 - > today to factory.

1161 - > We're not just the, hey, if you can throw everything out and 1162 - > build a greenfield code base, you can do the cutting edge. 1163 - > So expect to see more there. 1164 - > SPEAKER_01: Yeah, indeed. 1165 - > And this this notion of uh you know, we talked about sort of 1166 - > the the catchphrase, right, from scaling skills to uh to a 1167 - > full-on factory.

1168 - > Yeah. 1169 - > You know, maybe there's loops somewhere sort of in the in the 1170 - > process of it, but it's uh it's okay. 1171 - > Everybody's behind. 1172 - > Yes, yeah.

1173 - > SPEAKER_03: So let's sort of uh gradually let's no one feels 1174 - > comfortable, everyone wants to go faster, but we're here to 1175 - > help you move sort of through that process. 1176 - > Uh in terms of how to get started, it's pretty easy. 1177 - > Just go to the website, download the Tesla CLI, uh, and then ask 1178 - > it to do something for you. 1179 - > So TESL agent, hit enter, just like every other agent.

1180 - > It'll open a session, ask it to set up code review, ask it to 1181 - > delegate some work to AI for you. 1182 - > All of those things will work just fine. 1183 - > It's an agent, so you can ask it to do other things as well. 1184 - > Uh and then over time, more and more of it will be put into 1185 - > automation just as you as you work with the agent.

1186 - > SPEAKER_01: Yeah. 1187 - > And I think if you want to do the experiment, you can also try 1188 - > out uh having different team members run the Tesla agent 1189 - > because it does look a little bit at their logs. 1190 - > And so there's a little bit of an element of if you heard that 1191 - > someone is having a problem, uh having them try the Tesla agent, 1192 - > that might be an interesting experiment. 1193 - > SPEAKER_03: Yes, yeah, yeah.

1194 - > It's a great way uh the Tesla agent both can look at your 1195 - > local logs, it can also help you get your logs into a communal 1196 - > space. 1197 - > And as a point of getting started, sometimes just sitting 1198 - > down with the last month's worth of coding agent sessions and 1199 - > just asking what's broken, what's taking a lot of our time, 1200 - > will yield some really interesting results. 1201 - > Yeah. 1202 - > SPEAKER_01: So I think that's it for us.

1203 - > Hopefully you find the TESL agent interesting. 1204 - > We'd love to have you try it out and share feedback. 1205 - > You know, this is very much about iterating. 1206 - > Hopefully, you're well familiar that we're all about the 1207 - > community uh at uh TESL.

1208 - > So join the AI Native Dev Discord, share comments uh and 1209 - > feedback that you have around the product, you know, things 1210 - > you love, things you uh want to see us change. 1211 - > Uh, we're super, super excited about the TESL agent over here. 1212 - > Probably the most important thing. 1213 - > We're getting a little bit told off uh a little bit about uh uh 1214 - > the the you know just sort of how much we talk about it.

1215 - > Uh but very, very keen to see it come to life. 1216 - > You know, early users, thanks a lot for all the great feedback 1217 - > and evolutions uh for it. 1218 - > Uh and yeah, try it out and tell us uh what you think. 1219 - > Yeah, can't wait.

1220 - > And with that, thanks for tuning in to uh this episode and hope 1221 - > you join us for the next one. 1222 - > SPEAKER_02: The AI Native Dev is brought to you by Tesla, the 1223 - > package manager for skills and context. 1224 - > Your hosts are Guy Pajani and me, Simon Maple. 1225 - > Our producer is Tom Dowler.

1226 - > The AI Native Dev is not just a podcast, it's a community. 1227 - > And we host monthly meetups at the TESL offices in central 1228 - > London. 1229 - > Visit Tesla.io forward slash community to learn more, and I 1230 - > hope to see you there.