Your Code Review Process Is Already Obsolete — Here’s What 405 Silicon Valley Developers Just Realized

Last Monday night, 405 people crammed into a San Francisco office to watch 20 developers break their own tools. No slides. No company pitches. Just raw demos. And the thing that nobody said out loud — but everyone felt — was this: The way we build software has already flipped, and most of you haven’t noticed.

WorkOS founder Michael Grinich kicked off the night by rebuilding the one tool he hates most: LinkedIn’s messaging interface. Fifteen thousand lines of TypeScript. Nine hundred tests. All written by Claude. He read zero lines. He wrote it poolside over Memorial Day weekend. Two years ago, that would have been a flex. Last Monday, the room just nodded. It was normal.

That’s the moment I realized we’ve passed a threshold. The question is no longer ‘Can AI write code?’ It’s ‘What happens to the team when it does?’

Matt from ref.tools started his demo with a show of hands: ‘How many of you use AI agents to write planning documents?’ Lots of hands. ‘How many of you share that plan with your teammates?’ Far fewer. His diagnosis is brutal: Code review is the new bottleneck, and you can’t fix it by reading faster. AI-generated code is opaque, voluminous, and often wrong in ways that are invisible to a human scan. The real alignment has to happen before the code is written — at the decision point, not the pull request.

His solution is a shared document where agents write plans, teammates comment, and only then does the agent act. He calls it separating ‘state’ from ‘action.’ The insight is simple: if the context lives only in an agent’s session, the team is blind. But if it lives in a living document, anyone can pick it up and continue.

Kyle from HumanLayer tackled a different piece: watching an agent work in real time. He built a diff viewer that streams changes as the agent makes them, with comment threads that feed back to the agent. It’s like Figma for coding sessions — two sync channels, one fast for cursor movements, one slow for storage. The engineering detail that made me wince: they maintain a shadow git index to detect file changes after every tool call, because you can’t know ahead of time which calls will mutate files. This is the kind of plumbing we never thought we’d need. Now we can’t live without it.

Modem’s Mike Clark showed two open-source tools that turn the terminal into a collaboration hub. Hunk brings GitHub-grade diff review to the command line, with the twist that agents can comment on diffs. He demoed a scenario where an agent flagged a security hole in his own code — a bypass in a user ban feature — during the review. SideShow turns a PR into a shareable webpage with plain-English explanations. He says his team has interns who submit 100-file PRs; SideShow is how they survive.

Patent from Entire made a claim that stuck with me: Agent session logs are becoming more valuable than the code itself. His tool ties every agent session to a git commit, creating a ‘checkpoint’ with intent, results, tokens spent, and tool calls. Team members can search past sessions — not just their own. When an agent needs to debug a flaky test, it can search the entire history of checkpoints to find similar context. He’s built a distributed git network across four regions to make this fast. We’re used to throwing away agent sessions. That’s like throwing away the design rationale every time.

Brian Douglas brought the fun: he made Claude Code play Pokémon Red. But the point was serious. The agent kept getting stuck on a tree stump. He recorded every session as a high-fidelity ‘tape,’ then fed those tapes back to the agent as observational memory. He built his own version of Anthropic’s paid ‘Dreams’ feature — free, open source, and running on his machine. He also built a multiplexer to run multiple agent sessions side by side, like tmux for AI. If you’re not treating past agent sessions as training data for your team, you’re wasting your most valuable resource: the mistakes already made.

Alex and Marcelo laid bare the infrastructure problem. Alex demonstrated a ‘agent-native’ architecture — a product that agents can navigate without DOM parsing or screenshots, using a CLI tool that injects a chat interface with four tools. But Marcelo showed that the MCP standard is a mess: the same prompt, same service, different results across ChatGPT, Claude, and Copilot. Claude lost the map because it couldn’t window.open. Copilot only implements a subset of MCP. Building for AI clients today is like building for browsers in 1996 — except worse, because the behavior differences are larger and less documented.

The final two demos attacked the real barrier: accessibility. Charming lets non-technical users create apps by talking to ChatGPT, then share them with friends. No code, no Cursor. Nikhil’s NoInfra.ai gives his mom her own agent via Telegram — with a crypto wallet that refills itself when tokens run out. He says she’s been asking for it since January. Real adoption isn’t teaching everyone to use Cursor. It’s letting people who never will still have an agent they can trust.

And then there was the guy who built a new programming language — designed for agents, not humans. Code as a graph, not lines. Auto-instrumented flame graphs. Functions callable from Python or TypeScript without glue code. His argument: TypeScript was a compromise between correctness and developer speed. But if the primary writer is an agent, why optimize for human speed? Optimize for correctness. We’re still using languages designed for a world where humans write every line. That world is ending.

Two hours of demos, and I walked out thinking about that quiet nod from the room. The 15,000 lines of unread code. The agent that caught a bug in its own diff. The mom who wants her own AI. This isn’t a future. It’s a Tuesday night in San Francisco. And the tools you use today — your code review, your PR workflow, your IDE — they were built for a different era. If you’re still reviewing code line by line, you’re already behind.