Something breaks. You ask who wrote this part. The answer, weightless: "Oh, the agent wrote it."
And it's dropped as if it ends the investigation. The agent wrote it — meaning it's no one's fault. And it really is no one's fault: the agent can't take the blame, and the person who merged it just shrugged it off. Accountability evaporated right in front of you. That isn't an answer to the question — it is the problem, spoken aloud.
01An agent can't carry responsibility — so someone must
Accountability isn't a label stuck on for show. It's the anchor that holds quality: the accountable person is the one who'll bear the consequence if it's wrong, so they're the one with reason to look closely.
The agent has no such anchor. It bears no consequence when its code brings something down at midnight. It doesn't remember the mistake to avoid it next time — by morning it's forgotten. It loses no reputation, no sleep, learns nothing. Assigning responsibility to an agent is as meaningless as assigning it to the keyboard: both are just tools that turn a person's intent into text.
So responsibility can't sit with the agent. It has to sit with a human — and the only sensible human is the one who decided to bring that code in: the person who hits merge. The turn is here: "who wrote it" is the wrong question. The right one is "who's putting their name on it" — and the answer can never be "the machine."
02Signs a review is just rubber-stamping
When the machine writes fast and a lot, a very natural temptation appears: review quickly to keep up. And a quick review is just a stamp. The signs below tell you the team's review is sliding into ritual:
What they share: every one is a review trusting the <i>account</i> instead of the <i>evidence</i>. And what the agent writes is brilliant at producing easy-on-the-ear accounts — so this is exactly where the bar must rise, not fall.
03Keep the review bar rising, not falling
The paradox to swallow: the machine writing more doesn't mean review gets lighter — it's the reverse. The more code that comes from something that can't answer for it, the heavier the burden of "a real person puts their name on it" must be, not lighter. A few rules to hold that bar:
Hitting merge means accepting: "I answer for this as if I wrote it by hand." No "the agent wrote it" exception. The anchor of accountability must have a human on the other end.
A five-hundred-line diff is a diff no one truly reads. Make the agent ship in pieces reviewable in one sitting — what's readable is what gets read.
Don't waste effort on syntax — the agent types correct syntax. Scrutinize where it slips: did it grasp the intent, did it quietly touch elsewhere, does the test it wrote actually check what needs checking.
Notice all three shift the review's focus from "is the code clean" to "is someone answering for it, and does it do the thing it's meant to." Reviewing agent-written code isn't catching typos — it's confirming that a human genuinely understood and stands behind what's about to enter the system.
04Orphaned code is nameless debt
A piece of code no one truly owns is nameless debt in the system: when it breaks, no one feels they have to understand it, because "no one wrote it." It sits there until it blows, and then the whole team scrambles to trace something no one ever read closely.
Hold one line: the agent writes, but the merger owns. This is a review that doesn't rubber-stamp at team scale, and the team version of the habit of demanding evidence instead of trusting "done". The machine's writing speed is real and welcome — but it's only a bargain as long as every line entering the system has a human behind it, ready to say "this one's on me." Drop that anchor and you don't speed up — you just pile on debt faster.