The Review Pane Is Theater

We handed AI agents commit access and kept a code review process built for humans. It is theater now, and most teams know it and approve anyway.

I did not work that out from a whiteboard. I worked it out making music.

I produce music under the name RCRSN . Last week I put out two videos, Saudade and Golden Haze, off an EP called Slow Gold. I made them to test one thing: how easy is this now?

The sound: rap grit over hazy lounge-jazz, tablas underneath, a Brazilian funk swing carrying it. Golden-hour music. Saudade and marigold.

I made the videos the way I made the music. Alone, in Cowork, prompting AI tools until the frames stitched into something that looked like a real shoot. A few hours each. No crew, no set, no budget.

They came out good. They live on my Instagram, under rcrsn music. That was the whole release.

I expected easy. I didn't expect what it quietly deleted.

The hard part was always making the thing. Booking the room, owning the gear, being the one person who could. That just got cheap. What's left is taste: knowing whether the thing is any good.

Here is what nobody tells you about cheap. When something floods, it loses more than its price. It loses its thrill. A skill everyone suddenly has is a skill nobody is impressed by. Whatever becomes abundant, dulls. But the worth doesn't vanish. It moves. The moment a thing goes from rare to everywhere, value jumps to whatever sits beside it that is still scarce. Copies are free now. What can't be copied is the only thing left worth paying for.

I watched it happen to my music in a night. Software is watching it happen to code.

For seventy years, writing software was the expensive part. Then the machines learned to do it. Databricks just crossed the line where agents write more code on its platform than people do. Infinite code, on tap. And we did something strange with the flood: we ran it straight into a process built for a trickle.

Here is how software still ships. Someone writes code, opens a pull request. A second person opens the review pane, reads the diff, decides whether to trust it. That ritual was built for one situation: a human wrote this, and another human has to understand it before it goes live.

That situation is gone. The ritual isn't.

An agent writes two thousand lines before your coffee is cold. You can't read two thousand lines with the care they need, so you skim, you scroll, you approve. The queue is long and the agent sounds certain. The review pane, the thing meant to keep bad code out, has become a rubber stamp. We are pretending to review work no one is reading.

The old escape hatch is gone too. When a person wrote something confusing, you could pull them aside, ask why, watch their face. An agent hands you a confident reason on the spot, invented whole, no flicker of doubt. The confidence is free. The doubt is yours.

So here is the flag I will plant. The pull request and the review pane are relics. We strapped a jet engine to a horse-drawn carriage and act surprised it is shaking apart. The whole lifecycle rests on one assumption: that making code is the hard, scarce step. That is now false, and everything downstream is breaking in slow motion.

The fix is not a better diff viewer. It is the move manufacturing made a century ago: you do not inspect quality in at the end of the line. By then there is too much of it and it is too late. You build the checking into the line itself, upstream, until bad output never gets far enough to catch.

For software, that flips the lifecycle on its head. Verification stops being the last gate before merge and becomes the spine. The review pane stops being a wall of diff you pretend to read and becomes something you actually trust: tests you would bet money on, properties the code cannot violate, provenance you can trace, checks that return in seconds instead of a queue that rots for three days. The merge gate becomes the real decision, and what stands there is a check you believe, not a tired human skimming for green.

That rewrites the best job in engineering. The senior engineer's value used to be I read your code. It is becoming I built the gate that decides what ships. You stop reading the output and start building the thing that reads it for you, at a scale no human can match.

I have spent this year rebuilding my team's pipeline around exactly this. Less writing, more deciding. Fewer people staring at diffs, more judgment baked into the gates, so the diffs mostly check themselves. It is unglamorous, and it is the whole game.

Which brings me back to Slow Gold.

Each took a night, and the night was never the valuable part. I used to think it was. The value was the ear that knew which take was golden hour and which was just noise. Same ear, different room. In a world of infinite code, the rare thing was never the code. It is the judgment that knows which of it to believe.

Generation got cheap. Taste did not. That is the best news a builder has had in years.

So make more golden things. Just remember it was always the gold, never the making, that was the point.