i ship more code now than i did two years ago. but i write less of it. that math sounds great in a tweet. it hides the real story.
the part nobody tells you about working with ai agents is that the bottleneck shifts. the writing gets faster. the verification gets harder. and if you don't build the verification side of the loop with the same care you used to build the writing side, you end up shipping more bugs faster than you can debug them.
this is what i actually do.
the velocity illusion
here's the marketing pitch: ai writes code 10x faster than you can. ship more features. move fast.
here's what actually happens. ai writes code 10x faster. you read code at the same speed you always did. tests run at the same speed they always did. debugging takes the same time it always did. the only thing that got faster is the part that was already cheap.
so unless you change the rest of the loop, ai gives you a stack of code you can't keep up with. it's like hiring a junior engineer who can write 100 lines of code per minute and never asks questions. that's not a productivity gain. that's a problem you'll be debugging at midnight.
the engineers winning with ai aren't the ones who type prompts the fastest. they're the ones who built the verification scaffolding before they let the agent loose.
what i actually delegate
i have a clear rule for what goes to the agent and what stays with me.
ai gets:
- boilerplate i could write in my sleep but takes time (crud endpoints, simple migrations, repetitive test fixtures)
- code that has obvious correctness criteria (typed in, typed out, tests pass)
- translations between languages or frameworks where the semantics are well-defined
- the first draft of anything with a clear shape (a parser, a small client, a basic component)
- documentation, especially the parts that just describe what the code does
- exploratory scaffolding for ideas i want to try in 20 minutes
ai never gets:
- decisions about architecture or data model
- code that touches money, auth, or pii
- anything where the failure mode is silent corruption
- the second draft, after i know what i want
- prompts where i'm not sure what "correct" looks like
the dividing line is whether i can verify the output without re-reading every line. if yes, the agent can do it. if no, i do it myself.
the verification scaffolding
ai agents are useful in proportion to how cheap your verification is.
if you have:
- a typed language with strict mode
- a fast test suite that runs in seconds
- formatters and linters on save
- pre-commit hooks that catch the dumb stuff
- one-command local environments
- structured logs so you can see what actually happened
then an ai agent can write code, you can verify it in 30 seconds, and the velocity gain is real.
if you have:
- dynamic types
- a slow or flaky test suite
- no linting
- five-minute ci cycles
- "works on my machine" environments
- console.log debugging
then ai will hand you broken code, you'll spend 10 minutes finding the break, 30 minutes fixing it, and another hour wondering why the agent thought that was correct. you would have been faster writing it yourself.
the foundation is what makes ai useful. without the foundation, ai is a force multiplier for chaos.
the dumb mistakes i had to learn to avoid
i lost real time learning these the hard way.
accepting code i didn't read. if i can't summarize what each function does in one sentence, i don't merge it. the agent doesn't understand my codebase. it understands its training set, which only sometimes overlaps.
delegating problems i hadn't thought through. if i can't write the function signature myself, i can't tell whether the agent's signature is right. when i prompt without a clear spec, i get a confidently wrong answer that wastes my afternoon.
trusting tests the agent wrote for code the agent wrote. the agent doesn't know what should be true. it knows what's likely to be true. those are different. tests have to come from me, or from a real bug, or from an actual user complaint.
asking for too much in one prompt. "build me a stripe integration" gets me a 600-line file i can't review. "write a function that takes a stripe price id and returns the active subscription state, handling these four edge cases" gets me 30 lines i can read and ship.
believing the agent's confidence. the failure mode of llms is plausibility, not correctness. if it sounds right, that's not evidence it's right. it's only evidence that it's well-formed.
where the leverage actually lives
the place ai has changed my engineering life isn't in writing code. it's in three other places.
reading code. if i hit a 5,000-line file in a library i've never seen, i can paste it into a model and ask "what does the X function do, and what depends on it". in 30 seconds i have the lay of the land. that used to take me an hour of jumping through definitions.
naming things. i can describe what a function does and ask for five name options. i pick the one that fits the file. naming used to be a 10-minute aesthetic block. now it's a 30-second multiple choice.
finding what i don't know. the most underrated use of ai for an engineer is "what should i be considering that i'm not?". i paste a design or a problem and ask the model to roleplay as a senior engineer reviewing it. half the suggestions are useless. the other half catch real issues i didn't think of.
none of those are the marketing pitch for ai. none of them involve writing more code. they all happen before the code, when i'm trying to understand the problem instead of solve it.
the part i'm still figuring out
i don't know yet how to use ai for the parts of engineering that matter most. taste. judgment. knowing when to delete a feature. knowing when a ux pattern is fundamentally wrong. knowing when an architecture is going to bite us in six months.
the agent is good at "what would an engineer typically do here?". it's bad at "what should we do that no one else has thought of yet?". those are different problems and i haven't found a way to use ai for the second one. i'm not sure there is one.
so for now, the rule is simple. ai handles the parts i could explain to a smart intern in five minutes. i handle the parts i couldn't explain to anyone yet.
the new bottleneck
the trade i didn't see coming: the bottleneck used to be typing speed. now it's deciding speed. i used to spend most of my day in the editor. now i spend most of my day in the design notebook, the whiteboard, and the spec doc. the actual code happens in the gaps between decisions.
i don't think this is bad. i think it's the right thing. the part of engineering that's interesting was always the deciding part. the typing was just the cost. ai didn't make engineering easier. it made it more honest. if you have nothing to decide, you have nothing to ship. and if you have a lot to decide, you have a lot of company in the form of an agent that types faster than you do.
that's the actual deal. ai doesn't write your code for you. it writes the code you would have written, faster, if you knew what to write. when you don't, it writes confident garbage. the work is in knowing which is which.