Antoine Lehurt

A year ago, I started delegating most of my coding to AI agents. The longer I worked that way, the less confident I felt in what I shipped.

The features I’d built by hand years ago, I could still trace end to end: the data flows, the edge cases, why we’d picked one approach over another. But anything new, anything where the agent did the building and I did the reviewing, felt different. I’d planned thoroughly, researched with the agent, and approved every line. My mental model felt thinner than it used to be.

I kept asking myself why I trusted what I shipped when I wrote the code myself. It was what coding left behind: a map of how everything connected. The product, the domain, the system I was building inside of.

For most of my career, coding was how I built that map. Every choice I made while writing code added to it. Fitting a new feature into the existing architecture, keeping things maintainable, leaving the code in better shape than I found it. None of those choices were free. Each one cost attention, and that attention became understanding. I couldn’t shape something I didn’t grasp.

I’ve always shared the map with others. Every engineer does. The colleague who owns the payments service has their own map of that territory, worn in over months of working in the code. When they tell me how it really behaves (not how the docs say it does), I’m borrowing a piece of theirs to fill a gap in mine.

AI agents offer something that feels similar. I describe what I want, the agent produces something close to what I would’ve written. But the agent’s map is disposable, built from scratch every session and thrown away at the end. It doesn’t know where the gaps are.

Some things I can hand off without losing much. The boilerplate, the patterns I’ve written a hundred times. I can read those and know what I’m looking at. But the domain, the business logic, the shape of the system. An agent I don’t fully trust can’t give me that.

I used to go deep into the foundations of our systems, beyond the feature I was building, down to the code it sat on top of. That’s how I learned to trust what I shipped.

Maybe the answer is building the map earlier. I’ve started planning differently with the agent. More than the feature details. The architecture, the boundaries, how everything connects. In unfamiliar territory, I dive into the code myself first. By the time the agent writes code, I know the territory. I still review what it produces, but that’s not where I expect to catch gaps anymore.

I’m still iterating on the process. But I need the map before I can trust what I’m building.