Copilot Already Writes Half the Code. GitHub's CEO Says Agents Still Have Four Gates to Clear

GitHub CEO Thomas Dohmke sits on a platform used by more than 150 million developers, and he does not ease into the conversation. A few days before this No Priors taping with Sarah Guo and Elad Gil, GitHub shipped agent mode inside Copilot for VS Code. Instead of chatting, copying a snippet, or accepting a completion—the original Copilot move—you work with an agent that helps implement a feature. When it needs to install a package, it shows you the terminal command and waits for a nod. The human stays in charge. That, Dohmke says, is the crucial fact about every agent shipping today.

The teaser for 2025 is Project Padawan, named for a Jedi apprentice: you need patience, and you need to learn how to use the Force. The idea is that you assign a well-defined GitHub issue to Copilot. It drafts a pull request, outlines a plan, and works through that plan, committing as it goes. You watch it the way you watch a coworker, roll back a commit, check the diff out in VS Code, and leave review comments. In Dohmke's phrasing, Copilot "graduates from a pair programmer to a peer programmer" and becomes a member of the team.

Two things still stand between that demo and daily use. The first is the model: OpenAI's full o3 reasoning model was not generally available yet, and Dohmke expects better reasoning to push the agent-and-model combo closer to 100% on SWE-bench—the Princeton benchmark of roughly 2,200 issue/pull-request pairs drawn from 12 open-source Python repos. The second is the interface. A developer staring at an issue still has to decide whether to assign the agent or rewrite the ticket so it is specific enough to succeed.

That decision only works if four properties hold. The agent has to be predictable: you should know, looking at the issue, whether it can finish the job. It has to be steerable: if it cannot, it comes back with questions, or you extend the definition. It has to be verifiable: the work lives in a pull request with lots of commits you can roll back. And it has to be tolerable. Dohmke has watched developers meet agents that rewrite the same file, burn compute, and waste a morning. The more often that happens, the less likely they try again. Trust is slow; one stuck loop is enough to kill it.

Asked how far these agents are from a median programmer—and how much longer until they are superhuman—Dohmke does not start with benchmarks. Travel agents, coding agents, and house-design agents share a problem that human developers already have: a big idea that sketches cleanly on a whiteboard still has to be broken into small chunks of work. That decomposition is where he thinks agents are far from good enough. Give one the task "build GitHub" or "build a mobile app" and it is not specific enough. The agent will keep coming back for decisions: which database, which cloud, which tradeoff.

That systems thinking, he argues, is why the median developer is not replaced. The flip side is the work developers actually spend much of their week on: picking up issues, fixing bugs, adding a customer-requested feature, navigating a codebase, and finding the files to change. There, he expects dramatic progress over the year. When GitHub recorded the Padawan demo, a product manager who does not normally write code in the repository filed an issue, the agent opened a real pull request, and a developer reviewed and merged it. In some ways, he says, we are already there. In others, the missing piece is trust strong enough to use the agent every day.

The industry now calls the work AI engineering: full-stack product development extended by model integration. Copilot has a model picker and constantly juggles models from multiple vendors, so GitHub runs an applied-science team on evaluations and another team that builds the benchmarks those scientists—and the engineers shipping code-review agents and agent mode—use as a test suite. Data scientist and engineer are overlapping jobs. After offline tests, new or fine-tuned model versions fly first to GitHub and Microsoft employees, then to slices of users in A/B tests.

There is still a roadmap and a long backlog, and not only for Copilot. GitHub turns 18 this year; the founders started in late 2007 and launched in early 2008. Microsoft turns 50 on April 4. The company is using Copilot, including agent mode, to chew through customer feedback faster. The market does not wait. Meetings with OpenAI, Anthropic, or Google produce a new model version, and the roadmap changes overnight. Dohmke's planning horizon is a month or two. "We're literally sitting on an exponential curve of innovation."

Winning, in his telling, is not a slogan about market share. GitHub's line is that it builds GitHub *with* GitHub *on* GitHub *using* GitHub: legal terms, HR policies, product management, sales enablement—all of it lives in issues, discussions, and repositories. The first thing he opens in the morning is the GitHub app on his phone; Slack comes second. He has been a developer for more than 30 years and calls this the most exciting era he has seen in developer tools, with energy arriving from open source and closed source alike. As a Formula 1 fan, he wants more teams that can win the championship. Competition is what gets the company out of bed.

What still surprises Dohmke is how much code Copilot writes. Soon after the preview launched, the number in a product review was 25%. He told the room it had to be a telemetry bug and sent people back to validate it. Autocomplete was still making plenty of mistakes. The number was true, and it matched a behavior developers already had: type until you are stuck, look something up on Stack Overflow, Reddit, a blog, or GitHub, paste, and modify until the compiler is happy. That share then rose to around 50%, depending on the language.

