Inside GitHub's Copilot Bet: Agents, Open Source, and Why the Developer Job Endures

Thomas, GitHub's CEO, says the best part of the job is watching people use Copilot, a product the company started building more than four years ago. He remembers early usage statistics that looked too good to be true and sending the team back to verify them, and he now watches his own kids solve problems in natural language. GitHub is the world's largest source code host, and Copilot is used by more than 1.3 million developers and 50,000 enterprise subscribers; Thomas, who has been coding since the early 1990s, frames the goal as enabling a billion developers on the planet.

Host Jacob Effron, who worked at GitHub before becoming an investor, notes that Copilot is one of the rare products that shipped better than the team expected. Thomas agrees and points to moments when the ground shifted underneath the product — above all ChatGPT's launch in November 2022. On a trip to Japan, Singapore and Australia right after that release, every customer conversation changed from skepticism about AI to a request for help adopting it and making it part of their own strategy.

What made this shift different, Thomas argues, is that consumerization and enterprise adoption happened at the same time. In the cloud transition, executives had to be taught what the technology was; with AI, their kids and their parents were already using ChatGPT, so the question became why the same capability wasn't available inside the company.

The original Copilot had no chat and no agents — it was autocompletion inside the editor. Autocomplete as a feature was old, but having a large language model write ten lines of code, a test case or a cloud connection kept developers from switching to a browser full of tabs, searching, and pasting back, a detour that costs them the creative thread.

Thomas insists the motivation wasn't generative AI for its own sake but keeping engineers where they have the most fun: writing code. Chat added a second layer on top, and natural language matters because people think in the languages they learned as children, not in code or deterministic machine language. Asking a model to explain your own code back to you, he notes, can be more honest than you are to yourself.

That is what makes the technology democratizing. English is dominant in the United States and England but not in Brazil, Argentina or South Africa, and the seven-year-olds there who just played Super Mario also want to build a game — in Brazilian Portuguese. Thomas compares it to learning an instrument or learning to draw: most people won't become professional artists, but the option to create is now open to them.

Despite launching Copilot Workspace to go from idea to production in natural language, Thomas warns against overestimating how fast the role changes. Every company he has worked with writes more code each day than it deletes, and much of that code is decades old — banks still run COBOL on mainframes written by developers who are, he hopes, retired. That code predates agile, scrum, test-driven development and unit testing as practiced today, so it still needs maintaining; AI makes those systems easier to navigate and turns the hardest part of any new job — learning the codebase, the stack and the team's institutional knowledge — into a question like "how do I deploy here."

Backlogs are full on both sides: enterprise blockers such as proxy support and policies, plus the fundamentals of availability, scale, security, compliance and accessibility, all of which pile up whenever a vulnerability sweeps the internet. Thomas points to Copilot Autofix as the pattern — tooling that not only surfaces security and accessibility issues but burns them down, so developers can spend time on the innovation that makes them happy.

He also argues Copilot is itself an agent — the co-pilot in the cockpit often flies the plane — and that developers have used agents for years: CI/CD runs whenever code is pushed, executes the test cases, creates a lockfile and reports back. His analogy is household automation, because nobody fears their dishwasher or robot vacuum; security tooling today only lists problems, and the next generation fixes them.

He expects some industries to be displaced — translators come to mind, and he imagines recording this podcast in German for listeners to hear in English in his own voice with a chosen accent — while software development moves up the stack the way it moved from open source to cloud and from VMs to containers. AI, he argues, is a layer on top of code, and code doesn't go away: developers already rely on abstractions they never read, like an open-source library that just works, until it breaks and they fork it on GitHub. Copilot adds human language as another layer like that, and its biggest superpower is unblocking yourself — when he learned to code in the early 1990s he had books, magazines, a Wednesday computer club and otherwise went to bed hoping for an aha moment. Today a developer can highlight code and ask where the bug is, which is how kids will learn, the same way they learned TikTok and YouTube.

Asked how AI will change open source, Thomas expects it to make open source even more dominant than it already is. He cites a VP of engineering who coded a decimal-to-binary conversion with his son in 150 lines, then asked Copilot and got two lines: an import from an open-source library and a method call. Models suggest open source because that is what real developers would suggest and because so much of it sits in the training data — and even when told not to use a library, the model produces better code than the hand-written version.

