The short version
Dohmke's diagnosis: agents now write most code, pull requests have tripled in size, and over 20% more code gets merged without a human ever looking at it. We have entered what he calls "the era of the YOLO merge," and he admits to plenty of his own.
His answer, built into his startup Entire: store agent session logs in the git repo next to the code, capture intent before the diff exists, and replace line-by-line review with "gates" (confidence, risk, drift, security scores) that rerun on every push. He also announced a decentralized Git network, arguing centralized git can't survive agent-scale traffic. The idea worth stealing works without his product: treat agent session logs as a versioned artifact your team and your agents can both learn from, and write down merge criteria a machine can check.
Key takeaways
Agents already write most code
Anthropic says 70-90% of its code is written with AI, the Codex team claims 100% of Codex is written by Codex, and Google is on record at 75% of new code. Pragmatic Engineer data on Linear shows teams with agents shipping five times as many PRs as two years ago.
Code review is the part that cracked
Cursor's data shows PR size up three times (by design: nobody wants to interrupt an agent for a small PR) and over 20% more code merged without a human ever looking at it. His honest summary of the average reviewer facing an agent's morning output: "fuck that." Meanwhile newer models find ten times as many issues in review as a human reviewer, who tends to stop after three bugs because three feels like a job done.
The loops are inverting
DevOps spent 20 years making the inner and outer loop smaller, because a human ran both and human attention is the constraint. With agents, the leading practitioners (he name-checks Geoffrey Huntley's Ralph loop, plus Peter Steinberger of OpenClaw and Boris Cherny of Claude Code) do the opposite: make the loop as big as possible, give the agent an exit condition, and let it grind until the eval passes. The bottleneck moves from writing code to capturing intent and proving the loop delivered what was asked. That is his "agentic assembly line," and his thesis: the SDLC as we know it is dead.
Session logs are the second most important artifact in software
Code stays first, because it is the only deterministic artifact. But the chat session is where the "why" lives, and today it dies on the laptop where the agent ran. His answer: commit session logs to a git ref alongside the code. Entire's MIT-licensed CLI hooks into Claude Code and pushes session logs to the repo automatically, so a teammate (or an agent) can ask why a commit exists, read extracted learnings and friction points, and stop repeating last week's mistakes. The live demo of this failed on stage (auth loop with no phone), so he showed a pre-populated demo repo instead.
Trails: review signals instead of diffs
Shown for the first time in this keynote, by Rizel Scarlett (Entire devrel, maintainer of the Goose coding agent, which currently has 80+ open PRs she can't deeply review). A "trail" starts with written intent before any code exists, then links the plan, the agent's checkpoints, prompts, tool calls, and the merge. On every push, "runners" (config files in the repo, like CI workflows for review) rescore gates for confidence, risk, drift, and security. Merge criteria become those signals plus a teammate's approval, not a line-by-line read. His analogy: you drive a car by its dashboard, not by watching raw engine telemetry. His pitch: "a world where 'looks good to me' actually means something."
Centralized git won't hold at agent scale
He quotes Linus Torvalds' 2007 Google talk (distributed, fast, reliable, or "you're not worth using") and points out we spent two decades recentralizing git into GitHub, GitLab, and Bitbucket, optimized for human speed. GitHub's own charts of PRs, commits, and new repos are bending sharply upward as every developer runs ten agents in parallel. Announced the day before the keynote: Entire rebuilt its Git backend as a decentralized network with nodes in the US, Europe, and Australia, region pinning, multi-region repos, GitHub mirroring to get on board, and a promise to open source it all.
The numbers
- 70-90% of Anthropic's code written with AI (their own claim); 100% of Codex written by Codex (ditto); 75% of new code at Google
- 5x as many PRs shipped by Linear teams using agents vs two years ago (Pragmatic Engineer data)
- 3x growth in PR size (Cursor data)
- 20%+ more code merged without a human ever looking at it (Cursor data)
- 10x as many issues found by current review models as by a human reviewer
- 80+ open PRs on Goose, the open-source agent Rizel Scarlett maintains
- 2.1 million pushes per hour on a single repo on Entire's network
- 1 billion+ repos on GitHub that Entire hopes to mirror
Caveats
This is a founder's keynote: the diagnosis leans on data, but much of that data comes from vendors with their own story to tell, and the prescription is a pitch for his own product, with Trails shown for the first time on this stage. Most of the striking numbers are vendors' own claims (Anthropic, the Codex team, Cursor slides, Entire's push benchmark) with no independent check available. The "review signals instead of code" idea assumes you trust the gates, and the talk doesn't address who reviews the runners or what happens when an agent games an eval. The demo of the core session-log workflow failed live and was shown from a canned repo. And this recap is built from auto-generated captions: names were verified externally where possible, but treat exact figures and the garbled model names on one slide with care. Dohmke's own caveat is worth keeping too: agents are "dumb but relentless," and his company runs a Slack channel of agents confessing they went off the rails.
Why it matters for Teams AI builders
The problem he describes is one this community already has: agent output has outgrown human review capacity, and "I read every line" is quietly becoming fiction. Two patterns are stealable today without touching Entire. First, session logs as a team artifact: transcripts of agent sessions, committed or summarized into the repo, turn individual prompting experience into institutional knowledge that both new teammates and agents can read (several of us already keep CLAUDE.md learnings; this extends the same idea to the full session). Second, machine-checkable merge criteria: writing intent down before the agent starts, and encoding what "reviewable" means (tests, risk checks, drift from stated intent) as config that reruns on every push, is a practice, not a product. Whether the decentralized git network matters to you depends on whether you believe his claim that agent traffic breaks centralized hosting; that one is a bet, not a finding.
Join the discussion
Dohmke admits he merges agent PRs without reading them, and Cursor's data says he has plenty of company. What is your actual bar for merging agent-written code right now: full read, spot-check, or green CI and gut feeling? And would committing your agent session logs to the repo for teammates to read change anything, or is that just more output nobody reviews?