Copilot, Agent Mode, and the New World of Dev Tools with GitHub’s CEO Thomas Dohmke
Summary
GitHub’s 2025 bet is that Copilot can graduate from “pair programmer” to “peer programmer,” but only on well-defined work. Agent Mode keeps human approval inside VS Code; Project Padawan would take an assigned GitHub issue, outline a plan, commit into a draft pull request, and incorporate review feedback. The target is autonomy that remains as observable and reversible as a coworker’s work.
Widespread agent adoption depends on four qualities: predictable, steerable, verifiable, and tolerable. The full o3 model, which was not yet available, could improve reasoning and move agents closer to 100% on SWE-bench, but task decomposition remains the harder frontier: an agent cannot reliably turn “build GitHub” into executable pieces. Dohmke expects dramatic progress on scoped bugs and features this year, while systems thinking keeps the median developer from being replaced.
Copilot usage has already outrun conventional assistive-tool metrics, yet reliability remains the brake. Autocomplete initially wrote 25% of the code—so much that Dohmke suspected faulty telemetry—then rose to around 50%, depending on language. Agent Mode can turn a prompt into an entire application, shrinking a 15-minute demo to one minute, but it can also rewrite the same file repeatedly or delete it when stuck.
The addressable workload extends beyond code generation into review, cloud iteration, security, and product specification. Developers may spend only two or three hours coding and a comparable amount reviewing colleagues’ work; GitHub wants AI to supply an immediate review loop, remove setup boilerplate, fix vulnerabilities, and eliminate linter cleanup. Product managers, designers, and engineers then converge around the shared skill of writing precise specifications.
Enterprise adoption is being sold on unusually clear unit economics: $20 per user per month against 25%-28% end-to-end productivity gains and 55% or higher on coding tasks. The last disclosed figures were 77,000 organizations and 1.8 million paid users, though Dohmke declined to update them. Copilot’s price is nearly GitHub Enterprise’s $21, evidence that a once-small feature can capture substantial value when the ROI is measurable.
Dohmke expects agent pricing to remain compute-derived rather than become a synthetic programmer’s salary, even as more capable tiers get more expensive. His analogy is a dishwasher: buyers do not price it against a full-time human washing dishes. Human developers remain scarce, while agents have “infinite supply” bounded by GPUs—supporting higher-value tiers such as OpenAI’s cited $200 offering without sustaining human-equivalent pricing.
GitHub’s strategic stance is pluralist: multiple models, agents, and open-source projects will coexist, with differentiation moving up the stack. Copilot offers Claude, Gemini, 4o, o1, and o3-mini, while GitHub Models exposes open-weight alternatives; DeepSeek and FLUX illustrate how open development can pressure proprietary vendors. “Software is like Minecraft”: there is no final winner, only an expanding world of tools and temporary victories.
Deep dive
1. Copilot is moving from suggestions to accountable pull requests
Thomas Dohmke distinguishes today’s Agent Mode from tomorrow’s Project Padawan. In VS Code, Agent Mode can implement a feature and show a terminal command to install a package, but the developer must approve “Okay, run this.” The governing principle is explicit: “You’re still in charge,” because today’s agents still require a human in the loop.
Project Padawan’s 2025 workflow starts when someone assigns Copilot a well-defined GitHub issue. The agent creates a draft pull request, outlines its plan, executes through multiple commits, and accepts feedback while the developer observes it much like a coworker. In Dohmke’s phrase, Copilot “graduates from a pair programmer to a peer programmer that becomes a member of your team.”
The interface must help users decide whether an issue is agent-ready, refine it when it is vague, and let the agent return with questions. GitHub favors pull requests because their commit history makes work inspectable and reversible: developers can review, roll back, or check individual changes out in VS Code before accepting the result.
Dohmke’s adoption test has four parts: agents must be “predictable, steerable, verifiable, and tolerable.” The model-and-agent combination is the first technical obstacle: the full o3 model, which was not yet available, could improve reasoning toward 100% on SWE-bench, described here as roughly 2,200 issue–pull request pairs across 12 open-source Python repositories. But every wasted session or burst of burned compute makes a developer less likely to try the agent again.
2. Capability has become discontinuous before becoming dependable
Copilot Preview’s autocomplete already wrote about 25% of the code. Dohmke’s first response in product review was, “That must be a mistake in the telemetry,” because the early model still made obvious errors. The number was real: autocomplete fit developers’ existing habit of finding, pasting, testing, and modifying snippets, and the share soon rose to around 50%, depending on programming language.
Agent Mode breaks that metric altogether. A developer can ask for “a Snake game in Python,” write no code personally, and receive multiple generated files—making the human-written denominator effectively zero. A demonstration that took 15 minutes two years earlier now takes one minute; Dohmke says his role is instead validating the output and serving as the code-review human.
The opposite result can also happen: an agent may repeatedly rewrite one file or delete it after losing the logic. GitHub is therefore “swinging between the excitement of how much it can already do” and the reality that, after struggling to prompt a background-color change, the developer simply edits the file.
On median-programmer equivalence, Dohmke separates systems thinking from implementation. Agents remain far from taking a rough ambition like “build GitHub,” choosing databases and clouds, and decomposing it without repeated questions. Yet GitHub already had a product manager who usually did not code generate a real pull request from an issue; a developer reviewed it, and it was merged.
3. AI engineering turns planning into a rolling evaluation loop
GitHub calls the expanded discipline “AI engineering.” Applied scientists evaluate multiple models from multiple vendors, while feature teams reuse internal benchmarks inside test suites for code-review agents, SWE agents, and Agent Mode. The data-scientist and engineering roles increasingly overlap because model behavior is now part of ordinary product construction.
New or fine-tuned models move from offline tests into online A/B experiments, first with GitHub and Microsoft employees and then with slices of the broader population. GitHub simultaneously uses Copilot in agent mode to work through its own long product backlog—dogfooding inside a company that builds “GitHub, with GitHub, on GitHub, using GitHub.”
The conventional roadmap is unstable because meetings with OpenAI, Anthropic, or Google can reveal capabilities that reorder priorities from one day to the next. Dohmke says teams “can’t really plan more than a month or two ahead of time.” Competition is unprecedented in developer tools, but he treats it like Formula 1: more credible teams make the race better and force GitHub to move faster.
4. Most agent value sits beyond the hours spent writing code
In many companies, Dohmke estimates that developers code for only two or three hours a day and spend a comparable amount reviewing coworkers. Human review should remain before production for security and trust, but an AI reviewer can provide immediate feedback across time zones. A cloud workspace must then let users test and modify suggestions without cloning repositories, installing dependencies, or switching branches locally.
GitHub also wants code scanning to fix vulnerabilities, not merely identify them, while routine linter and formatting warnings disappear automatically. The larger prize is burning down years of low-priority security, accessibility, legacy-code, and regulatory work—relieving engineering managers from continually choosing between technical debt and whichever customer, sales, or security fire is most urgent.
Dohmke rejects the premise that all code becomes AI-written. Natural language is inherently nondeterministic, while Python, Ruby, Rust, and other programming languages remain the last deterministic layer above machine instructions that engineers use to check correctness and cost. Thirty- or 40-year-old COBOL will not magically become cloud software; developers will keep working in PHP, COBOL, and similar systems for at least a decade or so. He compares the transition with self-driving cars: Waymo works in San Francisco, but not yet all the way from SFO to San Jose, so the scope can expand without a known cutover point.
5. Agent abundance reshapes roles without collapsing tool choice
At a 10-person startup, short communication paths let the founder act as product manager; at 1,000 engineers, the recurring problem is “What did you actually mean?” Copilot Workspace’s early spec and brainstorming agent compares an issue with the codebase, describes the before-and-after state in human language, and lets users edit that specification like a Notion document.
Better specification tools pull disciplines together. A designer may describe the same change as a product manager, render wireframes as code, and ground them in a company design system; a strong product manager may generate the whole change set. Engineers likewise move toward product and design when they can express the intended behavior precisely.
Elad Gil’s pushback is that any leading general model would look spectacular against capabilities from four or five years earlier, potentially weakening specialization. Dohmke first caveats that if the singularity arrives, model choice may not matter; he can imagine models becoming roughly equal but cannot time it—his Tesla still cannot make the left turn into his neighborhood after 10 years. Differentiation then moves upward to workflow, frustration avoided, and software shipped.
GitHub consequently treats developer choice as foundational: teams will combine different models, agents, editors, clouds, container systems, and infrastructure tools according to their own “belief system.” Dohmke also expects personal software within five years “for sure”—a JARVIS-like interface could build bespoke apps or book “same hotel, same family,” leaving the user only to approve the $5,000 trip.
6. Copilot’s economics favor adoption, but not human-equivalent pricing
The last public figures Dohmke recalled were 77,000 organizations and 1.8 million paid Copilot users, disclosed several quarters earlier; he declined to provide an update. What he emphasizes instead is breadth: adoption spans company sizes and industries rather than remaining concentrated among startups or financial-services firms.
At $20 per user per month, Copilot costs perhaps 0.1% of an average US developer’s salary while Dohmke cites 25%-28% productivity gains end to end and 55% or higher on the coding task. The distinction matters because coding is only part of the job, but the ratio still produces “an incredible ROI on the dollar spend” against every company’s long software backlog.
Gil asks whether a future “rent-a-programmer” should capture the $50,000, $100,000, or $200,000 salary it displaces. Dohmke expects compute-based pricing, or a derivative of compute, because buyers will not value a machine like a human employee. His dishwasher analogy carries the claim: automation is not priced at the daily wages of someone washing the dishes.
Prices can still rise with delivered value: Dohmke cites OpenAI’s $200 tier for Deep Research and the o1 Pro model as something that would have sounded implausible two years earlier. Yet supply economics differ—developers are expensive partly because they are scarce, while agent supply is “infinite,” limited by GPUs. He still expects the creative and business-specific decisions about databases, clouds, and architecture to remain human.
7. Software value will bifurcate as open source expands who can build
Sarah Guo’s Trabant analogy asks whether abundant engineering makes some software collapse in value, just as East Germany’s default car lost its scarcity after reunification. Dohmke sharpens the history: the waiting list reached about 17 years, and his father sold their Trabant above its purchase price because the buyer could skip the queue. Scarcity premiums persist even in modern supercars.
Software prices, he argues, will move both ways. Copilot costs businesses $20 per user per month, almost matching GitHub Enterprise at $21, even though Copilot began as “that sub-feature” of autocomplete. Some products become free, as operating systems largely have; others capture more through subscriptions. The governing variable is business value, not a universal deflation rule.
Copilot directly packages Claude, Gemini, and OpenAI’s GPT-4o, o1, and o3-mini. GitHub Models adds Llama, Mistral, Kohya, and Microsoft’s Phi-4; the Add Models extension can reach that catalog from Copilot. Dohmke expects open source to drive proprietary innovation, citing DeepSeek and Black Forest Labs’ FLUX, while preserving the distinction between some models that are fully open source under the MIT license and others that expose open weights while keeping them under more proprietary terms and, in some cases, Chinese law.
Guo’s concern that AI-assisted beginners may miss architectural taste is “not silly,” Dohmke concedes; coding contests may need to assume AI use. His counterweight is access: unlike his Commodore 64 childhood, learners now have infinite knowledge and an assistant with “an infinite amount of patience.” Humans become conductors of an “orchestra of agents”—another major transition after open source, cloud, and mobile: “There’s no looking back.”