Agent-written code does something weird to my brain. I ask for a change, wait a minute, and suddenly I have types, tests, helper functions, and names that look reasonable enough to merge. Because the diff arrived so quickly, part of me treats it like borrowed code. I can review it, get the tests green, and move on without ever building the same mental map I would have built while writing it.
That speed is obviously useful, which is why I keep using these tools. They are great when I want to see the rough shape of an idea or get through a boring first pass. Six months later the code is simply code in the repo, though. Nobody cares that an assistant produced the first version when a helper starts doing five jobs or a tiny change takes an hour because the abstraction was wrong. If my name is on the commit, that future annoyance belongs to me.
Git records an author and a committer. It does not record that I reviewed the change at 1 AM, wanted dinner, and decided the extremely confident function name probably meant the function knew what it was doing. By the time something breaks, the chat is gone and the useful context has evaporated. Debugging starts with my name, the commit message, and whatever explanation survived in the code. Saying “the agent wrote it” might be true, but it is not going to help me fix production.
Writing a helper by hand used to force me through the shape of it. Now a helper like this can materialize in one shot:
function normalizeUserAccess(user, workspace, featureFlags) {
// many lines of very confident looking code
}The compiler may be happy and the tests may pass while the abstraction is still a bad fit for the project. Before merging, I ask myself where I would start if this breaks later. When I cannot answer that without reopening the agent transcript, I do not understand the change yet. That is usually my cue to rename things, flatten the helper, add the missing test, or just write the small part myself.
I keep prompts while I work because they are useful evidence. They show what I asked for, what I forgot to mention, and which wrong direction looked plausible at the time. I still refuse to make a chat transcript required reading for a function. The code, tests, and commit message have to explain the result because prompts are messy by design. Mine contain half-formed requirements, failed attempts, and sentences written while I was discovering what I wanted. Any code that only makes sense beside that mess needs another pass.
My review is mostly the same one I would give my own code, with extra suspicion around shape and repeated work. I check bad input, retries, partial failure, old data, and calls that happen twice after the network drops. Agents tend to handle the sunny path well enough. The strange states are where the confidence gets less comforting. I also watch for a ten-line request returning a small private framework, complete with interfaces and factories that nobody asked for. Maybe it is brilliant. Usually I needed a plain function.
A couple of questions help me cut through the tidy diff. Can I delete the helper without dragging half the codebase with it? Could I replace it with a boring function later? Does this change make the project easier for me to explain, or did it mostly add ceremony? Generated code is cheap, so I can ask for another version, shrink it, or throw it away and keep the useful test case. The slightly wasteful feeling lasts five minutes. Understanding the code saves much more time when it eventually behaves badly, and sadly no assistant can maintain that mental model inside my head for me.