AI as a Pair Programmer, Not a Replacement
The most useful way I've found to work with AI isn't "write my app for me." It's treating it like a fast, tireless pair programmer who's brilliant at the boring parts and needs supervision on the parts that matter.
What it's genuinely good at
When I built Yarplus, the parts that would have eaten my time weren't the interesting ones. They were the migrations, the form validation, the fortieth CRUD endpoint, the test scaffolding, the "translate this shape into that shape" glue. That's exactly where AI shines.
Used well, it lets me stay at the altitude where I actually add value — architecture, business logic, and UX — instead of drowning in boilerplate. A few patterns that consistently pay off:
- Boilerplate generation. Scaffolding a module, wiring up a route, generating a DTO from a schema. Mechanical work it does in seconds.
- Rubber-ducking. Explaining a problem out loud to something that talks back surfaces my own wrong assumptions before I write a line.
- Unfamiliar terrain. A first-pass explanation of an API or a language feature I haven't used, which I then verify against the real docs.
- Mechanical refactors. "Rename this concept everywhere," "convert these callbacks to async/await." Tedious, low-risk, high-toil.
Where it falls short — every time
The failures are predictable, and knowing them is what makes the tool safe to use.
It doesn't hold your system in its head
An AI sees the snippet you give it, not the three other services that share the same database, not the invariant you established two weeks ago. It will happily suggest something locally correct and globally wrong. Architecture is still mine to own.
It's confidently wrong about the subtle stuff
The dangerous bugs aren't syntax errors — those don't compile. They're the off-by-one in a billing calculation, the missing await that only fails under load, the auth check that looks right and isn't. AI produces these with total confidence, which is precisely why you can't outsource judgment to it.
Security can't be delegated
On a payment system, "looks plausible" is not a security model. I review anything touching auth, money, or user data line by line. The AI is a draftsman here, never the approver.
The faster the AI writes, the more important it is that I read. Velocity without review is just shipping bugs sooner.
The workflow that actually works for me
- I decide the design. Boundaries, data model, and the contract between components are mine. I don't ask the AI what to build, only to help build what I've decided.
- I scope tasks tightly. "Write this one function with this signature" beats "build the payments module." Small, verifiable units.
- I read every line. If I can't explain why a generated line is there, it doesn't get committed.
- I let tests be the referee. Generated code earns trust by passing tests I understand, not by looking right.
The honest takeaway
AI made me meaningfully faster — but only because I treat it as an accelerator on top of skills I already have, not a substitute for them. It's leverage. And leverage multiplies whatever you point it at: good judgment gets amplified, and so do bad habits. The engineer still has to be the engineer.