Shift left far enough and the loop collapses

It is interesting — and not surprising — to see so many companies building new version control right now.

GitLab shipped Agentic Code Review: it looks at every merge request with the full context of the repo, the pipeline, and your security policies, at a flat quarter-dollar a review. Epic Games open-sourced Lore, a from-scratch, content-addressed VCS. And underneath the headlines there is a crop of smaller projects that store the prompts and reasoning behind a change rather than the diff.

The reason for all this is simple: GitHub isn't serving us anymore. The abstractions it built on top of Git, and the affordances that came with them, are no longer the right ones for how we actually build software.

You can see it in the open source developers who increasingly say something like: don't send me your AI slop — send me your prompt and I'll run it myself. And I can see it in my own work. Every single side project I've started this year, I have effectively no knowledge of the code. So code review — the supposed linchpin of all of this — no longer serves any need I have.

At work it is the same. The less we look at and care about the actual code, the less code review is the right artifact. So what is?

The loop collapses

I don't have good language for this yet, so let me try it out loud.

We've all been told to shift left. But if you shift left inside a loop, you eventually collapse the loop.

Here's the version that made it click for me. The first time I heard about agentic code review, my reaction was: oh — so you build a skill that does the review. You push a PR, the skill runs, you get a good review, and now you don't need a human to do it. And then immediately: but why wouldn't I run that skill while I write the code? And if it runs while I write the code, why push for review at all? Push, and the review is just… gone.

That implosion feels real. But notice it only implodes one layer.

There is another layer that, at least for now, does not collapse (although it contracts): I still have to get the intent out of my head and into the system. It used to be that I had to at least type the code. In any larger context I also had to talk to people, write something down, specify it, argue about it. Now I mostly just have to get it out of my head.

So what replaces code review?

I think I already said it. There is still a place where the idea leaves my head and enters the software that runs. If the artifact to the right — the code, the docs — is no longer something I actively care about, then I shift left again, to where the idea comes out of my head. That's the artifact now.

And it isn't the code. It's the integrated package: the agent that ran, the prompt I gave it, the system context it had, the tools it used.

What's interesting is that this is a massive compaction in many cases. The agent can do so much from a description so much smaller, which means intent is far cheaper to review than code ever was. And that takes us in some genuinely different directions.

In the small: just talk

For a small team, or something brand new, I picture us sitting around a table riffing on ideas while the conversation is recorded — and an agent listening in, suggesting it sounds like you want me to build this, with us saying yes to some and no to others. Because the work is then an outcome of the ongoing conversation, it is, naturally and obviously, the thing we intended to build. There's nothing left to "review" — you were there.

In the large: you can't all sit at the table

In an organization of a few thousand people, that doesn't work. So what are the options?

One thing to name first: a Claude Code session is extraordinarily powerful and extraordinarily lonely. I think that loneliness has quietly revived the idea that the brilliant asshole is someone we can tolerate again. We can't. It's a dead end, and I suspect we'll rediscover that fairly soon.

The equivalent of sitting around the table is having that conversation with an agent in public — an openclaw-type-thing in a Slack channel, empowered with the tools and access to actually make changes. You drag the interaction between a human getting their intent out and the agent enacting it into a space where everyone can watch and join. Yes, in any large org you still can't see everything that's going on — there is just too much going on — so you still have to prioritize what you pay attention to. That part is still very much the job.

The other option is to make every agent conversation aimed at building software be an artifact of software delivery. If I start a coding session, then my prompts, my tools, and my system setup should all be the reviewable thing. We started sharing source code the moment we had something as good as Git, and never looked back. We're now just adding the stuff that actually matters. Think of the source as two layers: the code that enacts the intent, and the prompts-system-tools layer that embodies the intent. The second one is the layer worth capturing. If you can't picture it, just imagine blowing up the size of a pull request description until it contains the entire session that produced it.

And then the loop closes again

Push it one more step. If a large company is still doing code review, it's probably tagging in the "right people" — the ones who know an area, a system, a technology, the way we've chosen to do something. But if that's why they review, the collapse I described lands on them too. They won't review for long. The central teams guarding the central parts are already drowning in more and larger review requests, so they're writing skills to avoid doing the work by hand. And the moment those skills exist, the same question returns: why don't we just run them during development?

I already said the skills should be part of the artifact. So now you can build something rather elegant: a system that evaluates each skill by how much human interaction was still needed at the end of a code change — because a skill that was supposed to cover some technology clearly didn't fully do its job if a human had to step in.

That's a new loop. Not a loop around the code, but around the system that makes the agents — given a sensible prompt — build the right software, in the right way, of the right kind.

We've shifted everything we do left. And, I think, up.