It Took Me 3 Months to Trust AI Enough to Let It Write My Code
For the first 3 months of working with AI, I was deeply sceptical. The best models at the time were producing what I can only describe as AI slop. Rudimentary at best. The generated code showed no real thinking, no coherent architecture, no awareness of the broader system it was being asked to slot into. My trust was low, so I kept AI in its lane: repetitive tasks, low-risk areas, nothing I couldn't afford to throw away.
Then Claude Opus 4.5 shipped. Something changed.
For the first time, I started seeing glimpses of critical thinking emerging from the model. I noticed it pushing back, reframing problems, working through tension in its own reasoning before landing on an answer. The output quality jumped noticeably, and with it, so did my trust.
But the move to having it write code entirely didn't happen overnight. It was gradual, methodical, and measurable. I had to learn how the model behaved. I had to build guardrails. I had to fundamentally rethink how I design solutions.
Designing for a Machine, Not a Human
Here's what most people miss. Designing for an AI agent is nothing like designing for a human.
Human developers pick up auxiliary context from the environment around them. The codebase, the culture, the unspoken conventions that accumulate over years of working on a system. Agents don't. They need everything made explicit. Deliberate. Direct.
I had to build an architecture suitable for a machine, not a human. That meant being far more precise about context, constraints, and intent than I had ever needed to be when working with human developers. When I got that right, the output shocked me.
Writing good code stopped being about my ability to type. It became about my ability to articulate — the feature, the context, the environment, the constraints. That shift has fundamentally changed how I think about design and testability. If you can't articulate it clearly enough for an agent to execute it correctly, the problem is almost always in the articulation, not the agent.
The Last 3 Months: A Different World
The last 3 months have been a different world entirely. I now benchmark models as they drop against my own architecture. I measure how well they capture nuance from within the codebase. I evaluate whether they can hold the thread of the system across complex tasks.
Claude Opus 4.6 dropped recently, a 0.1 version increment on paper, but a 5x leap in coding quality in practice. It started catching edge cases in my codebase that earlier models walked straight past. That's not a small thing. That's the difference between a tool you supervise and a collaborator you trust.
Vibe Coding vs Agent-Led Coding
There's a distinction that matters enormously right now, and I don't see it talked about enough.
Vibe coding is opening an AI tool, describing what you want, accepting what comes out, and shipping it. It feels fast. It feels like the future. It's a trap. You've outsourced not just the typing, but the thinking, and you won't know what that costs you until something breaks in production. You can't debug code you don't understand. You can't maintain a system you didn't design.
Agent-led coding is showing up as the director. You define the architecture. You set the constraints. You guide the agent deliberately and review every output with a critical eye. The AI writes the code. You own it.
This requires deep technical knowledge to do well. You need to know when the agent is right, when it's confidently wrong, and when it's making a subtle design decision that will haunt you in six months. That kind of judgment doesn't come from prompting. It comes from years of building, breaking, and fixing software.
What This Means for Developers
This skill is no longer optional. The developers who thrive won't be the ones who resist AI, they'll be the ones who master directing it. The role is shifting from writing code to owning the outcome, and that requires more expertise, not less.
What This Means for Decision Makers
AI agents are powerful, but they amplify strong technical people; they don't replace them. If you think you can skip the experienced developer and just "use AI," you're not cutting costs. You're accumulating risk you can't see yet. The agent will build what you describe. You need someone who knows what to describe, what to watch for, and what to push back on.
Where We Are
Developers are not dead. Far from it. They're at the core of these systems, directing them, augmenting them with human intuition, and taking ownership of the output in a way that no AI can replicate.
3 months of scepticism. 3 months of agentic coding. And I'm only just getting started.
The question isn't whether AI will change how software gets built. It already has. The question is whether you're directing it, or just along for the ride.
In upcoming posts, I'll break down exactly how I design for agents, how I write guardrails, and how I benchmark models against my own architecture. If you want the details, follow along and feel free to reach out with questions. I'd love to hear where you are in your own journey with this.