# Your agent is blindfolded

Johan Lajili, Poolside

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/iRcX54EO5g8-your-agent-is-blindfolded) · [Video](https://www.youtube.com/watch?v=iRcX54EO5g8)

## Your agent is blindfolded

Coding agents need a way to see failures, operate the application, and verify repairs. Johan Lajili shows how application-specific tooling makes that feedback loop possible.

### Why does AI coding work for one developer and fail for another?

[0:16](https://www.youtube.com/watch?v=iRcX54EO5g8&t=16s)

How can one developer stop touching code while another gets unusable changes in a production application? Johan Lajili, an engineer at Poolside, opens with this split in experience. Poolside builds its own foundation models and coding agents, but the problem is familiar across tools: one developer celebrates having AI do everything; another asks whether those successes amount to little more than to-do apps.

It is easy to dismiss the enthusiast as selling AI or the skeptic as someone who never really tried it. A more useful explanation distinguishes **greenfield** projects from **brownfield** applications: starting fresh seems easier than changing a system with years of accumulated decisions. Yet Lajili has used AI successfully in legacy applications. The age of the codebase alone does not explain the difference.

![Two stacked Reddit posts contrast letting Cursor and Claude do the coding with reports of hallucinated imports and broken services.](https://ai.engineer/api/talk-essay-media/aca7c44891f231af8ef54a35e38826eb4f2389d4c6671a5b40c89a214bf24013)

Two contrasting accounts of using AI coding tools.

### Plausible code needs feedback

[1:54](https://www.youtube.com/watch?v=iRcX54EO5g8&t=114s)

In a new application, an agent's expectations often fit the environment it is creating. Put a component here, add a service there, and the resulting structure may work as expected. An existing application contains surprises: a promising code path may no longer be used, or behavior may depend on another part of the repository the agent has not inspected.

| Environment | What the agent can miss |
| --- | --- |
| Greenfield | Whether its newly created structure actually behaves as expected |
| Brownfield | Dead code, hidden dependencies, and existing behavior outside its inspection |

The distinction makes the **feedback loop** decisive. Intuition can suggest an implementation, but observations must establish whether that implementation works in this application.

When an agent announces that a new workflow works perfectly, its confidence is bounded by the capabilities and information it received. It may have verified the result; it may only have produced something that looks correct. A user who discovers a failure can supply logs and ask for another attempt, keeping the loop moving. Another user may conclude that the tool cannot be trusted and stop. The engineering opportunity is to let the agent obtain that corrective evidence itself.

### Give the agent access to the application

[3:44](https://www.youtube.com/watch?v=iRcX54EO5g8&t=224s)

At Poolside, Lajili built an internal CLI called **Spoolside** to let agents test the application. Its inspection capabilities include screenshots and snapshots: compact representations of what is on a page that an agent can consume without the full page content. He compares these capabilities with [gstack](https://github.com/garrytan/gstack/blob/main/browse/SKILL.md.tmpl).

Poolside's application is a **VS Code extension**, so ordinary webpage access is not enough. Spoolside supplies the additional access machinery that lets the agent interact with the extension much as it would with a webpage. It then extends that access across the running system:

- **Service evidence:** Extract logs from frontend and backend services.
- **Service control:** Restart services when needed.
- **Navigation:** Open a particular menu or go to a particular page.
- **Conversation workflows:** Send a message, wait for the agent's reply, send a follow-up, and upload an image.

These higher-level operations can be composed into a workflow. The agent gets both a way to act and a way to observe what happened.

![Slide titled “Our CLI at Poolside: Spoolside” lists snapshots, screenshots, component interaction, DOM tracing, service restarts, logs, and high-level commands.](https://ai.engineer/api/talk-essay-media/ab4d5876a1a3388bdfd4516ec5d3e3ddc3039d761f215a807b3f5014fe95e85e)

Spoolside’s CLI tools for inspecting and operating the application.

### Reproduce the failure before proposing the fix

[4:57](https://www.youtube.com/watch?v=iRcX54EO5g8&t=297s)

Application access changes where debugging starts. An eager agent may immediately suggest adding a margin or inserting some code. Lajili wants it to **reproduce the bug before editing**. That establishes that the agent can reach the failing state and recognize the problem it is trying to solve.

An intuitive fix might still be right. But if the agent cannot inspect the result, a human must verify it. That burden limits how much work can be delegated and makes unattended overnight runs difficult to trust. Reproduction is a first step toward that trust, not evidence that overnight autonomy has already been achieved. Spoolside itself is not offered as a reusable GitHub project; the recommendation is to build equivalent access for your own application.

### Make verification part of the working environment

[5:48](https://www.youtube.com/watch?v=iRcX54EO5g8&t=348s)

This shifts some engineering effort from directly building the product to making the product easier for an agent to work on. Better tools are one part of that investment. A more navigable codebase and better knowledge bases also help the agent understand what to change and how to check it. The interface can be a CLI, a skill, or an MCP integration. Lajili chose a CLI for simplicity; the appropriate form depends on the application and the problem.

**More output is useful only if errors do not compound with it.** Lajili contrasts the product engineer of 2025 with a proposed role he calls the AIX engineer: someone who makes it possible for AI to build the product reliably. That includes making verification easy and presenting the agent's work so a human can review it.

![An arrow connects a 2025 Product Engineer box to a 2026 aiX Engineer box, above a line about building the product and making sure AI can build it.](https://ai.engineer/api/talk-essay-media/622bd81242b2712b2ad5f4066bdbb9b1ddfa25a79a3788f4264877e410caf68e)

From 2025 Product Engineer to 2026 aiX Engineer.

His analogy is the airline oxygen-mask instruction: equip the AI to help itself before asking it to work on more features. Building that capability may slow immediate feature delivery, but he expects the investment to pay off as more agents use the environment over longer periods.

### Where do exploratory checks meet committed tests?

[7:39](https://www.youtube.com/watch?v=iRcX54EO5g8&t=459s)

The audience asks where mechanical primitives such as screenshots and logs end and checked-in unit or integration tests begin. Should these checks be temporary, or should they become tests that always run?

Lajili describes his checks as fairly ephemeral and explicitly treats that as a personal preference. He sometimes finds automated tests too rigid and difficult to maintain, and favors tooling that lets the agent explore an application as a human tester would.

Consider a button that is visibly too far to the left. The immediate temptation is to tell the agent exactly what is wrong. Instead, Lajili steps back and asks what would let the agent discover the misplacement itself. The missing capability may be more consequential than the individual correction: once the agent can observe this class of problem, it needs less human intervention on subsequent tasks.

### Find missing commands in the agent's logs

[8:53](https://www.youtube.com/watch?v=iRcX54EO5g8&t=533s)

After several rounds of work, inspect the interaction history. Lajili suggests asking an AI to review past logs for recurring issues and repeated actions. Repeated `sleep(50)` calls are a useful signal: the agent may be compensating for a missing command that waits for a particular condition. Repeatedly starting [Storybook](https://storybook.js.org/docs/writing-tests) can similarly reveal a workflow worth packaging into a reusable operation.

The useful abstraction is a named readiness condition with a bounded wait. For example, this TypeScript helper lets an application-specific probe decide when an operation can continue:

```typescript
async function waitFor(
  description: string,
  isReady: () => Promise<boolean>,
  timeoutMs = 10_000,
): Promise<void> {
  const deadline = Date.now() + timeoutMs;

  while (Date.now() < deadline) {
    if (await isReady()) return;
    await new Promise<void>((resolve) => setTimeout(resolve, 100));
  }

  throw new Error(`Timed out waiting for ${description}`);
}
```

The short polling delay controls how often the probe runs; it does not decide whether the application is ready. A reply-wait command, for example, should proceed when the reply is available rather than after an arbitrary pause. This illustrates the missing-command pattern, without assuming a particular Spoolside API.

### Choose an interface that fits the product

[9:16](https://www.youtube.com/watch?v=iRcX54EO5g8&t=556s)

The right observation surface depends on what you are building. For a Unity game, Lajili proposes considering an **ASCII representation of the 3D world**: a representation the agent can inspect as it reasons about the environment. For an application with extensive permissions, it may need easy access to different logins so it can experience the product under different roles.

Those choices remain an engineering responsibility. A screenshot, a world representation, and a role-specific session expose different kinds of evidence. Build the access that lets the agent discover the failures your product can actually have.

## Resources

- [gstack browser skill](https://github.com/garrytan/gstack/blob/main/browse/SKILL.md.tmpl) — Browser commands for screenshots, accessibility snapshots, page interaction, and verification workflows.
- [Inside Poolside’s Model Factory](https://www.poolside.ai/blog/introducing-the-model-factory) — Poolside’s account of the infrastructure behind training, evaluating, and iterating on its foundation models.
- [Playwright auto-waiting](https://playwright.dev/docs/actionability) — How browser actions wait for visibility, stability, and other readiness conditions before proceeding.
- [Testing UIs with Storybook](https://storybook.js.org/docs/writing-tests) — Use component stories for interactive development and automated UI testing.

## Slides

### AI Engineer Europe

[0:00](https://www.youtube.com/watch?v=iRcX54EO5g8&t=0s) [AI Engineer Europe logo in white on black.](https://assets.ai.engineer/sites/aiecode2025/sha256/aab59c7da120f8504a96c9b8622254406bbff88706e2388a912d6dcc744c1118.webp)

AI Engineer
EUROPE

### Presenting sponsor

[0:05](https://www.youtube.com/watch?v=iRcX54EO5g8&t=5s) [Google DeepMind named as presenting sponsor.](https://assets.ai.engineer/sites/aiecode2025/sha256/22e8cb940ef752894fb0f47ce4cfbb7a04b212fd252bdf1347f3f5879fa393f3.webp)

PRESENTING SPONSOR
Google DeepMind

### Platinum sponsors

Braintrust, WorkOS and OpenAI are listed as platinum sponsors.

[0:10](https://www.youtube.com/watch?v=iRcX54EO5g8&t=10s) [Braintrust, WorkOS and OpenAI listed as platinum sponsors.](https://assets.ai.engineer/sites/aiecode2025/sha256/bf60df78dc08b4cf33596a9869479c299d38f75a91e3dc5bbf3171105af000ef.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### Your Agent Is Blindfolded

Johan Lajili introduces a talk on giving agents eyes to improve performance and trust, against a backdrop of widely different experiences using AI.

[0:36](https://www.youtube.com/watch?v=iRcX54EO5g8&t=36s) [Johan Lajili’s talk title and subtitle about giving agents eyes to improve performance and trust.](https://assets.ai.engineer/sites/aiecode2025/sha256/3e65c403d141745652a833fdbb48204942b4a5f7a447342288db0d613acc8f31.webp)

Your Agent Is Blindfolded

How giving it (good) eyes multiplies performance and trust

Johan Lajili
Member of Engineering (Full Stack) - Poolside - London

© COPYRIGHT 2025, POOLSIDE INC. ALL RIGHTS RESERVED.

AIE
Google DeepMind

### The Duality of Man

Two posts contrast AI coding experiences: one developer says they only review and ship, while another reports hallucinated imports, three broken services and a false passing claim in a monorepo.

[0:39](https://www.youtube.com/watch?v=iRcX54EO5g8&t=39s) [Two example posts contrast enthusiasm for AI coding with frustration over errors in a production codebase.](https://assets.ai.engineer/sites/aiecode2025/sha256/63fd4507ec57593f672b6055ac7cbc4ebc58ccc364ac303133559523054f8c37.webp)

/* THE DUALITY OF MAN */

r/ChatGPTCoding · Posted by u/mass_shipped_vibes
2.4k
I haven't written a line of code in 3 months. Cursor + Claude does everything. I just review and ship. This is the future and I'm never going back.
847 comments

vs.

r/ExperiencedDevs · Posted by u/legacy_code_survivor
1.8k
Genuinely curious what codebase these people are working on. I tried Claude on our monorepo and it hallucinated half the imports, broke 3 services, then told me everything was passing. AI coding tools are a mass delusion for anything beyond todo apps.
1.2k comments

© COPYRIGHT 2025, POOLSIDE INC. ALL RIGHTS RESERVED.

Interface text:
AIE
Google DeepMind

[1:06](https://www.youtube.com/watch?v=iRcX54EO5g8&t=66s) [Two example posts contrast enthusiasm for AI coding with frustration over errors in a production codebase.](https://assets.ai.engineer/sites/aiecode2025/sha256/082d19a2d77c3fe5febec393f208f55051077653c723aea7f41d43b5bcafb616.webp)

/* THE DUALITY OF MAN */

r/ChatGPTCoding · Posted by u/mass_shipped_vibes
2.4k
I haven't written a line of code in 3 months. Cursor + Claude does everything. I just review and ship. This is the future and I'm never going back.
847 comments

vs.

r/ExperiencedDevs · Posted by u/legacy_code_survivor
1.8k
Genuinely curious what codebase these people are working on. I tried Claude on our monorepo and it hallucinated half the imports, broke 3 services, then told me everything was passing. AI coding tools are a mass delusion for anything beyond todo apps.
1.2k comments

© COPYRIGHT 2025, POOLSIDE INC. ALL RIGHTS RESERVED.

Interface text:
AIE
Braintrust
WorkOS
OpenAI

### Interpreting an agent’s claim

An agent’s claim that an OAuth flow works reflects what it can assess with the capabilities it has been given. It may or may not have verified the work; a skeptic may hear the same claim as evidence of dishonesty or incompetence.

[2:47](https://www.youtube.com/watch?v=iRcX54EO5g8&t=167s) [A claim that an OAuth flow works is contrasted with the agent's qualified assessment and a skeptic's interpretation.](https://assets.ai.engineer/sites/aiecode2025/sha256/554ff1727721e3a744e172991bfeae3cd23f257f48804787911fcba3e973934c.webp)

“I've implemented the new OAuth flow, it's all working”

/* WHAT IT MEANT */
To the best of the capabilities you have given me, this sounds like it would work.

/* WHAT A SKEPTIC SEES */
I'm a liar. And/or incompetent. You cannot trust me.

Interface text:
AIE
Engineering the future of AI

[3:34](https://www.youtube.com/watch?v=iRcX54EO5g8&t=214s) [A claimed working OAuth flow is contrasted with what the agent means and what a skeptic may hear.](https://assets.ai.engineer/sites/aiecode2025/sha256/6fb06c48bc13e694bf02df2ac7a9953c8f091565b691582e07d87b6db70acab1.webp)

“I've implemented the new OAuth flow, it's all working”

/* WHAT IT MEANT */
To the best of the capabilities you have given me, this sounds like it would work.

/* WHAT A SKEPTIC SEES */
I'm a liar. And/or incompetent. You cannot trust me.

Interface text:
AIE
AI Engineer EUROPE

### Spoolside: tools for testing the running app

Spoolside gives agents snapshots, screenshots, logs and controls for Poolside’s VS Code extension. The speaker urges teams to build tools specific to their own products.

[3:44](https://www.youtube.com/watch?v=iRcX54EO5g8&t=224s) [A list of Spoolside capabilities, including snapshots, screenshots, interaction, logs and service controls, encourages teams to build product-specific tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/5a9dae212c451ede3894b7ed931d181170d1f4448034226f0ddd225561d60c99.webp)

Our CLI at Poolside: Spoolside
Giving the agent eyes into the running app

Extract text & element snapshots
Interact with components by ref
Restart services locally
High-level: "Open settings menu"
Screenshots — page or component
Trace DOM → Svelte components
Extract logs — backend, helper, FE
"Change feature flag", "Seed DB"

But the point is not our tools, it’s yours
Make tools to interact with your product specific to your product.

© COPYRIGHT 2025, POOLSIDE INC. ALL RIGHTS RESERVED.

AIE
AI Engineer EUROPE

### Product Engineer to aiX Engineer

The speaker predicts a shift toward aiX engineers who equip AI to build and make its work easy to verify, so faster output does not compound errors.

[6:23](https://www.youtube.com/watch?v=iRcX54EO5g8&t=383s) [A 2025 product engineer diagram points toward a shift from building the product to making sure AI can build it, followed by thanks.](https://assets.ai.engineer/sites/aiecode2025/sha256/be62ae83c9887c66cd9520572307506980278a06f64b2159e5e5bf57588fd182.webp)

2025
Product Engineer →

Building the product < Making sure the AI can build the product

Thanks.

© COPYRIGHT 2025, POOLSIDE INC. ALL RIGHTS RESERVED.

AIE
AI Engineer

[7:09](https://www.youtube.com/watch?v=iRcX54EO5g8&t=429s) [A 2025 Product Engineer card points to a 2026 aiX Engineer card. A caption contrasts building the product with making sure AI can build it.](https://assets.ai.engineer/sites/aiecode2025/sha256/6b9aaee024816a1e62e75909889db751346788649bc63db64f77760bafa33dc8.webp)

2025
Product Engineer →

2026
aiX Engineer

Building the product < Making sure the AI can build the product

Thanks.

© COPYRIGHT 2025, POOLSIDE INC. ALL RIGHTS RESERVED.

AIE
Braintrust
WorkOS
OpenAI
AI Engineer

## Full transcript

[0:00](https://www.youtube.com/watch?v=iRcX54EO5g8&t=0s) [upbeat music] Um, hi everyone.

[0:16](https://www.youtube.com/watch?v=iRcX54EO5g8&t=16s) So I'm Johan, uh, from Poolside. Uh, if you haven't heard of us, so we are one of the handful of companies, uh, that are making their own, uh, foundational model from scratch, uh, their own, uh, LLM, uh, and coding agents.

[0:31](https://www.youtube.com/watch?v=iRcX54EO5g8&t=31s) Uh, check us out if you're, if you're not aware of some cool stuff and, and you should hear more soon. Um, but what I want to talk to about today, uh, is this: you have people seeing AI and using AI and getting vastly different experiences.

[0:48](https://www.youtube.com/watch?v=iRcX54EO5g8&t=48s) If you're on Reddit, if you're on Twitter, you're going to see people that say, "Oh, yeah, I'm, I'm never, like, touching code anymore. The AI is the, is doing everything for me.

[0:56](https://www.youtube.com/watch?v=iRcX54EO5g8&t=56s) It's fantastic." Uh, and others that say, "What are you talking about? I'm trying it in my production app. Uh, it produces absolute garbage. Uh, what are you guys working on to-do apps?

[1:07](https://www.youtube.com/watch?v=iRcX54EO5g8&t=67s) Uh, what are you doing?" And there is multiple ways to try to, to understand what's going on there. One way is to say, "Oh, this guy is a shill from OpenAI trying to sell you AI," uh, or, "This one is an empty that doesn't care about anything, and he's just, like, lying.

[1:23](https://www.youtube.com/watch?v=iRcX54EO5g8&t=83s) He, he didn't even try it." Another, um, is to say, well, maybe someone is working on a greenfield app, and that's nice and easy. Uh, whereas someone else is working on brownfield, on a legacy application.

[1:36](https://www.youtube.com/watch?v=iRcX54EO5g8&t=96s) That's complicated and agents are not there yet. But personally, I think that doesn't quite hold up. Um, we've seen people using AI in legacy applications with good success. I have myself, so at least on my own experience, I know, uh, that can work.

[1:54](https://www.youtube.com/watch?v=iRcX54EO5g8&t=114s) So what's the difference? What's, uh, the difference really between, um, brownfield and greenfield? The difference is that with greenfield, the agent's intuition is correct. The agent's writing the code and expect, you know, if I write the components here, if I write the service, it's gonna work.

[2:12](https://www.youtube.com/watch?v=iRcX54EO5g8&t=132s) I, I, I think that's gonna be fine. Uh, and he's right 'cause it has very good intuition. Uh, on brownfield, however, uh, there be dragons. Uh, you're gonna have things that the agent is not expecting.

[2:24](https://www.youtube.com/watch?v=iRcX54EO5g8&t=144s) Um, maybe, you know, like dead-ends code that's not used anymore. Uh, thing that it's not aware of in, in different part of the code that it hasn't even looked at.

[2:33](https://www.youtube.com/watch?v=iRcX54EO5g8&t=153s) And that's where the big difference between those two is the feedback loop. And everybody has sort of like somewhat talked about it in, in, in the background of the talks we've seen over the past three days, um, but I think that's the difference with getting this result.

[2:48](https://www.youtube.com/watch?v=iRcX54EO5g8&t=168s) So you've, you've got your agent that says, "Yeah, I've implemented the new workflow, and it's all working perfectly." What the agent means really is, well, to the best of the capa- of my capabilities, to the best of what you have given me, that sounds like it should work.

[3:05](https://www.youtube.com/watch?v=iRcX54EO5g8&t=185s) Maybe the agent was able to verify its work, maybe it wasn't. But as far as it knows, it's working. If you're a skeptic of AI, you're gonna see that first quote, see that it's indeed not working and just says, you know, "I'm a liar, I'm incompetent," or like, "You cannot trust the AI."

[3:25](https://www.youtube.com/watch?v=iRcX54EO5g8&t=205s) Uh, and that's, I think, where this cleavage in between those two type of users. Like, the first category is going to see some things. "Oh, yeah, actually, you know what?

[3:34](https://www.youtube.com/watch?v=iRcX54EO5g8&t=214s) It's not working, agent. Uh, can you try again? Check those logs or whatever." Uh, whereas those ones are just going to give up. But I think we can make this still better.

[3:44](https://www.youtube.com/watch?v=iRcX54EO5g8&t=224s) Um, at Poolside, uh, I've created a little CLI tool called Spoolside. Yeah. Um, might be good at programming and not good at naming things. Um, that basically allows it, uh, to test our applications effectively.

[3:59](https://www.youtube.com/watch?v=iRcX54EO5g8&t=239s) Some of the stuff you've already seen, uh, in things like gstack, for instance, being able to take screenshots of the applications, uh, being able to take a snapshot, uh, that is to say like a very token-compressed, uh, version of, of what's going on, on a webpage and use it.

[4:14](https://www.youtube.com/watch?v=iRcX54EO5g8&t=254s) But our application is not a webpage. It's an extension within VS Code. So already, like, it takes an extra step to get there. Um, but with that, our AI can interface with it just like it would with a normal webpage.

[4:29](https://www.youtube.com/watch?v=iRcX54EO5g8&t=269s) But we take it further. Uh, we have thing to extract logs from different services, from the backend, from the frontend, ways to restart different services. Uh, high-level commands. Can you access a specific menu?

[4:42](https://www.youtube.com/watch?v=iRcX54EO5g8&t=282s) Can you go to this page? Can you send a message to the agent, wait for it to reply, send another message, upload an image and do that, and it can stack things, uh, like somewhat efficiently, um, a bit like we've talked with, uh, coding tools, uh, this morning.

[4:57](https://www.youtube.com/watch?v=iRcX54EO5g8&t=297s) Um, and that's pretty useful 'cause then the agent is able to test what it's doing. If it's working on a bug, it can actually reproduce the bug before it starts working on that, on that.

[5:10](https://www.youtube.com/watch?v=iRcX54EO5g8&t=310s) The agents are very eager, "Yeah, I, I know what's going on. You just need a margin there. You just need to go and add this code." But until it reproduces the bug, uh, uh, I don't trust you.

[5:21](https://www.youtube.com/watch?v=iRcX54EO5g8&t=321s) And that's the big thing. It's maybe without that, the agent is able to still have good intuition and fix the issues, but I don't trust it, and then I'm gonna have to go and verify it myself, and I'm wasting time, and I cannot then take that agent and start running it overnight, for instance.

[5:37](https://www.youtube.com/watch?v=iRcX54EO5g8&t=337s) Uh, this is a first step to trust. And the point of this is not, um, Spoolside. It's not something you're gonna find on GitHub to use for yourself. It's to build your own.

[5:48](https://www.youtube.com/watch?v=iRcX54EO5g8&t=348s) I think as engineers- Um, that's our new role. Uh, we are going to have to focus less on the product and more on trying to make the AI work on the product.

[6:02](https://www.youtube.com/watch?v=iRcX54EO5g8&t=362s) How can we make it easy for it? Uh, that can be those tools, that can be improving the code base so that it's easier to work on, that can be improving knowledge bases.

[6:12](https://www.youtube.com/watch?v=iRcX54EO5g8&t=372s) Uh, you can implement this as a CLI, as a skill, as an MCP. In, in my case, it's a CLI 'cause I like things simple. But, like, there are many different variations of it, and I think it's going to be different from people to people and problem to problem.

[6:24](https://www.youtube.com/watch?v=iRcX54EO5g8&t=384s) But yeah, I think in, uh, 2025, we had product engineers, uh, that were, you know, like, very focused on doing everything with the product. But now that AI is getting quite good, you want to focus more on making sure that that velocity is not a trap, that you're not going to multiply errors, uh, or compound errors, that

[6:48](https://www.youtube.com/watch?v=iRcX54EO5g8&t=408s) you're going to actually verify what you're doing, making it easy for you to, to verify as well with, like, presenting the work that the AI done and everything around that.

[6:58](https://www.youtube.com/watch?v=iRcX54EO5g8&t=418s) And so I think we're all going to become AIX engineers, uh, essentially. And yeah, it's a bit like when you're in an airline, uh, and they say, "Oh, you put your mask on yourself before you feed...

[7:12](https://www.youtube.com/watch?v=iRcX54EO5g8&t=432s) You, you put your, your mask on, on your children." It's the same with AI. You need to put the mask on the AI. You need to make sure that it's self-served before you try to work on features.

[7:20](https://www.youtube.com/watch?v=iRcX54EO5g8&t=440s) Even if it slows you down right now, it's an investment, uh, that pays off as soon as you start multiplying agents, uh, and running things over time. And that's me done with two minutes to spare.

[7:33](https://www.youtube.com/watch?v=iRcX54EO5g8&t=453s) So thank you very much. Uh, any question from anybody?

[7:38](https://www.youtube.com/watch?v=iRcX54EO5g8&t=458s) Yes.

[7:39](https://www.youtube.com/watch?v=iRcX54EO5g8&t=459s) Thanks for the talk. Um, when you're thinking about what to put in the CLI, it sounds like you have a bunch of base primitives. For example, screenshots, logs, et cetera.

[7:48](https://www.youtube.com/watch?v=iRcX54EO5g8&t=468s) Um, where do you draw the line? Or what's your mental model for building those mechanical primitives versus putting together, like, checking in, for example, unit tests or integration tests?

[8:00](https://www.youtube.com/watch?v=iRcX54EO5g8&t=480s) Like, how ephemeral are these things relative to actually, at limit, like, checking them in and always running them?

[8:07](https://www.youtube.com/watch?v=iRcX54EO5g8&t=487s) I, I, I think they're quite ephemeral in the sense... A- and that, I guess, is a personal preference, but I do feel like automated test can be sometimes a bit too rigid and hard to predict and hard to, like, work over time.

[8:21](https://www.youtube.com/watch?v=iRcX54EO5g8&t=501s) So I like something that mimics the way I would test it, like a human would go and test the application. The way, uh, I find those is, um, in the first stage where I work with the AI, um, I don't.

[8:34](https://www.youtube.com/watch?v=iRcX54EO5g8&t=514s) Even though, you know, like, I can see that the button is a bit m- to the left, and I want to tell the AI that, what I want is the AI to realize that by itself.

[8:43](https://www.youtube.com/watch?v=iRcX54EO5g8&t=523s) So whenever I encounter that sort of problem, I take a step back and try to think on how to make the AI realize the problem by itself. Uh, another thing is retroactive loop.

[8:53](https://www.youtube.com/watch?v=iRcX54EO5g8&t=533s) Uh, after you've done that many times, look past over your logs, ask an AI, "Oh, did you notice any issues? Any, like, um, um, anything where you're doing sleep, for instance."

[9:03](https://www.youtube.com/watch?v=iRcX54EO5g8&t=543s) Calling sleep (50) everywhere is a thing that, like, there is something that should be wait for whatever, like a command that could be there. Uh, is there anything that you keep doing over and over, like running Storybook?

[9:16](https://www.youtube.com/watch?v=iRcX54EO5g8&t=556s) Um, and another thing is really think about, like, your own product. If you're making, say, a, a game in Unity, like, uh, do you want an ASCII representation of y- of your 3D world in, uh, for, for your AI?

[9:30](https://www.youtube.com/watch?v=iRcX54EO5g8&t=570s) If you're making something with lots of permissions, uh, different logins that your AI can take very easily. It's, it's really on your role to think about all that. That's what I think anyway.

[9:39](https://www.youtube.com/watch?v=iRcX54EO5g8&t=579s) And I think we're out of time. Thank you very much. [outro music]
