The AI Didn't Ship It. You Did.

A while back I shipped a couple of features that quietly violated my own architecture.

They worked. They passed review — my review. Entities ended up living inside services that had no business owning them, boundaries I'd been careful about for months got stepped over in a few hundred lines, and I clicked merge on all of it. Weeks later the shape of the system had gotten muddy enough that I spent two days pulling those responsibilities back where they belonged.

The code was written by an AI agent. So whose mistake was that?

The internet has a ready answer, and I think the internet is wrong.

The agent did exactly what I asked

Here's the uncomfortable part. The agent didn't malfunction. It was asked to add a feature, and it added the feature — in the most direct way available, which happened to be inside a service that already had the plumbing.

The rule it broke — every entity owns its own service; nothing hitchhikes — was real, load-bearing, and had governed the whole design. It was also living exclusively inside my head. It wasn't in a document. It wasn't in the brief. It wasn't in any file the agent could read.

An unwritten rule doesn't exist. Not for an agent, not for a new hire, not for you in six months. The agent didn't break my architecture; it revealed that my architecture was partly folklore.

Delegation moves the work, not the responsibility

The moment I approved that pull request, the code became mine. Not "mine to fix" — mine. My name is on the merge, my system carries the consequence, my two days paid for it.

That's not humility, it's just how authority works. An agent executes with your credentials, in your repository, under your review, toward goals you set. When something bad reaches production through that path, "the AI made a mistake" is not a conclusion. It's the first line of the post-mortem, and if it's also the last line, what you've actually published is a confession that you had no review process.

So the honest version of my story isn't the AI crossed my boundaries. It's: I approved code that crossed my boundaries, because I'd never written the boundaries down.

We have always blamed the tool

None of this is new. It just got a fresh scapegoat.

We blamed the compiler. We blamed the framework. We blamed the offshore team, the contractor, the intern, the previous developer who left. "Works on my machine" was accountability laundering long before anyone had an AI agent. Every generation of tooling gets a phase where it absorbs the blame for decisions humans made, and every generation eventually rediscovers the same thing: the tool operates inside your system of gates, or inside your lack of one.

What's genuinely new is only the speed. A tool that produces more code per hour also produces more consequences per hour, which means a weak review process gets found out faster than it used to. That feels like the tool causing problems. It's the tool revealing them.

Both loud camps are missing receipts

There's a symmetry worth noticing.

One camp posts that they're 10x now, 100x, unstoppable — extrapolating from a demo that worked. The other camp posts that it's all collapsing — extrapolating from a rewrite that slipped, a project that died, a team that had to intervene and do more review.

Here's the thing: delays, rework, and human intervention are not evidence of failure. They're a description of software. Projects have always slipped. Rewrites have always taken longer than promised. Reviewers have always had to send things back. Judging AI against a fantasy of deterministic, first-try, rework-free delivery is judging it against a standard no human team has ever met either.

Software isn't Lego blocks snapping into a predetermined shape. It's a growing organism. It changes as it meets the world, and the changing is not the disease — it's the growth. My two-day refactor wasn't proof that AI doesn't work. By that logic it was proof that I don't work.

Both camps are doing the same thing: broadcasting vibes with no ledger. What I've got instead is a ledger — a bad approval that cost two days, a duplicate post I had to delete, and a set of guards that now exist because of both.

The smaller, faster version

That second one is worth telling, because the loop was tighter.

While building the automation that publishes this blog, my pipeline posted the same article to LinkedIn twice. The cause was mine again: a file reorganization made every existing post look brand new to the detection logic, so it re-announced one. I deleted the duplicate by hand, added two independent guards, and verified them by replaying the exact commit range that had broken it.

Same shape as the architecture story, one day instead of two weeks. Something automated did precisely what it was told; the thing it was told was insufficient; a human owned the gap and closed it.

What I actually changed

Not "trust the agent less." That's the reflex, and it's the wrong lesson — the failure wasn't excessive autonomy, it was an unstated standard.

I wrote the rule down. Every entity owns its own service; nothing hitchhikes. It's now stated explicitly in the instructions for every task, because I learned the expensive way that an agent inherits your authority but not your standards — those you have to say out loud.

And that generalizes past AI entirely. If a rule matters and lives only in your head, your team is one onboarding away from the same two days.

Tie yourself to the mast

Someone recently made the Ulysses argument at me: bind yourself to the mast before your enthusiasm embarrasses you.

I like the metaphor, and I think it argues the opposite of what it's usually deployed to argue. Odysseus didn't plug his own ears — the wax went to the crew. He tied himself to the mast precisely so he could hear the sirens and survive it. The rope wasn't abstinence. It was the constraint that made the experience safe.

That's what a pull request is. That's what a build gate is, and a review, and automation that fails loudly instead of silently. Ropes, not earplugs. The mast doesn't exist so you avoid the thing — it exists so you can go near it without wrecking the ship.

So blame the agent if you like. But notice what that admits: that your contribution was the typing, and the typing is the part that was always going to be automated. The engineers who come out of this well won't be the ones who avoided AI mistakes. They'll be the ones whose systems catch mistakes, own them, and turn them into two regression guards and a written-down rule. ✨