I recently chatted with a Distinguished Engineer about how he uses agents in his engineering workflow and how he builds new team processes around AI-generated work.
During the conversation, David Fowler made a really poignant take: when producing code becomes trivial, human attention becomes scarce resource. 🤯
You can listen to our full conversation on Spotify. (It's a recording of a Twitter Space I did with him. People have said they really enjoyed the spaces I run, so I saved them as lightly edited podcast episodes).
See below for my own thoughts on code review in the world of agentic coding:
My own thoughts
For decades, software engineering has relied on a foundational necessity: a reliable paper trail. As version control matured from changelogs to CVS to modern Git diffs, we built our craft around durable artifacts that preserve intent, track progress, and safeguard quality.
Historically, this system worked because software development operated at human speed. An engineer reasoned through a problem, committed code, and opened a pull request. Colleagues reviewed that code, engaging in a back-and-forth dialogue to unpack the underlying logic. We deliberately used this collaborative friction to maintain code quality.
But today, a new class of autonomous collaborators has disrupted the traditional engineering workflow.
Coding agents have drastically compressed the implementation window from typing code line-by-line to writing a single prompt that generates a full feature. The most forward facing teams are already moving past single-agent execution, orchestrating parallel sessions where a main agent manages subagents to complete larger bodies of work on demand. (When I worked at Block, this became the way many teams I encountered worked).
This sudden leap in speed is intoxicating, but it threatens to outrun our ability to keep software trustworthy. In practice, an engineer uses an agent to generate hundreds of lines, but the engineer only skims the results. Reviewers facing a growing backlog do the same. If the Git diff looks right, the team ships. Then a production outage occurs. In the past, you could bring the authoring engineer into the incident room to trace their logic and patch the system. But when the decision was made by one of a dozen subagents running in parallel, there is no one to bring in, and the commit history shows only the result, not the reasoning.
This is the central problem I keep seeing in AI-native development: we can now produce code faster than we can understand it. And yet, for an industry obsessed with artifacts, meticulously tracking commits, pull requests, and logs, we often throw away the one record that explains all of them: the agent session itself.
The company I work at, Entire, has been aiming to maintain velocity without sacrificing engineering integrity by preserving agent sessions alongside the tools developers already use. The full chain of AI-assisted work, including prompts, responses, tool calls, subagent activity, checkpoints, and the final commit, can all become part of the engineering context. The mechanics do not have to be heavy. We do this using lightweight hooks around the agent and Git workflow.
But the purpose of capturing session history is not for users to simply reread a diary of logs and transcripts. (A lot of people tell me, "So what, I don't want to read the logs!") Instead, session history can become an active surface for understanding, unlocking capabilities that standard Git diffs simply cannot support.
When an engineer or agent needs to understand a complex block of autonomous code, the investigation should not stop at a timestamp, a commit hash, or a best guess. I want to be able to ask why this implementation exists, what prompt produced it, which agent or subagent touched it, and what validation or review context shaped the final result.
If we want to build at this new speed without losing our grip on the codebase, a static diff of the final code is no longer enough. When the system breaks at 2:00 AM, we cannot rely only on tools built for a human pace to audit agent-to-human collaboration. To keep our systems reliable, we have to preserve more of the actual narrative of how the software came to be.
Because in an AI-native world, the session is the story.
Check us out on entire.io !
And check out this episode of a crazy time I was on an AI coding game show for CodeTV . I look back at this episode many times, and just think "Ugh, we should've used Entire. It would've made handing off work between my team so much easier."
Top comments (0)