Agent mode breaks the statistic. You can say you want a Snake game in Python and the agent writes all the files. The only thing the human typed was the prompt, so "the denominator becomes zero"—an infinite percentage. A 15-minute demo from two years ago is a one-minute demo now. The opposite is also true. The agent will rewrite the same file, or delete the whole file, because it is stuck in its own logic. That, Dohmke says, grounds the company: we are not close to an agent that autonomously walks every GitHub issue and fixes the backlog. What you are really doing is becoming the human code reviewer for a software-development agent.

Writing code is maybe two or three hours of a developer's day. An equal stretch goes to reviewing coworkers' code, and Dohmke does not think that human pass disappears: for security and trust, another person should still look before production. Code-review agents can still take the first loop, especially for distributed teams that should not wait for the West Coast to wake up. The interface matters as much as the model. If every round of review feedback means cloning the repo, installing dependencies, and switching branches, the boilerplate never went away. The outer loop only gets fast in a cloud environment you can open, try, and patch.

The more practical win is the security backlog. Code scanning should find vulnerabilities *and* fix them. Linter errors—the hundred warnings about spaces inside parentheses—should simply vanish into an AI pass. Any decent-sized project carries outdated dependencies and known low-risk holes that someone decided were unreachable or not worth it this sprint. Letting AI burn that down, Dohmke argues, is how you stop engineering managers from swinging forever between tech debt, legacy code, security, accessibility, European regulation, and the innovation backlog. There is no balance. There is only the bigger fire: a sales team that cannot ship, or a security team ready to escalate.

Guo asks whether a world of mostly generated code changes testing, technical debt, and how teams should look at the work. Dohmke does not buy "all of the code is written by AI." He sees two layers. Programming languages—Python, Ruby, Rust—are abstractions over a chip's instruction set, and they are deterministic: the machine does what you wrote. Human language is not. Three people can say the same sentence and mean three things. Teams will describe more features in English and still drop into the programming-language layer to check correctness, cost, and profit margin. Financial institutions still run COBOL on mainframes. We are far from an agent that magically turns 30-year-old code into a cloud app, in the same way Waymo works in San Francisco and does not yet drive you all the way to San Jose.

What he looks for on his own engineering teams is already shifting: can you describe a problem specifically enough that an agent can pick it up? A ten-person startup barely feels this. There is often no product manager; the founder is the PM, paths are short, and people just build. A thousand-engineer company lives and dies on "what do you want to build, how, and what did you actually mean." Copilot Workspace is an early attempt: a spec and brainstorming agent reads the GitHub issue, compares it with the codebase, and writes the before-and-after in human language, which you edit like a Notion doc. Dohmke expects a similar move for designers—type the same spec a PM would, render wireframe code, then ground it in the design system.

Those disciplines get closer together. A product manager who can write a sharp spec should be able to generate a whole changeset. A designer can take over part of the PM role. An engineer who is good at describing a feature can step into that work too. Dohmke does not think one company or one interface will own all of it. GitHub's belief is developer choice: if the platform offered only React, React fans would stay and everyone else would leave. The same stack-of-tools pattern he sees in the Bay Area—editor, OS, containers, cloud, HashiCorp Terraform, Vercel and Next.js—will show up as a choice of agents and models. Claude versus OpenAI is already a belief system as much as a benchmark.

Guo pushes on generalizability: if you threw away most of the models and kept one of today's options, you would still be ecstatic relative to five years ago. Dohmke grants the point at the model layer. Copilot started in June 2020 on GPT-3, then a code-specific model that became Codex; that specialized model no longer really exists, because everyone sits on stronger base models. He has driven a Tesla with Autopilot in some form for ten years, and it still cannot make the left turn into his neighborhood. He can see the future. He does not know the date. Differentiation, he thinks, will move up the stack—to the place a developer starts the morning, explores an idea, and ships with the least frustration. He does not believe the CEO of GitHub ever gets an empty backlog.

On the business, Dohmke will not go past the earnings call. The last public figures, from a few quarters earlier, were 77,000 organizations on Copilot and 1.8 million paid users. What he finds more interesting is the mix Satya Nadella reads on those calls: not only startups and not only banks, but every industry, every company size. He cannot recall a developer tool adopted with that velocity. Twenty dollars a month is about 0.1% of a typical U.S. software salary, against roughly 25–28% end-to-end productivity gains and 55% or higher on coding tasks. That return, he thinks, is the adoption curve.

