On watching code fly by
These days I'm watching a lot of code fly by. This can take the form of scrolling through diffs of pull request or seeing code flash by in Claude Code. When people talk about seeing code this way, they tend to be speaking dismissively, but it's an underrated way of reading code.
My argument is simple: I find myself perceiving quite a lot as it "flies by," and sometimes this gives me the information I need to stop or reorient the agent. So, for example, I might notice:
- Logic that should be, but is not, encapsulated;
- The system doing a full scan when it should be querying against an index;
- Imports that introduce dependencies I don't want;
- "Fixing" a problem by deleting something important;
- Locating a problem where it almost certainly isn't.
Trained code-readers can see these and many more problems almost instantaneously. Think about how quickly you can read road signs; imagine you change a TV channel to a broadcast of your favorite sport or hobby, and how much you pick up near-instantly. Again, I'm reminded of athletic performance or performance in online poker, where a window would pop to the front of your screen and you had to get as much information as you could from it in a fraction of a second.
The current terminal tools are quite good at showing relevant code changes, given how new they are: I think the Gemini CLI is best at this, but Claude does well also. I also expect that we'll see massive improvement in how our tools present information to us. I'd love, for example, to have a window with a navigable stack of code changes, with all the Claudes feeding diffs into the stack.1
I'm still a great fan of reading code slowly and carefully, and there are cases where I merge code I've never read (because tests pass, because I trust CI, or because the AI is very good at that kind of code). But don't dismiss the idea of meaningful processing of "code flying by." We do this kind of processing on status reports, homework assignments, stock listings, and so on; it's also a legitimate, and increasingly important, way to read code.
Note that you can imagine this as a paradigm of much smaller pull requests and a different model of actually integrating diffs into a repository. I'm eager to see more work on this from people who know more than I do about this part of the tooling.↩