Last summer, I wrote about the risk of using AI to generate code you do not understand. I still believe that risk is real. I also use the tools much more now.

The models became more reliable, their context improved, and the tools around them became useful enough for daily work. The failures did not disappear. The cost of managing them became low enough that the trade started to make sense.

At work, we built an agent that turns selected Jira tickets into pull requests:

flowchart TD
    A["Jira ticket assigned to agent"] --> B["Agent implements the change"]
    B --> C["Agent opens a pull request"]
    C --> D["Human reviews the code"]
    D -->|Approved| E["Human merges"]
    D -->|Changes needed| F["Human or agent revises"]
    F --> C

We started with small bug fixes, copy changes, and other work with clear boundaries.

One rule makes this tolerable:

Whoever merges AI-generated code owns it.

The reviewer is responsible for understanding what the code does, how it fits into the system, and what happens when it breaks. The review is the point where a person must rebuild the context that the agent skipped.

This works reasonably well for our current team because we already know the codebase. We can notice when a small change violates an assumption that exists somewhere else.

I am less sure how this works for newer developers.

Junior developers often build context through small tickets. They write the code, make mistakes, debug the result, and learn why the system works the way it does. If an agent handles those tickets, code review may not provide the same experience. Reading a clean diff is different from struggling through the implementation.

The answer may be to limit agent use until someone has enough context to review its work. It may also mean creating other ways for developers to build that context. I do not think we know yet.

There is also a practical ceiling. At some level of complexity, reviewing and reconstructing an agent’s work costs more than writing the code yourself. We are still trying to find that line.

My original concern has not changed. AI creates another abstraction over the code, and that abstraction will leak. The useful change is that we now have a clearer rule for who deals with the leak.