Maintainers benefit too: agents help burn down security issues, manage issue queues and summarize long discussions. Thomas expects more contributors as well, because the hardest part of contributing is learning the codebase and the maintainers' conventions, and fear of rejection is a real deterrent when the work is unpaid hobby time. He points to Meta's latest Llama release and Zuckerberg's comments as evidence that open sharing keeps gaining ground.

Jacob raises the consolidation question: if models keep reusing the same high-quality projects, do we stop building 75 variations of every JavaScript library? Thomas says models behave like developers, who choose React or Next.js over jQuery for maintenance and longevity, and that Copilot is anchored in your own context — the code above and below the cursor, plus adjacent tabs you can open deliberately — so answers match the project in front of you. At the same time it will keep promoting the biggest libraries, much as tech blogs do. Specialized or custom models, or retrieval, could then encode a company's conventions: a shop working in Ruby on Rails can make Copilot follow its patterns instead of chasing the newest language.

Fine-tuning for Copilot is one of the most requested features, especially from enterprises sitting on old code and internal libraries the model will never have seen — C++ in particular lacks the package-manager ecosystem of modern languages. The flow is deliberately undramatic: an organization picks a couple of repositories, the tuning process runs, and then VS Code, Visual Studio or JetBrains automatically uses that fine-tuned model. Developers get a tailored Copilot without touching data science or parameters.

On hallucination, Thomas pushes back on the premise: code found on the internet for an algorithm, an API or rounded corners on an iPhone app is almost never perfect either, and developers already adapt what they find. What made the original Copilot good was context — it knew your variable names and what you had written above, so it started closer to the right answer than a GitHub, Reddit or Stack Overflow result typically does. The goal is not perfection but raising the average, and the average rises with better models, better customization and better retrieval.

Extensions address what models can never know: almost no project is built on a programming language alone, and every company's platform engineering stack is custom — some use LaunchDarkly, some Statsig, some Azure, some AWS. Pulling that context into Copilot Chat means asking how to create a feature flag returns that team's LaunchDarkly connection, with the option to create the flag or check whether it is enabled from the chat window. Even the best model still won't know what your stack actually does, which is why extensibility sits on top of models, retrieval and fine-tuning.

What surprised him most was pace. Copilot began in GitHub Next, a team positioned outside engineering and product to work on the future of software development — "research" in quotes, since it was never about publishing papers. What was scoped as Horizon 3 turned out to be more like Horizon 1.8 and quickly became the current horizon; in AI, Thomas says, you cannot plan on a three-year horizon because you get six months at best before having to reconsider. Adoption has crossed the chasm, so the question is no longer early adopters but the early and late majority — the fastest he has seen technology go from "will this even work" to mainstream enterprise adoption.

Thomas expects the pace to accelerate rather than merely sustain, because teams now use AI to build AI systems and can accomplish more in the same amount of time. He sketches two long-term goals: burning down the security and accessibility backlogs, then keeping them clean. Accessibility might eventually be handled by devices — a Geordi La Forge visor that shows a vision-impaired person the world — while in the meantime developers still need ALT tags, contrast and readable font sizes. Security's harder second act is not reintroducing vulnerabilities, for example when one part of a company downgrades React without knowing another part already patched it.

He puts compliance in the same bucket of toil — the work lawyers hand over as the EU AI Act, DMA and DSA roll out. Innovation will come across the whole stack, he predicts: chip startups designing GPUs that run transformer models faster (fabbed at TSMC), improvements in models, responsible-AI tooling that makes deployment safer and more ethical, and application-layer ideas nobody can imagine yet. Asked which parts of the stack AI will not touch, he can't name one; the better question, he says, is which part of an organization doesn't need the efficiency gains, given that everyone is competing for a limited amount of time and attention.

Thomas admits he finds the term "artificial intelligence" scary as wording, given that the technology is meant to make life and the world better. On market structure he is blunt: nothing in tech is winner-take-all, and even apparent winners get disrupted. Microsoft survives at nearly 50 years old by reinventing itself, and GitHub, as he put it at Universe, was refounded on Copilot. Competition is the point — you don't watch a sport with one team, you want ten F1 teams with two cars each — and companies play the infinite game: Minecraft, not Super Mario, with small mini-games inside the long run.

