How to Kill the Code Review — Ankit Jain, Aviator @aiDotEngineer

Uploaded August 2026 | Updated September 2026, 3 weeks ago

Over 30% of changes now merge with no review at all, and the wait on the ones that do get reviewed is four times what it used to be. Ankit Jain's read is that the debate about when we stop reading code line by line is already over, because we stopped. His sharper point is what replaced it: an AI writes the code, an AI reviews the code, the two go back and forth in a web UI, and a human skims the thread and merges. When AI reviews and nobody reads, he says, we have configured the wrong thing.

He is also here to correct his own five layer trust model from a few months earlier, which missed that review was never only about correctness. It also carries knowledge sharing, mentorship, architectural feedback, and onboarding, and that half has to survive. Spec driven development does not rescue it, because a spec written up front with no feedback loop is the 1970 waterfall model, and the decisions that actually matter end up in the prompts, which teams throw away the moment the pull request opens. His proposal keeps them: capture the session, turn those decisions into acceptance criteria, pair that with a registry built from your own recurring review comments, and generate a test plan that a verification system runs against a live preview. The review surface becomes intent and evidence instead of the diff.

Speaker info:
- https://x.com/ankitxg
- linkedin.com/in/ankitjaindce
- https://www.latent.space/p/reviews-dead

Timestamps:
0:00 - The five layer trust model, and what it got wrong
1:17 - We already stopped reviewing, and AI reviews nobody reads
3:05 - What code review was actually for
4:21 - Spec driven development is waterfall again
5:53 - Intent lives in the prompts, which we throw away
6:42 - The AI slop registry
7:58 - Session to acceptance criteria to test plan
11:51 - Deterministic where you can, and reviewing intent not the diff
14:12 - Homework: mine your last 1,000 review comments

How to Kill the Code Review — Ankit Jain, Aviator

$DeepSWE: A Contamination-Resistant Coding Benchmark — James Shi, Datacurve DeepSWE is 113 software engineering tasks written from scratch, not scraped from pull requests, so a model cannot have seen them in training. Each one is a long horizon problem drawn from a real open source repository, authored by engineers who actually maintain that code, with isolated environments and program based verifiers that check observable behavior rather than trusting the models own account. James Shis point is that once you remove the contamination the leaderboard stops clustering: strong models pull far ahead and others, Gemini 3.1 Pro among them, fall toward the bottom. The more revealing signal is in how models fail. Some quietly expand a task beyond what was asked, a failure mode DeepSWE scores in its own right, and Claude models did this a good fraction of the time while GPT models did it less often. Stronger models also tend not to verify their own work, and there is a real gap between the ones that test what they wrote and the ones that assume it is correct. Since reward hacking is a constant temptation, the verifiers are built to be gamed as little as possible, keeping the score anchored to the objective rather than to a convincing looking rollout. Speaker info: - https://x.com/shiqyy - https://www.linkedin.com/in/jamesshi117/ - https://deepswe.datacurve.ai Timestamps: 0:00 - Introduction: the DeepSWE benchmark 1:03 - 113 original, contamination-resistant tasks 2:08 - What makes a good benchmark 3:51 - The leaderboard and model spread 5:18 - Failure mode: over-scoping the task 7:16 - Do models verify their own work? 8:45 - Tasks authored by core contributors 10:15 - Writing realistic, high level prompts 11:45 - Program based verifiers and observable behavior 13:43 - Limitations and future work 15:25 - Reward hacking and keeping it cheating proof$

Persona Engineering: A Field Guide to AI Synthetic Personas — Ishan Anand, InsightSciences.ai

Trading Desks to Clinical Trials: Parallels in Applied Vertical AI — Ayush Bhardwaj, Allos AI

Anthropics CCA Exam as a Field-Guide for Agentic Engineering — Frank Coyle, UC Berkeley

Teaching AI to Find Real Vulnerabilities — Prof. David Brumley, Bugcrowd

Building the Engine While Flying the Plane: Launching the Figma MCP Server — Jesse Lumarie, Figma

Bringing Continual Learning into Enterprises — Samuel Denton, Applied Compute

$Agent Spending Without Controls — Rodrigo Coelho & Pranav Maheshwari, Edge & Node Pranav Maheshwari ran one prompt in two terminals: find the email address of the head of crypto and blockchain at Mastercard. The terminal without a payment skill file returned the companys email format and an invitation to work the rest out. The one with it paid a fraction of a cent to a metered endpoint and came back with the address, the persons location and their handle. That gap is the whole argument. Most MCP servers are free today, and his claim is that the useful ones will not stay free, which leaves an agent only as capable as the tools it can pay for. Rodrigo Coelho sets up the longer history first: Edge & Node built The Graph, served 1.8 trillion onchain queries, and shipped a query micropayment system in 2021 that cited the HTTP 402 spec years before Coinbase released x402. What stops enterprises adopting any of this, in Coelhos telling, is compliance rather than throughput. Traditional rails assume a human somewhere in the decision loop. Agents transact around the clock at machine speed, and a counterparty arrives as a bare wallet address with no identity attached to it. Somebody carrying a title like chief legal officer has to sign off, knowing that getting sanctions screening wrong carries fines in the billions. The closing demo makes that concrete. Two agents hit a metered scraping service, one from an ordinary wallet and one from a wallet flagged as sanctioned. With screening off, both transactions authorize. Switching screening on leaves the first working and rejects the second as a blocklisted address. Speaker info: - https://x.com/rodventures - https://www.linkedin.com/in/rodrigoco/ - https://x.com/impranavm_ - https://www.linkedin.com/in/thepranavmaheshwari/ Timestamps: 0:00 - The Graph, and paying for queries before x402 existed 2:03 - Prior art: micropayments, the 402 spec, and joining the foundation 3:52 - Rails built for humans in the loop, not machines 4:49 - Why enterprises stall without a compliance layer 5:42 - A wallet address with no identity behind it 6:37 - The officer who signs off, and the size of the fines 7:35 - Agents are only as good as the tools they can pay for 8:31 - Demo: the same prompt with and without the skill file 12:16 - Demo: an agent buying a gift under a set budget 16:14 - Demo: screening a sanctioned wallet 18:04 - Compliance on, and the transaction rejects$

State of Data — Sean Cai, Independent / State of Data

RL Environments at Scale – Will Brown, Prime Intellect

Data Quality Is the Compute Multiplier — Ari Morcos, DatologyAI