The GitHub Blog
type: channel
description: Updates, ideas, and inspiration from GitHub to help developers build and design software.
date: 2026-02-04T19:21:21Z
update period: hourly
update frequency: 1
update base: 2000-01-01T12:00+00:00
generator agent: https://wordpress.org/
items: Pick your agent: Use Claude and Codex on Agent HQ
items: What the fastest-growing tools reveal about how software is being built
items: How to maximize GitHub Copilot’s agentic capabilities
items: From pixels to characters: The engineering behind GitHub Copilot CLI’s animated ASCII banner
items: Year recap and future goals for the GitHub Innovation Graph
items: 7 learnings from Anders Hejlsberg: The architect behind C# and TypeScript
items: Help shape the future of open source in Europe
items: Power agentic workflows in your terminal with GitHub Copilot CLI
items: Build an agent into any app with the GitHub Copilot SDK
items: A cheat sheet to slash commands in GitHub Copilot CLI

Pick your agent: Use Claude and Codex on Agent HQ
type: item
creator: Mario Rodriguez
date: 2026-02-04T17:00:19Z
subject: Company news
subject: News & insights
subject: Agent HQ
subject: AI agents
description: Claude by Anthropic and OpenAI Codex are now available in public preview on GitHub and VS Code with a Copilot Pro+ or Copilot Enterprise subscription. Here's what you need to know and how to get started today. The post Pick your agent: Use Claude and Codex on Agent HQ appeared first on The GitHub Blog.
encoded: Context switching equals friction in software development. Today, we’re removing some of that friction with the latest updates to Agent HQ which lets you run coding agents from multiple providers directly inside GitHub and your editor, keeping context, history, and review attached to your work. Copilot Pro+ and Copilot Enterprise users can now run multiple coding agents directly inside GitHub, GitHub Mobile, and Visual Studio Code (with Copilot CLI support coming soon). That means you can use agents like GitHub Copilot, Claude by Anthropic, and OpenAI Codex (both in public preview) today. With Codex, Claude, and Copilot in Agent HQ, you can move from idea to implementation using different agents for different steps without switching tools or losing context. We’re bringing Claude into GitHub to meet developers where they are. With Agent HQ, Claude can commit code and comment on pull requests, enabling teams to iterate and ship faster and with more confidence. Our goal is to give developers the reasoning power they need, right where they need it. Katelyn Lesse, Head of Platform, Anthropic How to get started When you have a task, you can choose Copilot, Claude, Codex, or a custom agent. You can make them work asynchronously and then review the results on your own time. Each coding agent session consumes one premium request. You can currently start Claude and Codex sessions from github.com, GitHub Mobile, and in VS Code. Claude and Codex must be explicitly enabled in your settings before use. See details on how. Create and view agent sessions on GitHub You can start and manage agent sessions directly from GitHub: Open the Agents tab in any repository where agents are enabled. Enter your request and select an agent using the Copilot icon. Submit the request to start the session. Agents run asynchronously by default. You can follow their progress in real time or review completed sessions later, with detailed logs showing what the agent did and why. Each session produces a…

What the fastest-growing tools reveal about how software is being built
type: item
creator: Dylan Birtolo
date: 2026-02-03T17:00:00Z
subject: News & insights
subject: Octoverse
description: What languages are growing fastest, and why? What about the projects that people are interested in the most? Where are new developers cutting their teeth? Let’s take a look at Octoverse data to find out. The post What the fastest-growing tools reveal about how software is being built appeared first on The GitHub Blog.
encoded: In 2025, software development crossed a quiet threshold. In our latest Octoverse report, we found that the fastest-growing languages, tools, and open source projects on GitHub are no longer about shipping more code. Instead, they’re about reducing friction in a world where AI is helping developers build more, faster. By looking at some of the areas of fastest growth over the past year, we can see how developers are adapting through: The programming languages that are growing most in AI-assisted development workflows. The tools that win when speed and reproducibility matter. The areas where new contributors are showing up (and what helps them stick). Rather than catalog trends, we want to focus on what those signals mean for how software is being built today and what choices you might consider heading into 2026. The elephant in the room: Typescript is the new #1 In August 2025, TypeScript became the most-used language on GitHub, overtaking Python and JavaScript for the first time. Over the past year, TypeScript added more than one million contributors, which was the largest absolute growth of any language on GitHub. <img data-recalc-dims="1" fetchpriority="high" decoding="async" height="576" width="1024" src="https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?resize=1024%2C576" alt="A chart showing the top 10 programming languages on GitHub from 2023 to 2025. TypeScript rises to #1 in 2025, overtaking Python and JavaScript, which move to #2 and #3 respectively. Other top languages include Java, C#, PHP, Shell, C++, HCL, and Go. The chart tracks ranking changes over time on a dark background with colored lines representing each language." class="wp-image-91509" srcset="https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?w=1728 1728w, https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?w=300 300w, https://github.blog/wp-content/uploads/2025/10/octove…

