How I Actually Work With AI Coding Agents

There's a version of "coding with AI" that lives in demo videos: someone types one sentence, a full app appears, everyone claps. That's not how the real work goes. After months of building actual projects this way, my process looks a lot less magical, and a lot more reliable.

Here's the loop I actually use.

Start with intent, not instructions

The biggest mistake I see is treating an agent like a search box. You type a task, hope for the best, and react to whatever comes out.

Instead, I start by writing down intent: what I'm building, why, and the constraints that matter. Something like:

I'm adding a dark mode toggle to a static site. It must persist across page loads, respect the system preference on first visit, and not cause a flash of the wrong theme. No new dependencies.

That paragraph does more work than any clever prompt trick. The agent now knows the goal and the guardrails, so its first attempt lands in the right neighborhood instead of three neighborhoods over.

Work in tight, verifiable steps

I never ask for the whole feature in one shot. I break it down and verify each piece before moving on:

1. Get the theme state read/written correctly.
2. Wire the toggle button.
3. Handle the first-visit / no-flash case.
4. Style both themes.

Each step ends with me actually looking at the result: reading the diff, running it, checking the edge case. The point isn't distrust for its own sake. It's that small verified steps compound, while one giant unverified leap tends to collapse.

Read every diff

This is the habit that separates "AI wrote my bug" from "AI helped me ship." I read every change before accepting it. Not to nitpick style, but to catch the confident mistakes.

AI is a genuinely strong collaborator and a fluent liar in the same breath. It will happily invent an API that doesn't exist, delete a line that mattered, or "fix" a test by weakening it. None of that survives a careful read of the diff.

// Looks reasonable. But is `crypto.randomUUID` available in
// every environment this ships to? That's a diff-review question,
// not a "looks fine, accept" question.
const id = crypto.randomUUID();

Know when to take the keyboard back

Agents are fantastic at breadth: scaffolding, boilerplate, translating between formats, exploring an unfamiliar API. They're weaker at the load-bearing 5%: the tricky invariant, the subtle race condition, the thing where being almost right is worse than useless.

When I hit that 5%, I stop delegating and write it myself, then hand the result back for tests and cleanup. Using AI well means knowing which parts to keep.

The loop, in one line

Set clear intent → work in small steps → verify each one → read every diff → own the hard parts.

It's not glamorous. It ships.

This is the approach behind every project written up on this site. If you want to see it applied end to end, the next few articles walk through real builds, including the one that made this very blog.