As many engineers know, LLM assisted coding was largely a time sink up until January of 2026. Since then the way we write code has changed drastically. Engineers have gone from implementing code by hand to overseeing the implementation of code by an agent. Code reviews are now getting reviewed by LLM bots and deployments are being tracked by agents with access to production logs.
This is a significant change.
When we decide to deploy code, someone has to own the change and take responsibility for the impact it creates. Typically this is the engineer who is creating the code change. A second layer of responsibility is extended to the engineers reviewing the code. In the past it has been customary to get code reviews from other engineers but this tradition is being pressure tested by the large volume of code agents can create in a short period of time.
The mental energy for an engineer to review code has remained the same while the volume of code change continues to increase. It would be great to give AI code an AI review and say it is good to go but in reality a real human has to take responsibility for the change.
What does an engineer do when faced with reviewing a code change that spans 50 to 100 files and thousands of lines of code? In my experience, I see a new pull request mentioned in chat, open it up, see it is huge, and say I’ll come back to it when I have time. I imagine many others do the same.
I would wager this creates a pattern where only those who are truly required to support the change do the code review.
This pattern prevents tribal knowledge from surfacing. In hand written code bases this could have serious negative impacts. In an AI code base it’s possible the impact is smaller, but I don’t think the knowledge disappears. It relocates. The context that used to live in a reviewer’s head gets built into the code and the agent’s context from the ground up. Memory files, house rules, evals. The catch is someone still has to author that context, and usually that only happens after getting burned once.
What does the engineer faced with 100 files changed do when they are actually required to give approval by a deadline? My initial instinct is to take the change for a test drive. Knowing how the application should behave and the intent of the change is a powerful tool in the validation of agentic code changes.
Let AI catch the bugs in the code and read massive diffs. Let humans analyze the intent and validate results.
As agentic engineering advances I wonder what the future of code review will look like. Do we expect AI code review to become good enough to allow for a production deploy without a human gating approval?
I think the gate actually represents two requirements:
- validating the code
- validating the intent of change
- Do we need this?
- Is this the right thing to build?
- Did the change actually do the thing we intended?
I bet in the near future we will allow AI to provide code quality approval while a human review of intent will still be required. The intent approval is how humans will take ownership.
Cheers
Will