AI is now a normal part of software development. Engineers use it to complete simple tasks, explore hard problems, review code, and write documentation. Engineering leaders use it to brainstorm, create guidelines, and improve how teams work.

But AI also creates a new problem: some people try to transfer responsibility from themselves to the tool.

I recently saw a code comment that said something like:

I think Claude decided to do it this way because X. So, perhaps, in this case it's justified.

This is not a useful explanation. The pull request was submitted by an engineer, so the decision belongs to that engineer, not Claude.

You own the result

I do not think engineers need to disclose every time they use AI. When a pull request comes from your account, you own the code, the design, and the consequences.

Before asking another person to review AI-assisted code, you should understand what you are trying to achieve. You should know that the proposed solution is conceptually correct and belongs in the right part of the codebase.

Then review the code yourself, using another AI model / agent, skill, or whatever you want. You must answer the questions you and it finds and fix important issues before sending the work to another human.

The review standard should remain the same. Good code is good code, no matter how it was produced.

Do not let the agent lead you

AI agents learn from the code they can see. They often copy existing patterns, including bad patterns from legacy code. They may also introduce abstractions and complexity that the task does not need.

A human must guide the agent towards a better solution.

This is one form of AI slop: code that may work but adds complexity, repeats old mistakes, or sits in the wrong place.

Respect the reviewer’s attention

Attention is one of the most expensive resources in an engineering team.

When you submit poorly prepared work, reviewers must rebuild the context, understand the problem, inspect a solution, and solve the task again in their heads.

AI saved time for the author by moving the cost to other people. This is not only a code quality issue, but also a matter of professional etiquette and organizational culture.

Before submitting work, ask yourself how you would feel if you received it. Is the goal clear? Can the reviewer understand the main choices? Will they know why this solution was selected instead of another one?

A good pull request should make the reviewer’s job easier. Use AI to summarize the changes, simplify complex explanations, collect the main arguments, and compare the chosen solution with alternatives.

A good phrase I found on the internet recently:

If you are requesting human attention, demonstrate human effort.

Accountability is not optional

When someone says, “the AI decided this,” remind them that they are accountable, not the tool.

If the behavior continues, it becomes a management issue. Repeated refusal to own submitted work should be treated as a performance problem.

AI changes how we produce software, but not who is responsible for the result. Use it to improve your work, not to outsource responsibility.