How we’re experimenting with LLMs to evolve GitHub Copilot

From GPT-4 to Copilot: How GitHub Next Spikes Ideas Into Products

Generative AI may have dominated headlines in 2023, but its roots go back decades. What changed recently is the arrival of neural-network-based models powerful enough to build practical developer tools. GitHub has been experimenting with these models for years—work that led to GitHub Copilot’s 2021 preview—and that experimentation continues to shape how the platform evolves.

The latest evolution of Copilot emerged from a burst of research and prototyping inside GitHub Next, the company’s R&D group. The team got early access to the model that would become GPT-4, before anyone outside OpenAI had seen it. “It became a race to discover what the new models are capable of doing and what kinds of applications are possible tomorrow that were impossible yesterday,” says Idan Gazit, senior director of research for GitHub Next.

Over several months, researchers spiked a range of ideas, tested what felt promising, and then doubled down on the projects that showed real value. By the time GPT-4 was publicly announced in March 2023, the team had several concepts and technical previews ready. That work, combined with product leadership’s vision for Copilot’s future, led to the release of GitHub Copilot Chat and previews of Copilot for Pull Requests, Copilot for Docs, and Copilot for CLI on March 22, 2023.

“We knew we wanted to make an announcement of our own around the joint Microsoft and OpenAI announcement of GPT-4,” says Mario Rodriguez, VP of product management. The GitHub Next investments weren’t production-ready, he notes, but they got leadership thinking about what Copilot could become.

AI Should Be Predictable, Tolerable, Steerable, Verifiable

As more developers incorporate AI tools into their workflows, GitHub’s AI experiment work is guided by four principles. The experience should be:

• Predictable: tools should guide developers toward goals without surprising or overwhelming them.
• Tolerable: models can be wrong, so users need to spot bad suggestions quickly and recover from them at low cost.
• Steerable: when responses miss the mark, users should be able to redirect the AI, not rely on the model getting it right the first time.
• Verifiable: outputs must be easy to evaluate since models are helpful only when users can confirm what’s correct.

Imagining Copilot Beyond the IDE

While GitHub Next experimented with specific features, product teams were thinking about Copilot’s broader trajectory. The ambition: make Copilot ubiquitous across every tool developers use, conversational so natural language can accomplish tasks, and personalized to the context of the individual, project, team, and community.

That combination of technical experimentation and product vision is what shaped Copilot’s evolution from an in-editor pair programmer to a more deeply integrated assistant.

The Pull Request Problem: Content vs. Presentation

Pull requests are central to GitHub—the point of collaboration where teams review and approve code changes. So when researchers Andrew Rice, Don Syme, Devon Rifkin, Matt Rothenberg, Max Schaefer, Albert Ziegler, and Aqeel Siddiqui got access to GPT-4, they focused on bringing AI smarts to the pull request workflow.

The team prototyped several features: automatic code suggestions for reviews, a summarization mode, and test generation. As the March 22 deadline approached, some prototypes weren’t meeting expectations, and the team narrowed its focus to generating pull request summaries.

The early version of Copilot for Pull Requests generated a description and code walkthrough in the first comment of a PR, intended to give reviewers essential context. An internal study with Hubbers didn’t go well—and the problem wasn’t the AI content.

“The developers were concerned that the AI would be wrong,” Rice recalls. But the real issue was the user experience. “You have the content the AI generates and then you have the way that it’s presented to the user and how it interacts with the workflow. At first, we focused a lot on the first bit, the AI-generated content, but it turned out that the second bit was far more crucial in getting this thing to fly.”

The fix wasn’t new model output. The team repackaged the same generated content as a suggestion system, letting developers preview and edit a proposed PR description before posting it. “All of a sudden the feedback changed to ‘wow, these are helpful suggestions,’” Rice says. “The content was exactly the same as before, it was just presented differently.”

Core Takeaways From the Experiment

