From Arctic Code Vault to Autocomplete: How GitHub Copilot Went From Moonshot to Product

Salva did not study computer science. He majored in philosophy and English, drawn to how people express their experience of the world, and says he went into software and product because he wanted to be in the business of creativity. He sees software as a new medium and jokes that in another century he would have been making new colors of paint.

After more than 20 years in engineering, including about 10 at Microsoft, he joined GitHub three years before this conversation. At Microsoft he led product for the shared developer infrastructure behind Windows, Office and Azure and for Azure DevOps. When Microsoft acquired GitHub, he saw that the energy and community of developer tools were there, and wanted to work on everything from Copilot to Codespaces, Actions and advanced security.

Salva describes Copilot as the intelligent autocomplete developers have had for 20 years, magnified across many lines of code. It is powered by Codex, a derivative of GPT-3, and appears as gray italic suggestions in editors such as VS Code and IntelliJ. It infers intent from variable names, class names, method names and comments, and gives scaffolding to riff on.

The point, he says, is flow. Remembering parameter order, looking up syntax or generating dummy data is labor rather than creating, and Copilot brings that information into the editor instead of sending developers to documentation, tutorials or Stack Overflow. He cites an educator who has teenage students build internal tools for small businesses with Copilot, and says it also helps developers build a mental map of an unfamiliar code base.

Salva says the realization was that programming languages are languages too, and relatively constrained ones, so large language models could translate between English and Python the way they translate between human languages. His introduction was funny: his infrastructure team saw a huge spike in clone requests that looked like a denial-of-service attack and turned out to be OpenAI harvesting repositories. GitHub stepped in and offered the data in a more responsible, better packaged way.

GitHub had already taken a snapshot of public code for its Arctic Code Vault, stored on silver film in a vault in northern Finland, to preserve the world's open-source software. They took that snapshot to OpenAI to see what large models trained on public code could do. The team then tried different interfaces, including a side panel, before settling on inline autocomplete, working with the VS Code team to add the needed extensibility and choosing gray text to signal that suggestions are ephemeral.

Between the first experiments and the launch, he says, researchers at OpenAI experimented while GitHub worked out how to use the model: which parameters to tune, what to optimize and how to prompt. Latency was central, and experiments pointed to roughly 200 milliseconds as the point where a suggestion doesn't feel like an interruption. The whole path took about a year and a half.

Copilot started in GitHub Next, a team that works on second- and third-horizon projects: moonshots that may matter in three to five years. Salva ballparks horizons as the next year, next three years and next five years, but says they are better seen as levels of ambiguity and confidence. GitHub ring-fences that team from the engineering, product and design (EPD) organization that runs the operational products.

His advice is first to hire smart people and give them space, without expecting revenue or demanding security, privacy, uptime and accessibility up front. Once an idea clearly connects to customers with a real problem, start informal market testing with prototypes. When developers called it magical, GitHub moved some researchers into a new EPD squad for a limited period, opened a technical preview to tens and then hundreds of thousands of users, and saw excited tweets and Hacker News threads.

Salva's lessons are that researchers should move back only when a replacement has the skills, not by the calendar. The product team must own its roadmap, because you can't delegate a roadmap to an R&D group. Finally, engineering fundamentals mark the difference between research and an operational product, and bringing them in takes cultural change management.

Salva says AI brings engineering, ethical and legal challenges, such as who is at fault if the AI produces something offensive. The team landed on framing Copilot as an AI pair programmer: if your partner whispered slurs or politics in your ear you could not focus, so the product needed principles for appropriate behavior. Lenny likes the idea of using a persona to define how the product should act.

He says he has spent more time with legal on this product than any other, along with privacy and security champions and developers. Early Copilot had no filter, then a simple word block list, which turned GitHub into editors of language and sometimes blocked legitimate uses. GitHub now works with Azure's Responsible AI group, whose models detect patently offensive content in context, which he sees as proof that AI is getting better at filling in parts of the stack.

Asked about the claim that 40% of code is written by Copilot, Salva clarifies that figure is for Python developers and that the range across languages runs from the upper twenties to the forties. Languages with more and more varied public training data tend to see better suggestions. He expects AI to spread through the entire development stack, for example by summarizing pull request changes so reviewers don't have to decipher thin commit messages.

His hope for five to ten years out is that more people become developers because AI adds an abstraction layer, and that experienced developers focus on outcomes and design rather than syntax and parameter order. On scaling, he names supply chain shortages of the rare GPUs needed to train and run models, and the amount of dialogue with the community, which required growing the product team more than the engineering team.

Salva says he wants people to be skeptical of Copilot, particularly about training on public code, security, buggy suggestions and attack vectors such as model poisoning. GitHub's stance is that Copilot is not a replacement for a developer and should not auto-generate code without a human, or replace static analysis and unit tests. Lenny links this habit of dialogue and skepticism back to Salva's philosophy education.

As a portfolio manager of several product lines, Salva says allocation depends on circumstances, but as a general rule he keeps some capacity for audacious research. He describes uncertain bets as about 5-10% of a team's capacity, 25-30% on operations to keep in-market products meeting expectations, and about 60% on incremental progress that realizes payoff from bets made one to four years earlier.

He notes this works for larger teams; at a startup nearly everything is the big bet and you are all in on one lottery ticket. In the lightning round he recommends *Make It So*, a book on sci-fi user interfaces, *Brief Interviews with Hideous Men*, and The Memory Palace podcast. His interview icebreaker asks product candidates to teach him something new in one minute, graded on completeness, complexity and clarity.