How to maximize GitHub Copilot’s agentic capabilities
type: item
creator: Ari LiVigni
date: 2026-02-02T17:00:00Z
subject: AI & ML
subject: GitHub Copilot
subject: GitHub Skills
description: A senior engineer's guide to architecting and extending Copilot's real-world applications. The post How to maximize GitHub Copilot’s agentic capabilities appeared first on The GitHub Blog.
encoded: Modern engineering work rarely lives in a single file. Real systems evolve across years of incrementally layered decisions—some good, some accidental. A single feature request (“Add tagging to notes,” “Refactor the validation layer,” “Support a new consumer on our API”) often touches controllers, domain models, repositories, migrations, tests, documentation, and deployment strategy. Copilot’s agentic capabilities don’t replace your judgment in these situations—they amplify it. When used well, Copilot becomes a partner in system design, refactoring, modernization, and multi-file coordination. This guide focuses on architecture-aware, multi-step workflows used every day by staff engineers, but written to be accessible for earlier-career engineers who want to understand how senior engineers think—and how Copilot can accelerate their own growth. It draws on four GitHub Skills exercises (linked below), and builds toward a complete, real-world scenario: extending a small modular Notes Service with a tagging subsystem, refactoring a validation layer, designing a safe migration, and modernizing tests. Before you start You’ll get the most out of this guide if you have: GitHub Copilot with agent mode enabled Some familiarity with service-layer architectures (Node, Python, Go—language doesn’t matter Copy a GitHub Skills exercise template to your handle or organization (use the green “Copy Exercise” button) A willingness to let Copilot propose solutions—and the judgment to inspect and challenge them If you’re earlier in your career, don’t worry. Each section explains why these patterns matter and how to practice them safely. Learn interactively at your own pace with GitHub Skills The following free modules map directly to the workflows in this guide: Expand your team with Copilot: multi-step agentic execution Build applications with Copilot (agent mode): task-driven code generation Modernize your legacy codebases with Copilot: refactoring and migrations Customize Your GitHub Co…

From pixels to characters: The engineering behind GitHub Copilot CLI’s animated ASCII banner
type: item
creator: Aaron Winston
date: 2026-01-28T17:00:00Z
subject: Engineering
subject: GitHub Copilot
subject: GitHub CLI
subject: GitHub Copilot CLI
description: Learn how GitHub built an accessible, multi-terminal-safe ASCII animation for the Copilot CLI using custom tooling, ANSI color roles, and advanced terminal engineering. The post From pixels to characters: The engineering behind GitHub Copilot CLI’s animated ASCII banner appeared first on The GitHub Blog.
encoded: Most people think ASCII art is simple, and a nostalgic remnant of the early internet. But when the GitHub Copilot CLI team asked for a small entrance banner for the new command-line experience, they discovered the opposite: An ASCII animation in a real-world terminal is one of the most constrained UI engineering problems you can take on. Part of what makes this even more interesting is the moment we’re in. Over the past year, CLIs have seen a surge of investment as AI-assisted and agentic workflows move directly into the terminal. But unlike the web—where design systems, accessibility standards, and rendering models are well-established—the CLI world is still fragmented. Terminals behave differently, have few shared standards, and offer almost no consistent accessibility guidelines. That reality shaped every engineering decision in this project. Different terminals interpret ANSI color codes differently. Screen readers treat fast-changing characters as noise. Layout engines vary. Buffers flicker. Some users override global colors for accessibility. Others throttle redraw speed. There is no canvas, no compositor, no consistent rendering model, and no standard animation framework. By the numbers 3 seconds of animation ~20 frames ~6,000 lines of TypeScript Dozens of terminal + theme combinations tested So when an animated Copilot mascot flying into the terminal appeared, it looked playful. But behind it was serious engineering work, unexpected complexity, a custom design toolchain, and a tight pairing between a designer and a long-time CLI engineer. That complexity only became fully visible once the system was built. In the end, animating a three-second ASCII banner required over 6,000 lines of TypeScript—most of it dedicated not to visuals, but to handling terminal inconsistencies, accessibility constraints, and maintainable rendering logic. This is the technical story of how it came together. 📦 What’s new in GitHub Copilot CLI GitHub Copilot CLI brings agentic workfl…

Year recap and future goals for the GitHub Innovation Graph
type: item
creator: Kevin Xu
date: 2026-01-28T16:00:00Z
subject: News & insights
subject: Policy
subject: Innovation Graph
subject: open source
description: Discover the latest trends and insights on public software development activity on GitHub with data from the Innovation Graph through Q3 2025. The post Year recap and future goals for the GitHub Innovation Graph appeared first on The GitHub Blog.
encoded: Today’s data release marks our second full year of regular releases since the launch of the GitHub Innovation Graph. The Innovation Graph serves as a stable, regularly updated source for aggregated statistics on public software development activity around the world, informing public policy, strengthening research, guiding funding decisions, and equipping organizations with the evidence needed to build secure and resilient AI systems. Updated bar chart races With our new data release, we’ve updated the bar chart race videos to the git pushes, repositories, developers, and organizations global metrics pages. Let’s take a look back at some of the progress the Innovation Graph has helped drive. Academic papers One of the most rewarding aspects of the past year has been seeing the growing range of research questions addressed with Innovation Graph data. Recent papers have explored everything from global collaboration networks to the institutional foundations of digital capabilities. These studies showcase how network analysis techniques can be applied to Innovation Graph data, in addition to earlier work we referenced last year linking open source to economic value, innovation measurement, labor markets, and AI-driven productivity through other methodologies. Historical Institutions and Modern Digital Capabilities: New Evidence from GitHub in Africa Research by an economist at the Federal Reserve Board uses GitHub data to examine how the density of Protestant mission stations correlates with present-day participation in digital production across African countries. Olana, Deriba, “Historical Institutions and Modern Digital Capabilities: New Evidence from GitHub in Africa” (November 25, 2025). Available at SSRN: https://ssrn.com/abstract=5805622 or http://dx.doi.org/10.2139/ssrn.5805622. The Structure of Cross-National Collaboration in Open-Source Software Development Researchers from MIT, Carnegie Mellon, and the University of Chicago analyze international collaboration p…

7 learnings from Anders Hejlsberg: The architect behind C# and TypeScript
type: item
creator: Aaron Winston
date: 2026-01-27T17:17:28Z
subject: Developer skills
subject: Octoverse
subject: Programming languages & frameworks
subject: Typescript
description: Anders Hejlsberg shares lessons from C# and TypeScript on fast feedback loops, scaling software, open source visibility, and building tools that last. The post 7 learnings from Anders Hejlsberg: The architect behind C# and TypeScript appeared first on The GitHub Blog.
encoded: Anders Hejlsberg’s work has shaped how millions of developers code. Whether or not you recognize his name, you likely have touched his work: He’s the creator of Turbo Pascal and Delphi, the lead architect of C#, and the designer of TypeScript. We sat down with Hejlsberg to discuss his illustrious career and what it’s felt like to watch his innovations stand up to real world pressure. In a long-form conversation, Hejlsberg reflects on what language design looks like once the initial excitement fades, when performance limits appear, when open source becomes unavoidable, and how AI can impact a tool’s original function. What emerges is a set of patterns for building systems that survive contact with scale. Here’s what we learned. Watch the full interview above. Fast feedback matters more than almost anything else Hejlberg’s early instincts were shaped by extreme constraints. In the era of 64KB machines, there was no room for abstraction that did not pull its weight. “You could keep it all in your head,” he recalls. When you typed your code, you wanted to run it immediately. Anders Hejlsberg Turbo Pascal’s impact did not come from the Pascal language itself. It came from shortening the feedback loop. Edit, compile, run, fail, repeat, without touching disk or waiting for tooling to catch up. That tight loop respected developers’ time and attention. The same idea shows up decades later in TypeScript, although in a different form. The language itself is only part of the story. Much of TypeScript’s value comes from its tooling: incremental checking, fast partial results, and language services that respond quickly even on large codebases. The lesson here is not abstract. Developers can apply this directly to how they evaluate and choose tools. Fast feedback changes behavior. When errors surface quickly, developers experiment more, refactor more confidently, and catch problems closer to the moment they are introduced. When feedback is slow or delayed, teams compensate with co…

Help shape the future of open source in Europe
type: item
creator: Mathias Schindler
date: 2026-01-27T14:16:04Z
subject: News & insights
subject: Policy
subject: GitHub Policy
description: Read GitHub’s position on the European Open Digital Ecosystem Strategy and learn how to participate. The post Help shape the future of open source in Europe appeared first on The GitHub Blog.
encoded: At GitHub, we believe that open source is a primary driver of innovation, security, and economic competitiveness. The European Union is currently at a pivotal moment in defining how it supports this ecosystem, and it wants to hear from you, the builders. The European Commission is planning to adopt an open source strategy called “Towards European Open Digital Ecosystems“. This initiative is not about passing new laws; instead the EU is looking to develop a strategic framework and funding measures to help the EU open source sector scale up and become more competitive. This effort aims to strengthen the EU’s technological sovereignty by supporting open source software and hardware across critical sectors like AI, cloud computing, and cybersecurity. We’ve been advocating for this kind of support for a long time. For instance, we previously highlighted the need for a European Sovereign Tech Fund to invest in the maintenance of critical basic open source technologies such as libraries or programming languages. This new strategy is a chance to turn those kinds of ideas into official EU policy. You can read GitHub’s response to the European Commission here. Brand new data from GitHub Innovation Graph shows that the EU is a global open source powerhouse: There are now almost 25 million EU developers on GitHub, who made over 155 million contributions to public projects in the last year alone. The EU wants to help European companies turn open source projects into successful businesses, which is an admirable goal with plenty of opportunities to achieve it. For example, the EU can create better conditions for open source businesses by making it easier for them to participate in public procurement and access the growth capital they need to turn great code into sustainable products. By supporting the business models and infrastructure that surround it, the EU can turn its massive developer talent into long-term economic leadership. It is important to understand, though, that not …

Power agentic workflows in your terminal with GitHub Copilot CLI
type: item
creator: Dylan Birtolo
date: 2026-01-26T18:54:49Z
subject: AI & ML
subject: GitHub Copilot
subject: GitHub CLI
subject: GitHub Copilot CLI
description: Explore the GitHub Copilot CLI and try interacting with Copilot directly from your terminal. The post Power agentic workflows in your terminal with GitHub Copilot CLI appeared first on The GitHub Blog.
encoded: Since GitHub Copilot CLI launched in public preview in September 2025, we’ve been shipping frequent regular updates and advancements. Below, we’ll show you what makes Copilot CLI so special, why it’s great to have an agentic AI assistant right in your terminal, and how we’re building the Copilot CLI to connect more broadly to the rest of the GitHub Copilot ecosystem. Note: This blog is based on a GitHub Universe 2025 presentation. Watch below to see the functionality in action. 👇 Bringing the CLI to where you work If you use GitHub Copilot in VS Code or in a similar IDE, consider how often you spend your entire working day in the IDE, trying to avoid doing anything in any other working environment. We kept this thought top of mind when we conceptualized the GitHub Copilot CLI. Developers spend time using ssh to connect to servers, debug things in containers, triage issues on github.com, manage CI/CD pipelines, and write deployment scripts. There’s a lot of work that doesn’t neatly map into an individual IDE or even a multipurpose code editor like VS Code. To make sure that we brought the GitHub CLI to developers where they already are, it made sense to go through the terminal. After all, the terminal transcends all the different applications on your computer and, in the right hands, is where you can accomplish any task with fine-grained control. Bringing GitHub Copilot into the CLI and giving it access to the broader GitHub ecosystem lets you spend more time getting your work done, and less time hunting down man pages and scouring through documentation to learn how to do something. Showcasing the GitHub CLI functionality Often, the first step with a project is getting up to speed on it. Let’s consider an example where you’re filling in for a friend on a project, but you don’t know anything about it—you don’t know the codebase, the language, or even the framework. You’ve received a request to update a feedback form because the UI elements are not laid out correctly. …

Build an agent into any app with the GitHub Copilot SDK
type: item
creator: Mario Rodriguez
date: 2026-01-22T15:01:44Z
subject: AI & ML
subject: Company news
subject: GitHub Copilot
subject: News & insights
subject: GitHub Copilot CLI
subject: GitHub Copilot SDK
subject: SDK
description: Now in technical preview, the GitHub Copilot SDK can plan, invoke tools, edit files, and run commands as a programmable layer you can use in any application. The post Build an agent into any app with the GitHub Copilot SDK appeared first on The GitHub Blog.
encoded: Building agentic workflows from scratch is hard. You have to manage context across turns, orchestrate tools and commands, route between models, integrate MCP servers, and think through permissions, safety boundaries, and failure modes. Even before you reach your actual product logic, you’ve already built a small platform. GitHub Copilot SDK (now in technical preview) removes that burden. It allows you to take the same Copilot agentic core that powers GitHub Copilot CLI and embed it in any application. This gives you programmatic access to the same production-tested execution loop that powers GitHub Copilot CLI. That means instead of wiring your own planner, tool loop, and runtime, you can embed that agentic loop directly into your application and build on top of it for any use case. You also get Copilot CLI’s support for multiple AI models, custom tool definitions, MCP server integration, GitHub authentication, and real-time streaming. How to get started We’re starting with support for Node.js, Python, Go, and .NET. You can use your existing GitHub Copilot subscription or bring your own key. The github/copilot-sdk repository includes: Setup instructions Starter examples SDK references for each supported language A good first step is to define a single task like updating files, running a command, or generating a structured output and letting Copilot plan and execute steps while your application supplies domain-specific tools and constraints. Here’s a short code snippet to preview how you can call the SDK in TypeScript: import { CopilotClient } from "@github/copilot-sdk"; const client = new CopilotClient(); await client.start(); const session = await client.createSession({ model: "gpt-5", }); await session.send({ prompt: "Hello, world!" }); Visit github/copilot-sdk to start building. What’s new in GitHub Copilot CLI Copilot CLI lets you plan projects or features, modify files, run commands, use custom agents, delegate tasks to the cloud, and more, all without leaving …

A cheat sheet to slash commands in GitHub Copilot CLI
type: item
creator: Jacklyn Carroll
date: 2026-01-21T17:09:10Z
subject: AI & ML
subject: GitHub Copilot
subject: GitHub CLI
subject: GitHub Copilot CLI
subject: slash commands
description: Run tests, fix code, and get support—right in your workflow. Stay focused and let Copilot handle the busywork. The post A cheat sheet to slash commands in GitHub Copilot CLI appeared first on The GitHub Blog.
encoded: Do you ever feel like you’re spending more time moving between different tools than you are writing code? If you thrive in the terminal and want faster, more predictable ways to run tests, fix code, and manage context, Copilot CLI slash commands give you that control without breaking your flow. You can use slash commands to perform a variety of tasks like configuring which AI model to use or setting up an MCP server, or even sharing your session externally. Slash commands offer fast, repeatable actions without needing to craft a new prompt each time. TL;DR: See all the slash commands and what they do at the bottom of this post. 😉 What are slash commands? A slash command is a simple instruction, like /clear or /session, that tells Copilot exactly what you want to do. They are prefixed with a / and instantly trigger Copilot to carry out context-aware actions. To start using slash commands , open Copilot CLI and type / to see a list of available commands. How to use slash commands Type / in the Copilot CLI to see a list of available slash commands and their descriptions. You can also use /help to get more details about what each command does and how to use it. For instructions and examples, keep scrolling! Start here (two minutes) Open Copilot CLI Type /help to see available commands Run /clear to reset context Run /cwd to confirm Copilot is scoped to the right directory. You can jump to the sections below based on what you’re trying to do. Learn more in our docs > In addition to Copilot CLI, you can use slash commands across Copilot Chat and with agent mode, too. Why use slash commands? As developers, we want tools that work fast in the terminal. Slash commands in Copilot CLI do just that. Instead of writing a new prompt for each task, you use quick, explicit, and repeatable commands directly in your workflow. In practice, they help with: Speed and predictability: With slash commands, Copilot’s actions are more transparent and predictable. Unlike natural language prom…