Software developers like to talk about responsibility when the stakes are low.

We care about code review. We care about tests. We care about production incidents, postmortems, ownership, security, observability, backwards compatibility, and all the other rituals that make software engineering more than just typing instructions into a machine.

Then an AI model enters the room and suddenly some people act like responsibility has been outsourced.

The model said this was fine.

Claude suggested it.

GPT told me this API behaved that way.

The AI said the migration was safe.

That is not an explanation. It is not a defense. It is not even particularly interesting. It is the software equivalent of saying, “I copied it from Stack Overflow,” except worse, because at least Stack Overflow usually has another human being, a timestamp, comments, votes, and some visible social context around the answer.

An AI model is not a person. It is not a colleague. It is not a senior engineer. It is not accountable. It does not understand consequences. It does not get paged. It does not sit in the incident review. It does not have professional judgment, legal liability, reputation, fatigue, embarrassment, or skin in the game.

It emits text.

Sometimes that text is useful. Sometimes it is excellent. Sometimes it is subtly wrong in exactly the way that passes a casual review. Sometimes it confidently invents facts, APIs, edge cases, package names, citations, or security properties. This is not a moral failure by the model. It is just what the system is: a probabilistic tool that generates plausible continuations under constraints.

The responsibility remains with the developer.

Tools Do Not Own Decisions

No serious engineer says:

My compiler allowed it, so the design must be correct.

No serious engineer says:

My IDE autocomplete inserted this line, so I trusted it.

No serious engineer says:

The linter passed, so the system is secure.

No serious engineer says:

The benchmark looked good on my laptop, so production will be fine.

These tools inform decisions. They do not make decisions.

AI is the same category of thing: a tool. A powerful tool, but still a tool. It can accelerate exploration, suggest designs, draft code, find patterns, summarize unfamiliar systems, and generate test cases. But the moment its output becomes part of your codebase, your documentation, your migration plan, your security posture, or your production system, it is your work.

Not the model’s.

Yours.

AI Can Be Useful Without Being Trusted

There is a difference between using AI and trusting AI.

Using AI well looks like this:

• “Generate three possible approaches; I will compare them.”
• “Find suspicious code paths; I will inspect them.”
• “Draft a test suite; I will run and improve it.”
• “Explain this unfamiliar module; I will verify against the source.”
• “Suggest a migration plan; I will validate it with real constraints.”

Trusting AI blindly looks like this:

• “It said the function was unused, so I deleted it.”
• “It said this dependency was safe, so I added it.”
• “It said the query was indexed, so I shipped it.”
• “It said this auth flow was secure, so I merged it.”
• “It said there were no breaking changes, so I released it.”

The first mode is engineering. The second is negligence with a chatbot in the loop.

So when you say, “the model told me to,” what you are really saying is:

I allowed a tool to substitute for my judgment.

That should be embarrassing.

The model did not merge the pull request.

You did.