Thomas Dohmke, the former CEO of GitHub who led the launch of GitHub Copilot, has launched Entire — a developer platform built specifically for the age of agentic coding. The company has raised $60 million to solve what Dohmke sees as the next bottleneck in software development: reviewing code written by AI agents.
The review bottleneck
Here is the problem Entire is trying to solve:
AI coding agents (GitHub Copilot Agent Mode, Cursor, Devin, Claude Code) can now generate entire features, refactor codebases, and implement complex changes autonomously. But every line of agent-generated code still needs human review before it ships. And reviewing AI-generated code is fundamentally different from reviewing human-written code.
When a human writes a pull request, the reviewer can infer intent from the commit messages, the conversation in the issue tracker, and shared context about the codebase. When an agent writes a pull request, the reviewer sees the output but not the reasoning. Why did the agent choose this approach? What alternatives did it consider? What constraints was it working under?
This is the review bottleneck — as agents write more code, the review queue grows, and reviewers lack the context to review efficiently.
How Entire works
Entire’s core innovation is agent reasoning traces — capturing and surfacing the decision-making process of AI agents alongside their code output:
- Why this approach? The agent’s reasoning for choosing one architecture over another
- What was considered? Alternative implementations the agent evaluated and rejected
- What constraints applied? Requirements, performance targets, or compatibility concerns that shaped the output
- What assumptions were made? Dependencies, API contracts, or environment assumptions
Instead of reviewing a diff in isolation, reviewers see the agent’s thought process. This turns a blind review into an informed one.
Why this matters for engineering teams
The shift from AI-assisted coding to agentic coding changes the developer workflow fundamentally:
Before agents (2023-2024)
Developer writes code → Developer creates PR → Reviewer reviews → MergeThe developer has full context. The reviewer can ask questions. The feedback loop is tight.
With agents (2025-2026)
Developer describes task → Agent writes code → Agent creates PR → Reviewer reviews ??? → MergeThe reviewer now faces agent-generated code without the context that a human developer would carry. The PR might be 500 lines across 20 files — technically correct but architecturally questionable. Without understanding why the agent made its choices, the reviewer either rubber-stamps it (risky) or spends hours reverse-engineering the intent (slow).
With Entire (the pitch)
Developer describes task → Agent writes code + reasoning trace → Entire surfaces context → Reviewer reviews with full context → MergeThe reasoning trace bridges the context gap between agent and reviewer.
The bigger picture: agentic development infrastructure
Entire is part of a broader trend — new infrastructure emerging specifically for agentic software development:
| Layer | Tool | Purpose |
|---|---|---|
| Code generation | Copilot, Cursor, Claude Code | Agents write code |
| Orchestration | OpenClaw, Devin | Agents plan and execute multi-step tasks |
| Review and reasoning | Entire | Track agent reasoning for human review |
| Testing | Agent-generated tests | Agents verify their own output |
| Deployment | ArgoCD, Flux | GitOps deploys agent-approved changes |
The developer role is shifting from writing code to directing agents and reviewing their output. The tools need to evolve accordingly.
Dohmke’s credibility
Thomas Dohmke is not a random founder pitching an AI startup. He was CEO of GitHub during the most transformative period in developer tooling:
- GitHub Copilot launched under his leadership — the first mainstream AI coding assistant
- Copilot Chat brought conversational AI into the IDE
- Copilot Agent Mode (2025) enabled autonomous multi-file changes
- GitHub grew to 100+ million developers under his tenure
He has seen the agentic coding transition from the inside — watching how Copilot evolved from autocomplete to autonomous agent, and what broke in the developer workflow as agents became more capable.
What I think
The review bottleneck is real. I have seen it in consulting engagements — teams adopt AI coding tools, productivity increases on the generation side, but the review queue becomes the constraint. Senior engineers spend more time reviewing agent output than they saved by not writing it themselves.
Three observations:
The problem is real but the timing is early. Most teams are still in the “Copilot autocomplete” phase, not the “fully autonomous agent” phase. Entire is building for where development is going, not where most teams are today.
Agent reasoning traces could become a standard. If Entire proves the concept, expect GitHub, GitLab, and other platforms to add similar capabilities. The idea that agent PRs should include reasoning is sound regardless of the specific tool.
This does not replace code review — it changes what review means. Instead of reviewing syntax and logic, reviewers will increasingly review agent reasoning: “Was this the right approach?” rather than “Is this code correct?”
The $60M signals serious investor conviction that agentic coding is the next platform shift. Coming from the person who led GitHub through the Copilot era, the bet has credibility.
For platform engineering teams
If you are building an internal developer platform, watch this space. The toolchain for agentic development is forming now:
- Agent orchestration — how do you manage which agents can do what?
- Reasoning audit trails — how do you track why agent-generated code exists?
- Review workflows — how do you adapt PR review for agent output?
- Trust boundaries — which agent changes can auto-merge vs require human review?
These are platform engineering problems, not individual developer problems.
