# GitHub Next Explorations Rahul Pandita, GitHub Next | AI Engineer World's Fair 2024 | 18:18 Source: https://www.youtube.com/watch?v=1oySeF37SZc Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks. Page: https://aietalks.com/talks/github-next-explorations Published: 2025-02-08 Tags: agent-skills, agents, code-generation, copilots, human-in-the-loop ## TL;DR - GitHub Next uses prototypes, internal dogfooding, tech previews, and user feedback to decide which AI software engineering ideas should become products. - Next Edit Suggestions extends Copilot beyond the current cursor by suggesting related changes elsewhere in the program. - Copilot Workspace helps developers move from an issue to a specification, plan, implementation, and verification while keeping control of the problem-solving process. ## Summary Rahul Pandita explains how GitHub Next explores possible futures for software engineering. The group operates outside GitHub's regular product organization, builds functional prototypes, tests them internally, releases some as tech previews, and shelves ideas that do not produce the right signals. He then presents Next Edit Suggestions, which predicts related edits after a developer changes existing code. A demo shows a new Python parameter leading to updates in a method definition, arguments, and documentation. The main demonstration covers Copilot Workspace. It starts from a GitHub issue, generates a current and proposed specification, creates a file-change plan, implements the changes, and lets the developer revise the result through chat or direct editing. An integrated terminal and live preview help the developer check whether the generated code works. Pandita presents Workspace as support for the whole software development inner loop, with developers retaining control and using AI as a thought partner. ## Key ideas ### GitHub Next explores software engineering ideas outside the normal product process [00:34](https://www.youtube.com/watch?v=1oySeF37SZc&t=34s) GitHub Next is a group of about 20 researchers, senior developers, and tool builders who report directly to GitHub's CEO. Its purpose is to explore the future of software engineering and pass the results to product and development teams. Pandita compares this work with the period after electric motors appeared in the 1880s. Factories needed decades of experimentation before electric power became standard because people had to learn how to redesign work around the new technology. GitHub Next follows the same pattern with AI: it rapidly prototypes, experiments, and learns instead of pretending that the future is already known. ### Explorations move through increasingly public tests and can be stopped at any stage [06:48](https://www.youtube.com/watch?v=1oySeF37SZc&t=408s) An idea at GitHub Next often begins as a functional prototype. The team dogfoods it internally, then tests it across the company, and may release it as a tech preview to early adopters. Feedback from those stages determines whether it has a chance to become a product. The team can also kill or shelve an exploration at any point when the signals are wrong. Pandita names Copilot for CLI, Copilot Voice, GitHub Blocks, and Speckle Lang as examples of explorations. Some became products, some were absorbed into existing products, and others were shelved while their lessons were retained. ### Next Edit Suggestions predicts changes beyond the current cursor [06:03](https://www.youtube.com/watch?v=1oySeF37SZc&t=363s) Traditional Copilot ghost text is good at creating code at the current context, but developers often edit existing code across several locations. Next Edit Suggestions addresses that pattern by suggesting what else needs to change in the program. In the demo, Pandita adds a parameter to a Python program. The system proposes updating the method definition, adding the required arguments, and changing documentation so it matches the code. GitHub Next is still testing how to present these suggestions, including cases where the next edit is outside the visible viewport or in a file that is not open. ### The team is tuning Next Edit Suggestions for accuracy before release [07:51](https://www.youtube.com/watch?v=1oySeF37SZc&t=471s) Pandita says GitHub Next is investigating whether ghost text is the right presentation for edits that occur in several places. It is also considering how to show a suggestion when its location is not visible or when the relevant file is closed. The team is fine-tuning models for this specific use case because the suggestions need to be accurate and useful. After the exploration meets the team's internal dogfooding standard, it may appear as a standalone tech preview or as part of another product in an IDE. ### Copilot Workspace covers the full software development inner loop [08:50](https://www.youtube.com/watch?v=1oySeF37SZc&t=530s) Pandita describes software development as a loop that starts with understanding a task, the available frameworks and languages, and the existing code. The developer then decides what the finished result should look like, plans the required file changes, and implements them. GitHub Next wanted AI to help across all of these stages. Copilot Workspace grew from several separate explorations, including using natural language as a functional specification and improving completions with runtime information. User feedback brought these efforts together into one larger exploration. ### Workspace was shaped around trust, problem solving, and developer control [10:56](https://www.youtube.com/watch?v=1oySeF37SZc&t=656s) In conversations with developers, GitHub Next heard that getting started on an assigned issue was often the hardest part. Developers also questioned whether they could trust AI output and wanted to keep the problem-solving part of development. They described AI as a thought partner, sparring partner, or second brain. Copilot Workspace responds with a one-click proposal, a built-in runtime for checking generated code, an environment designed for iteration, and ways to share work through a pull request or with colleagues. Pandita repeatedly frames the developer as remaining in control. ### Workspace turns an issue into editable specifications, a plan, and code [12:05](https://www.youtube.com/watch?v=1oySeF37SZc&t=725s) In the demo, Pandita opens an issue asking for a Rust example in GitHub's Monospace font playground. Copilot Workspace generates the current specification, identifies the target state, and proposes updates to package.json and other files. It then produces a plan naming the files to change and implements that plan. The developer can revise the result at any point, such as asking Workspace to add Rust to language mappings or add code documentation. Chat can also target a specific location. The workflow keeps the generated proposal open to correction instead of treating it as final. ### Runtime tools and previews give developers ways to check generated work [15:02](https://www.youtube.com/watch?v=1oySeF37SZc&t=902s) Workspace includes an integrated terminal where the developer can install and run the repository. When the first suggested command is wrong, Pandita edits it and runs the command he actually wants. The terminal output shows that the code compiles. A live preview then shows the updated website with the Rust example. Workspace can also synthesize terminal commands from natural language. Pandita gives mobile use as one reason for this design, since entering shell symbols on a phone can be tedious. He presents runtime support as a way to verify and iterate on AI-generated changes. ## Notable quotes - "Our charter is to explore the future of software engineering." (03:50) - "What if ghost text was good at that as well?" (06:46) - "Developers are in control, not the other way around." (11:09) - "We do not know what the future of AI is, but what we know is explorations is the way to get it." (17:20) ## Tools & references mentioned - GitHub Next - GitHub Copilot - Copilot for CLI - Copilot Voice - GitHub Blocks - Speckle Lang - Copilot Next Edit Suggestions - Copilot Workspace - Monospace - Andrew Ng - Devin ## Who should watch - You are building AI features for developers and want a concrete model for moving from an internal prototype to a product or a shelved experiment. - You are evaluating coding agents and want to see how specifications, plans, implementation, runtime checks, and previews can fit into one workflow. - You care about keeping developers responsible for decisions while using AI to get started and revise code across a repository. ## Related talks - [GitHub Copilot: The World's Most Widely Adopted AI Developer Tool](https://aietalks.com/talks/github-copilot-the-worlds-most-widely-adopted-ai-developer-tool) (Dave Bernes, GitHub, 29:49) - [The AI Evolution](https://aietalks.com/talks/the-ai-evolution) (Mario Rodriguez, GitHub, 19:32) - [The Agent Awakens: Collaborative Development with Copilot](https://aietalks.com/talks/the-agent-awakens-collaborative-development-with-copilot) (Christopher Harrison & John Peck, GitHub, 1:04:06) - [Open Models track](https://aietalks.com/talks/open-models-track) (Britney Walker, Charles River Ventures & Rahul Pandita, GitHub & Kevin Hwang, Codium & Michael Truell, Cursor, 17:26) - [GitHub Copilot: The World's Most Widely Adopted AI Developer Tool](https://aietalks.com/talks/github-copilot-the-worlds-most-widely-adopted-ai-developer-tool-skituuev) (Christina Warren, GitHub & Dave, GitHub and Azure DevOps Teams & Alex, GitHub for Startups & Harold, Microsoft, 1:19:45)