AI is part of how I build now. Not as an autopilot I hand the wheel to — as a fast, tireless pair that clears the boilerplate so I can spend my attention on the parts that actually need judgment. The phrase "in the loop" is the important bit: I'm always in it.
Here's the loop I run most days:
idea ──▶ AI drafts ──▶ I review & shape ──▶ ship
▲ │
└──────── refine ◀─────┘The AI produces a first pass fast; I react to something concrete instead of a blank file; we iterate; I make the calls. Reacting to a draft is almost always quicker than starting cold — and a draft surfaces the questions I should be asking sooner.
Where it helps most
The wins are real, but they cluster around work that's mechanical, repetitive, or easy to verify — exactly where I don't need to spend my best thinking:
- Scaffolding — components, hooks, tests, types. The shape is obvious; typing it out is just toil.
- Refactors across many files — renames, prop changes, extracting a pattern. Tedious and error-prone by hand, quick to review when batched.
- First drafts — turning a rough idea into something running I can react to.
- The stuff I'd otherwise put off — edge-case tests, error states, a11y attributes, JSDoc.
A typical example — I describe a small utility, it writes the obvious version, and I keep or adjust it:
// AI handles the boilerplate; I keep the decisions.
export function useDebouncedValue<T>(value: T, delay = 300) {
const [debounced, setDebounced] = useState(value)
useEffect(() => {
const id = setTimeout(() => setDebounced(value), delay)
return () => clearTimeout(id)
}, [value, delay])
return debounced
}Thirty seconds instead of three minutes, and my focus never left the actual feature.
Where I stay in control
This is the half that makes the difference. AI is great at plausible; it's indifferent to right. So the decisions stay with me:
- Architecture — how things fit together, what the data flow is, where the boundaries sit.
- Naming & API design — the things future-me and teammates live with.
- UX and anything user-facing — copy, states, motion, the feel.
- Security & correctness — I read every diff. "Looks done" isn't done.
The goal is leverage, not abdication. If I can't explain why a piece of code is there, it doesn't ship.
How I keep the quality bar
A few habits keep AI from quietly lowering the standard:
- Small steps. Smaller asks = smaller, reviewable diffs = fewer surprises.
- Review like it's a teammate's PR. Read it, question it, test it.
- Tests as the contract. If the behavior matters, it gets a test — written or at least verified by me.
- Taste is non-negotiable. I'd rather ship a smaller, sharper thing than a bigger, generic one.
What it changed
Less time on the boring 80%, more on the 20% that's actually hard and actually mine. The output looks the same to a visitor — it's just that I got there faster and with more attention left for the details that make it good. That's the whole point of keeping a human in the loop.