Enterprises will run many models, and already do. Copilot itself uses several: 3.5-turbo for autocompletion, 4-turbo for chat and 4o for Workspace, with smaller models in the responsible-AI pipeline that scan and fix security issues invisibly. Every other tool in the engineering stack, from Slack to Atlan, brings its own models, so asking whether a company uses multiple models is like asking whether it uses multiple SaaS products. He doesn't believe in one model to rule them all, especially outside software — biotech models for treating cancer are a different world — and enterprises already buy best-of-breed security tools alongside suites, since diverse teams with different stacks will keep multiple AI developer tools coexisting.

Wearing his founder hat, Thomas's first piece of advice is to play the long game and keep the big picture in view, even while operating in a culture of extreme urgency where same-day delivery and next-day cars feel normal. Long-term thinking, he says, also helps founders remember why they are doing what they are doing.

Second, there is no stable state: companies only survive by continuously reconfiguring. He notes that "pivot" carries a negative connotation unless the pivot produced something like Slack, but in reality adaptation never stops, and product-market fit is not an event you achieve once and then keep — you have to keep finding it, retaining position and changing the team and organization as you grow.

Third, and his favorite part of being GitHub's CEO, is saying no. The danger at 1,000, 3,000 or hundreds of thousands of people is losing the discipline that made the company work; he repeats the line, attributed to Steve Jobs, about a thousand nos for every yes. Focus is the true power of a startup, and it has to be preserved as the company scales.

For the ecosystem, GitHub's extensions program is the invitation: partners across the whole stack make Copilot more powerful, and customers are already telling their tool vendors to build Copilot extensions so platform engineering lives in the natural-language interface instead of fifteen separate portals, with accessibility, security and compliance as wide-open areas. The next wave combines extensions and agents, because autocompletion is approaching a solved problem: value moves to scanning and fixing vulnerabilities, reviewing code against standards, refactoring, multi-file edits, predicting the next step and understanding a codebase — he notes that a first pull request at a new company is scary even with decades of experience. Even filing an issue improves when an agent that understands the codebase turns a vague bug report into a spec you can edit and iterate on; developers won't fear that agent, he argues, because it helps them sharpen their own thinking.

In the quickfire round Thomas calls AGI, and the fear of AGI, overhyped, while the impact of AI on biotech, climate change and fields further from traditional tech is underhyped. Asked whether anything about AI scares him, he says no — not even as a parent — though he does worry about deepfakes and whether society keeps up with the technology that detects them; he expects AI to be part of the defense, and jokes that AI screen-time rules will eventually confirm that coding is fine and gaming is done for the day.

Nvidia is the incumbent he is most impressed by. The thing he thought wouldn't work but did was the core premise: as a self-described skeptical German developer he didn't believe any of it, until a Zoom session where GPT-3 wrote code and then produced correct Python syntax — commas, colons and all — without a compiler inside the model, and chat turned out to be the other surprise when ChatGPT opened their eyes to conversational interfaces. He names an AI startup he is excited about, mentions he is an investor in a silicon company, points to biotech as the most exciting area, and says that if he weren't running GitHub he would build the next GitHub.

In the debrief, co-host Jordan pushes back on the developer headcount: Thomas insists developers never go away and natural language is their most powerful tool, but Jordan expects the number of developers needed to fall, especially in front-end tooling and some backend work, while infrastructure and sophisticated next-generation products will still require engineers. Jacob notes GitHub's long-standing strategy of winning developer hearts first, so the answer is unsurprising, and agrees that manual, rote work will be absorbed — QA roles have already shrunk — but argues the lower barrier to building software means more micro-businesses and more competition.

Jacob adds that non-developers will move into development, and Jordan agrees the multi-model world persists: cost, best-in-class performance per use case and small on-device models all point that way, and Copilot is not a wrapper on one OpenAI model but many models and versions. On risk, Jacob is more measured than Thomas: he is bullish that AI brings more good than harm, but sees deepfake-driven scams as a real concern and thinks some skepticism is healthy. He also raises COBOL — mission-critical systems in government, finance and hospitals whose original developers have retired — asking whether AI will maintain that code or reimplement it in modern technology; Jordan says startups already target COBOL conversion and it is a good use case, provided institutions are willing to touch such critical systems.