• Presentation matters as much as generation: AI output is only useful if it fits naturally into the developer’s workflow. Framing generated content as a suggestion rather than an authoritative comment dramatically changed user perception.
• Verifiability is a feature: developers need to be able to see and evaluate what the AI produced. Suggestion systems make it easy to accept, edit, or discard output before it becomes part of the record.
• Spike first, then build: GitHub Next’s approach of rapidly prototyping many ideas before committing to a few allowed the team to find the features that were worth pursuing.
• Start with unique workflows: rather than asking where AI might be generally useful, the team started from what makes GitHub distinct—pull requests—and looked for opportunities to help there.

Accuracy matters less than context

For Rice, the biggest takeaway from GitHub Copilot’s evolution was that how AI output is framed matters more than its raw accuracy. That isn’t an excuse for bad suggestions, but a developer’s tolerance for imperfection exists on a spectrum. When AI output is presented as an editable suggestion rather than an authoritative answer, user behavior changes considerably.

Eddie Aftandilian, a principal researcher behind Copilot for Docs, reached similar conclusions. In late 2022, Aftandilian and Johan Rosenkilde were experimenting with embeddings and vector databases for a different GitHub Copilot prototype. The idea quickly expanded: once GPT-4 access arrived, the retrieval engine could search large documentation corpora and compose results into prompts that produce more topical answers.

“Since GitHub is all about developer tools, we thought, how can we make this into a useful developer tool?” Aftandilian says. Developers spend enormous time digging through docs, and as he puts it, “No one really likes reading documentation!” The opportunity was clear: answer a developer’s question directly instead of forcing another search. “It’s also an area of the development process that we felt was underexplored.”

Early versions of Copilot for Docs were deployed to internal GitHub employees, extending coverage from public docs to GitHub’s own internal documentation. Public preview testing surfaced an interesting pattern in feedback about answer quality.

Since models often return the wrong answer or cite the wrong document, Aftandilian’s team added references and links to other documentation alongside each response. The result: “Developers didn’t mind if the output wasn’t always perfectly correct if the linked references made it easier to evaluate what the AI produced. They were using Copilot for Docs as a search engine.”

Getting real human feedback early was another key lesson for Aftandilian. “One of our conclusions was that you should ship something sooner rather than later to get real, human feedback to drive improvements.”

The user experience must also be designed to absorb AI mistakes. “Initially we were focused on getting everything right, but we soon learned that the chat-like modality of Copilot for Docs makes the answers feel less authoritative and folks are more tolerant of the responses when they point the user in the right direction.”

The 30-minute prototype

At a GitHub Next gathering in Oxford in October 2022, Rosenkilde pitched an idea: use LLMs to help developers work out CLI commands from natural-language descriptions. As he wrapped up his talk, colleague Matt Rothenberg had already built a working application along almost exactly those lines. “By the time my talk ended, he asked if he could show me something, and my mind was just blown,” Rosenkilde recalls.

That half-hour demo became the basis for Copilot for CLI, which launched as a preview in March 2023. It surfaced requested shell commands with a breakdown of each part—no web searches required—but getting there required polishing a rough prototype into something developers could actually use.

Rosenkilde credits much of Copilot for CLI’s success to what Rothenberg did next: rapidly iterating through UX options. “I’m a backend person… Matt was the UX guy, and he iterated extremely quickly through a lot of options.”

The explanation field that accompanies each generated command wasn’t in the original UI. Getting the LLM to produce structured explanations took considerable engineering coaxing. “It’s very unnatural for a language model to produce something that looks like this, I had to hit it with a very large hammer,” Rosenkilde jokes. Without that structure, the model would produce paragraphs that weren’t scannable or focused enough.

The explanation field also serves a security purpose. As Rosenkilde explains, developers can read in natural language “whether the command will change files you didn’t expect to change.” For a small application, every feature has to justify itself. “When you have such a small application, you want every feature to have multiple different uses so that you can package up a lot of complexity in something that visually is very simple.”

Next steps

GitHub continues to refine its AI tools across the platform, treating preview feedback as a core driver of development. Current previews are open through the waitlist for GitHub’s experimental features, and GitHub Copilot itself remains available as a free 30-day trial for individual developers.