Every company is now a software company, and they all have the same problem: a backlog that never shrinks, and a manager who asks how long a feature will take. Dohmke reaches for Star Trek. Captain Kirk asks Scotty how long to repair the warp drive, gets an outrageously long estimate, and then the captain sets the deadline. Copilot's business, in this telling, is built on that frustration—not because engineers are weak, but because building software is complex and everyone hates how long it takes.

Gil asks whether the market eventually becomes "rent a programmer," priced like a $100,000–$300,000 salary, or collapses toward a thousand-dollar commodity. Dohmke's answer is compute, or a unit derived from compute. It will be cheap in the way a dishwasher is not priced as a full-time dishwasher. Buyers will not pay machine rates that look like human rates, and he thinks that instinct is correct: the agent is not replacing the developer. The creative work and the business decisions—which database, which cloud, how many clouds so you are not stuck with one supplier, the way a car plant keeps more than one airbag vendor—still sit with people. Price points will still rise with capability. OpenAI's top tier at $200 a month for Deep Research and o1-pro would have sounded absurd two years ago for a "chat agent," even as users riot over a $5 phone-app subscription because they still think software should be a CD you buy once.

Human developers are expensive because supply is limited. Agents have infinite supply, bounded only by GPUs in data centers. Guo, who also grew up around East German scarcity, brings up the Trabant and its waiting list. Dohmke's parents had one; he later owned one. The wait in the late 1980s was about 17 years, not ten. His father sold the car to a neighbor in 1984 or 1985 at a *higher* price than they had paid, because a sale could jump the queue, and parents often signed infants up so a car would exist by driving age. The same logic, he says, still lives in supercars: a top-end Porsche 911 RS can resell above sticker because the dealer makes you buy a hundred Porsches first. Scarcity sets price until it doesn't.

Then the contrast that still startles him: Copilot is $20 per user per month for businesses. GitHub Enterprise is $21—repos, issues, the whole software-development lifecycle, a price many companies already found steep for DevOps. Autocomplete, a sub-feature, now costs about as much as the platform. Five years ago that would have sounded unlikely. He expects deflation in some software prices (nobody pays for the operating system anymore) and higher bills than ever for Netflix and Office. Both can be true. What matters is the value the business actually gets.

Copilot currently packages Claude, Gemini, and several OpenAI models, including GPT-4o, o1, and o3-mini. GitHub Models, the catalog, adds open-weight options such as Llama, plus Mistral, Cohere, and Microsoft's Phi-4. Because Copilot has extensions, you can reach from Copilot into that catalog and run quick inference on Phi-4 without waiting for every model to be "in the box." Dohmke's larger point is that open source will keep driving the closed labs. DeepSeek had just landed: papers open, some models fully MIT-licensed, others open-weight under licenses governed by Chinese law. Image models followed the same back-and-forth, from Stable Diffusion to FLUX from Black Forest Labs near Freiburg, not far from where he is based in Germany. Students and researchers can try a model locally instead of paying a commercial API. That, he says, is GitHub's DNA.

Who wins—iPhone or Android, Windows or Linux? Dohmke refuses the binary. React did not "win"; before it there was jQuery, and after Python, TypeScript, and Rust there will be another language, probably closer to the natural-language layer sitting on top of the CPU. Rust itself "wasn't really a thing" five years ago. Software, he says, is like Minecraft: you win little battles and isolated quests, but the world only gets bigger, and there is always a next big thing. It is an infinite game.

Guo relays a worry she hears from experienced systems programmers, often Rust people: if the next generation lets AI write the code, will they grow the taste for architectural tradeoffs and the corner cases of how an implementation fails? Dohmke will not call the concern silly—cheating on a programming exercise or Advent of Code is already too easy—but he thinks competitions will have to assume AI is in the room. He learned to code in East Berlin with no internet, only books, magazines, and a Wednesday computer club he outgrew. Today's kids have infinite knowledge and, just as important, infinite patience. "Copilot doesn't run out of patience. Parents do." You do not need technical parents. You need a phone, a connection, and a model, and you can take Boolean logic as deep as you want. He has started calling it an orchestra of agents, with the human as conductor. His own engineers do not complain about a shortage of ideas. They talk about being overcommitted, burned out, and out of time.

Gil closes on East Berlin and whether reunification trained Dohmke for this speed of change. He has always believed a lot of his life was defined by one Thursday night in 1989, when the Wall was going to open. Friday was normal school. Saturday was a half day; four kids showed up and were sent home, and they crossed into West Berlin. For that generation, childhood is not a place you can return to. The corner store is gone, the schools are gone, the system is gone. Ten years before this conversation, Microsoft bought his company and he moved to the United States—another one-way door. Before and after the internet, open source, the cloud, mobile, and now AI: there is no looking back. AI will be in almost everything, if you want it. You can still throw the phone in the corner and spend a day without the internet.