When an agent writes the code, the diff is only half the artifact. The other half is the session that produced it.
Traditional code review assumes the diff carries the intent. A human wrote every line, so the reasoning is embedded in the changes, and the PR description fills the gaps. Agent-written code breaks that assumption. The real record of intent, the instructions the author gave, the corrections they made mid-stream, the tradeoffs the agent surfaced and how they were resolved, lives in the session transcript. Review the diff alone and you are auditing an answer without seeing the question.
We rebuilt our review flow around this. Every PR in Tembo links back to the agent session that generated it. When a PR lands on my desk, I can open the session and see exactly what my teammate asked for, what the agent pushed back on, and where the human intervened. Better still, if I have a question about a design choice, I do not have to interrupt anyone. I ask the session itself. The same context that wrote the code answers questions about the code. The transcript stops being exhaust and becomes the review's primary source, which is one more reason sessions are replacing tasks, runs, and threads as the unit engineering teams actually work in.
This matters because agent-assisted teams are about to drown in pull requests. Generation is no longer the constraint, and every team that speeds up its merge rate discovers the volume just grows to fill the capacity. I have argued before that code review becomes the bottleneck, and the only way through is to make each review radically cheaper. Session-linked review does exactly that: the reviewer inherits the full context instead of reconstructing it.
The structural implication is that planning, building, and reviewing can no longer live in three disconnected tools. The plan links to the session, the session links to the PR, and the review interrogates all three. Teams that keep these artifacts scattered will pay a reconstruction tax on every single merge. Teams that connect them will review faster than their agents can write, and that is the position you want to be in.
Key takeaways
- A pull request written by an agent is incomplete evidence, because the intent and corrections live in the session that generated it.
- Linking every PR to its originating agent session lets reviewers see what the author asked for and interrogate the code directly.
- As agent-generated PR volume grows, planning, building, and reviewing need to converge into one connected surface.
FAQ
Why is the diff not enough when reviewing agent-written code?
Because the diff shows what changed, not why. With agent-generated code, the reasoning, constraints, and course corrections live in the session transcript. Without it, reviewers are reconstructing intent from scratch on every PR.
What does session-linked review look like in practice?
Every PR carries a link to the agent session that produced it. A reviewer can read the instructions the author gave, see how the agent responded, and ask that same session follow-up questions about the code before approving.
Related Essays
Code Review Becomes the Bottleneck
When an agent ships a working PR every six minutes, you accumulate reviewable code faster than humans can process. The next wall is review, not generation.
Review Needs a Computer, Not a Diff
Agents have made code generation cheap and review the bottleneck. The fix is giving every reviewer a live machine with the change already running, not a diff in a browser tab.
The Algorithm Should Be Inspectable
Trust is the bottleneck for agent adoption, not capability. Hide the logic in a prompt and people stop using it. Make it inspectable code and they iterate with you.
Drowning in pull requests that need your review? Try Tembo Review, a beautiful AI-assisted PR review tool unlike anything you’ve used.