The AI wrote it. But you still own it.

Last week I opened a pull request I mostly didn't write. An agent wrote most of it. The code was clean. Good names, matched our style, tests passed. I read it, changed a few things, and sent it out. A teammate reviewed it and approved it. My name is on that PR.

If it had broken production at 2am, nobody would blame the model. And nobody would really blame the teammate who approved it. They would look at who wrote it. That's me.

I've been thinking about this a lot. The more I work with coding agents, the more I notice a quiet idea creeping in: if the AI wrote it, it feels less like mine. I think that's backwards. My ownership didn't get smaller. It got bigger, and heavier.

The easy trap

The trap is simple to fall into. The code shows up faster than I could type it. It reads well. It usually runs. So it starts to feel like the agent is the author, and I'm just the person who clicked approve.

But "the AI wrote it" only says who typed the code. It doesn't say who is responsible for it. Those were always two different things. If I copy a function a teammate wrote, I can't say "someone else wrote that part" when it breaks. Once it's in my PR, it's mine. The agent doesn't change that. It just makes it easier to forget.

What the agent can't see

Here is why ownership goes up, not down. The agent is missing the context that makes code correct in your system.

It writes a database query that is valid SQL, but forgets that every table in our product is multi-tenant. So it misses a tenant check that isn't visible in the file it's editing. It writes a delete that looks fine, but would wipe out related rows too, because it doesn't know those rows are supposed to stay. It picks a library we chose not to use, because the team hit a problem with it last year and made a call the agent never saw.

None of this makes the agent dumb. These are decisions that live in people's heads and old Slack threads. The agent writes code that is correct on its own. Whether it's correct for your company is a different question. Only someone who knows the system can answer it. Right now, that's you. You can hand off the typing. You can't hand off knowing why your system works the way it does.

Two AIs agreeing is not ownership

The obvious fix is: let the AI review it too. And you should. A second agent often catches what the first one missed. I use this every day.

But two models agreeing is not the same as someone being responsible. If both agents miss the tenant check, neither one cares when it leaks. Neither one sits in the postmortem. Neither one fixes it, or explains it to the customer, or remembers it next time. And the agent gives you wrong code in the same confident voice it uses for right code. That calm tone is dangerous if you let it replace your own judgment.

What ownership looks like now

So the work changed. Less of my day is spent writing lines. More of it is spent on the parts I can't hand off: Does this fit how we build things here? What happens at the edges? What breaks later? Can we live with this failure? Tuning the output until it fits our system is not rubber-stamping. That's most of the job now.

That's not less responsibility. It's more. Code flows past me faster than ever, and every line still needs a human who will put their name on it. The volume went up. The judgment went up with it. The only thing that didn't grow is the number of people accountable when it breaks. That number is still one per PR.

The line I keep coming back to

You can't write "the AI did it" in a postmortem. There's no box for that. There's a box for what happened, a box for what we'll fix, and one person who owns both.

So use the agents. Let them write. Let them review. Let them take the boring 80% and give you your afternoons back. I do. But before you put your name on it, read it like you wrote it, because to everyone downstream, you did. The code got cheaper. The ownership got more expensive. Pretending otherwise is how things break at 2am.