The GitHub Blog
type: channel
description: Updates, ideas, and inspiration from GitHub to help developers build and design software.
date: 2025-12-12T20:43:39Z
update period: hourly
update frequency: 1
update base: 2000-01-01T12:00+00:00
generator agent: https://wordpress.org/
items: The future of AI-powered software optimization (and how it can help your team)
items: Let’s talk about GitHub Actions
items: GitHub Availability Report: November 2025
items: MCP joins the Linux Foundation: What this means for developers building the next era of AI tools and agents
items: Speed is nothing without control: How to keep quality high in the AI era
items: The new identity of a developer: What changes and what doesn’t in the AI era
items: How to use GitHub Copilot Spaces to debug issues faster
items: Your stack, your rules: Introducing custom agents in GitHub Copilot for observability, IaC, and security
items: “The local-first rebellion”: How Home Assistant became the most important project in your house
items: How to orchestrate agents using mission control

The future of AI-powered software optimization (and how it can help your team)
type: item
creator: Paull Young
date: 2025-12-12T20:43:37Z
subject: News & insights
subject: Policy
subject: Continuous Efficiency
description: We envision the future of AI-enabled tooling to look like near-effortless engineering for sustainability. We call it Continuous Efficiency. The post The future of AI-powered software optimization (and how it can help your team) appeared first on The GitHub Blog.
encoded: When was the last time you heard someone ask in a standup, “How could we do this more sustainably?” Topics like green software and carbon efficiency are unfortunately rarely at the top of busy development teams’ priority lists. What’s more, there are very few “green software practitioners” out there. But we believe we’re at a unique moment in time where this can all change. The next generation of AI-enabled developer tooling has the opportunity to create near-effortless, always-on engineering for sustainability. The GitHub Next and GitHub Sustainability teams have been collaborating to prove this concept and value through a series of internal and external pilot projects. We call it Continuous Efficiency. Making the case for Continuous Efficiency We believe that once it’s ready for broader adoption, Continuous Efficiency will have the potential to make a significant positive impact for developers, businesses, and sustainability. For developers Digital sustainability and green software are intrinsically aligned to “efficiency,” which is at the core of software engineering. Many developers would benefit from performant software, better standardization of code, change quality assurance, and more. For businesses Building for sustainability has measurable business value, including: Reducing power and resource consumption Increasing efficiency Better code quality Improved user experience Lower costs Despite this, sustainability rarely makes it onto the roadmap, priority list, or even the backlog. But imagine a world in which the codebase could continuously improve itself… <img data-recalc-dims="1" fetchpriority="high" decoding="async" height="320" width="1024" src="https://github.blog/wp-content/uploads/2025/12/image1_c8a727.png?resize=1024%2C320" alt="A graphic showing Continuous Efficiency = Green Software + Continuous AI" class="wp-image-92828" srcset="https://github.blog/wp-content/uploads/2025/12/image1_c8a727.png?w=1324 1324w, https://github.blog/wp-content/uploads/2…

Let’s talk about GitHub Actions
type: item
creator: Ben De St Paer-Gotch
date: 2025-12-11T17:40:52Z
subject: News & insights
subject: Product
subject: CI/CD
subject: community
subject: GitHub Actions
subject: product feedback
description: A look at how we rebuilt GitHub Actions’ core architecture and shipped long-requested upgrades to improve performance, workflow flexibility, reliability, and everyday developer experience. The post Let’s talk about GitHub Actions appeared first on The GitHub Blog.
encoded: GitHub Actions has grown massively since its release in 2018; in 2025 alone, developers used 11.5 billion GitHub Actions minutes in public and open source projects, up 35% year over year from 2024. At the same time, this has not been without its growing pains, and you’ve made clear to us what improvements matter most: faster builds, improved security, better caching, more workflow flexibility, and rock-solid reliability. Meeting that level of demand first required a deliberate investment in re-architecting the core backend services powering every GitHub Actions job and runner. This was a substantial effort that laid the foundation for the long-term performance, scalability, and feature delivery you’ve been asking for. That new architecture is rolled out, powering 71 million jobs per day and giving us deeper visibility into developer experience across the platform. With that work behind us, we shift our attention back to your top requests for much needed, long-standing quality-of-life improvements. Below, we’ll walk through what we’ve shipped this year, how you can get started with these upgrades today, and what’s coming in 2026. Let’s jump in. Rebuilding the core of GitHub Actions In early 2024, the GitHub Actions team faced a problem. The platform was running about 23 million jobs per day, but month-over-month growth made one thing clear: our existing architecture couldn’t reliably support our growth curve. In order to increase feature velocity, we first needed to improve reliability and modernize the legacy frameworks that supported GitHub Actions. The solution? Re-architect the core backend services powering GitHub Actions jobs and runners. Our goals were to improve uptime and resilience against infrastructure issues, improve performance and reduce internal throttles, and leverage GitHub’s broader platform investments and developer experience improvements. We aimed to scale 10x over existing usage. This effort was a big bet and consumed a significant part of our …

GitHub Availability Report: November 2025
type: item
creator: Jakub Oleksy
date: 2025-12-11T16:03:53Z
subject: Company news
subject: News & insights
subject: GitHub Availability Report
description: In November, we experienced three incidents that resulted in degraded performance across GitHub services. The post GitHub Availability Report: November 2025 appeared first on The GitHub Blog.
encoded: In November, we experienced three incidents that resulted in degraded performance across GitHub services. November 17 16:52 UTC (lasting 2 hours and 16 minutes) On November 17, 2025, from 16:52 to 19:08 UTC, Dependabot was hitting a rate limit in GitHub Container Registry (GHCR) and was unable to complete about 57% of jobs within SLO. To mitigate the issue, we lowered the rate at which Dependabot started jobs and increased the GHCR rate limit. This mitigated the circumstances and led to the resolution of the incident. Longer term, we’re adding new monitors and alerts to help prevent this in the future. November 18 20:30 UTC (lasting 1 hour and 4 minutes) On November 18, 2025, from 20:30 to 21:34 UTC, we experienced failures on all Git operations, including both SSH and HTTP Git client interactions, as well as raw file access. These failures also impacted products that rely on Git operations. The root cause was an expired TLS certificate used for internal service-to-service communication. We mitigated the incident by replacing the expired certificate and restarting impacted services. Once those services were restarted we saw a full recovery. We have updated our alerting to cover the expired certificate, and we are performing an audit of other certificates in this area to ensure they also have the proper alerting and automation before expiration. In parallel, we are accelerating efforts to eliminate our remaining manually managed certificates, ensuring all service-to-service communication is fully automated. November 28 05:59 UTC (lasting 2 hours and 24 minutes) On November 28, 2025, between approximately 05:59 and 08:24 UTC, Copilot experienced an outage affecting the Claude Sonnet 4.5 model. Users attempting to use this model received an HTTP 400 error indicating no model was available until an alternative model was selected. Other models were not impacted. The issue was caused by a misconfiguration deployed to an internal service, which made Claude Sonnet 4.5 erron…

MCP joins the Linux Foundation: What this means for developers building the next era of AI tools and agents
type: item
creator: Martin Woodward
date: 2025-12-09T21:00:13Z
subject: Maintainers
subject: Open Source
subject: agentic AI
subject: agentic workflows
subject: Linux Foundation
subject: MCP
subject: open source
description: MCP is moving to the Linux Foundation. Here's how that will affect developers. The post MCP joins the Linux Foundation: What this means for developers building the next era of AI tools and agents appeared first on The GitHub Blog.
encoded: Over the past year, AI development has exploded. More than 1.1 million public GitHub repositories now import an LLM SDK (+178% YoY), and developers created nearly 700,000 new AI repositories, according to this year’s Octoverse report. Agentic tools like vllm, ollama, continue, aider, ragflow, and cline are quickly becoming part of the modern developer stack. As this ecosystem expands, we’ve seen a growing need to connect models to external tools and systems—securely, consistently, and across platforms. That’s the gap the Model Context Protocol (MCP) has rapidly filled. Born as an open source idea inside Anthropic, MCP grew quickly because it was open from the very beginning and designed for the community to extend, adopt, and shape together. That openness is a core reason it became one of the fastest-growing standards in the industry. That also allowed companies like GitHub and Microsoft to join in and help build out the standard. Now, Anthropic is donating MCP to the Agentic AI Foundation, which will be managed by the Linux Foundation, and the protocol is entering a new phase of shared stewardship. This will provide developers with a foundation for long-term tooling, production agents, and enterprise systems. This is exciting for those of us who have been involved in the MCP community. And given our long-term support of the Linux Foundation, we are hugely supportive of this move. The past year has seen incredible growth and change for MCP. I thought it would be great to review how MCP got here, and what its transition to the Linux Foundation means for the next wave of AI development. Before MCP: Fragmented APIs and brittle integrations LLMs started as isolated systems. You sent them prompts and got responses back. We would use patterns like retrieval-augmented generation (RAG) to help us bring in data to give more context to the LLM, but that was limited. OpenAI’s introduction of function calling brought about a huge change as, for the first time, you could call an…

Speed is nothing without control: How to keep quality high in the AI era
type: item
creator: Gwen Davis
date: 2025-12-09T17:00:00Z
subject: AI & ML
subject: Generative AI
subject: generative AI
description: AI can help you build faster than ever, but it can also produce bugs, issues, and problems. Use these strategies to keep your speed without losing control of your code. The post Speed is nothing without control: How to keep quality high in the AI era appeared first on The GitHub Blog.
encoded: What’s the point of moving faster if you can’t trust the code you’re shipping? We’ve all been using AI in our workflows for a while now, and there’s no denying how much faster everyday development has become. Tasks that once took hours now finish in minutes. Entire features come together before you’ve even finished your morning coffee. But we’ve also experienced the other side of that speed: when AI is used without clear direction or guardrails, it can generate what’s often called AI slop—semi-functional code stitched together without context, quietly piling up bugs, broken imports, and technical debt. In this new era, being fast isn’t enough. Precision and quality are what set teams apart. “The best drivers aren’t the ones who simply go the fastest, but the ones who stay smooth and in control at high speed,” said Marcelo Oliveira, GitHub VP of product at GitHub Universe 2025. “Speed and control aren’t trade-offs. They reinforce each other.” So how do you get the best of both? How do you move fast and keep your code clean, reliable, and firmly under your direction? Here are three essential strategies: Tip #1: Treat speed and quality as a package deal It’s very easy to accept AI-generated code that appears polished but hides underlying issues. However, speed without quality doesn’t help you ship faster, it just increases the risk of issues compounding down the road. That’s why the teams and organizations that succeed are the ones that pair AI-driven velocity with real guardrails. And that’s exactly what GitHub Code Quality (currently in public preview) helps you do. GitHub Code Quality is an AI- and CodeQL-powered analysis tool that surfaces maintainability issues, reliability risks, and technical debt across your codebase, right as you work. Here’s how to start using it: Enable with one click Turn it on at the repository level and GitHub will analyze your code using a combination of CodeQL and LLM-based detection. This will give you a clear view of the maintainabili…

The new identity of a developer: What changes and what doesn’t in the AI era
type: item
creator: Eirini Kalliamvakou
date: 2025-12-08T18:15:17Z
subject: News & insights
subject: Octoverse
subject: AI
subject: developer experience
subject: developer tools
description: Discover how advanced AI users are redefining software development—shifting from code producers to strategic orchestrators—through delegation, verification, and a new era of AI-fluent engineering. The post The new identity of a developer: What changes and what doesn’t in the AI era appeared first on The GitHub Blog.
encoded: For the past four years, the conversation about AI and software development has moved faster than most people can track. Every week, there is a new tool, a new benchmark, a new paper, or a new claim about what AI will or won’t replace. There is certainly noise, but even if sometimes data seems inconclusive or contradictory, we still know more now than three years ago about AI adoption. With four years of AI adoption under our belt, we are also able to start seeing the shift in what it means to be a software developer. I lead key research initiatives at GitHub where I focus especially on understanding developers’ behavior, sentiment, and motivations. The time we are in with AI is pivotal, and I interview developers regularly to capture their current perspective. Most recently I conducted interviews to understand how developers see their identity, work, and preferences change as they work more closely than ever with AI. The TL;DR? The developers who have gone furthest with AI are working differently. They describe their role less as “code producer” and more as “creative director of code,” where the core skill is not implementation, but orchestration and verification. Let’s dive in for the more detailed findings, alongside key stats from the 2025 Octoverse report. What were the interviews about, and who did we recruit? As developers work more with AI and get familiar with its capabilities, their relationship with coding—an activity central to the developer identity—changes. How do developers feel about that? What is their new role as developers, and what skills are important? In our interviews, we heard from 22 advanced users of AI about their workflows, how they arrived at them, and their outlook on AI-assisted software development. We define “advanced AI users” as developers who use AI for the majority of their coding, draw on several AI tools in parallel, and apply AI across a wide range of development tasks. We provide a more detailed note on who we recruited at th…

How to use GitHub Copilot Spaces to debug issues faster
type: item
creator: Andrea Griffiths
date: 2025-12-04T20:35:36Z
subject: AI & ML
subject: GitHub Copilot
subject: GitHub Checkout
subject: GitHub Copilot Spaces
description: Follow this step-by-step guide to learn how to debug your issues using GitHub Copilot Spaces and Copilot coding agent. The post How to use GitHub Copilot Spaces to debug issues faster appeared first on The GitHub Blog.
encoded: Every developer knows this pain: you open an issue, and before you can write a single line of code, you’re hunting. You’re digging through old pull requests, searching for that design doc from three months ago, trying to remember which file has the security guidelines. That hunting phase? It takes forever. And it’s not even the actual work. And even if you want to bring AI into the picture, GitHub Copilot still needs the same thing you do: context. Without it, you get generic answers that don’t understand your codebase. GitHub Copilot Spaces fixes that. Spaces gives GitHub Copilot the project knowledge it needs—files, pull requests, issues, repos—so its responses are grounded in your actual code, not guesses. Are you a visual learner? Watch the full demo below. 👇 What is a space, again? Think of a space as a project knowledge bundle. You curate the files, docs, and decisions that matter for your project, and Copilot uses all of that when generating plans, explanations, or pull requests. You can: Add entire repositories or specific files, pull requests and issues (just paste the URL) Include text content like notes, video transcripts, or Slack messages Add design docs and architecture decisions Trigger Copilot coding agent directly from the space Use the space in your IDE through the GitHub MCP server The best part? Link it once and forget about it. Spaces automatically stay synced with the linked content. When your codebase updates, your space updates too. How to debug issues with spaces: 1. Start with an issue A contributor opened an issue reporting an unsafe usage of check_call in your project. As a maintainer, you might not know the best way to fix it immediately. On your own, you’d start by searching the repo, checking past pull requests, and combing through security guidelines just to figure out where to begin. With Spaces, you don’t have to do that manually. Create a space, add the issue and the key files or docs, and let Copilot reason across everything at on…

Your stack, your rules: Introducing custom agents in GitHub Copilot for observability, IaC, and security
type: item
creator: Griffin Ashe
date: 2025-12-03T17:00:45Z
subject: AI & ML
subject: Generative AI
subject: GitHub Copilot
subject: News & insights
subject: Product
subject: agentic AI
subject: custom agents
description: Use partner-built Copilot agents to debug, secure, and automate engineering workflows across your terminal, editor, and github.com. The post Your stack, your rules: Introducing custom agents in GitHub Copilot for observability, IaC, and security appeared first on The GitHub Blog.
encoded: Every engineering team has its unwritten rules. How you structure Terraform modules. Which dashboards you trust. How database migrations must be handled (never at midnight). And your work stretches across more than your editor into observability, security, CI/CD, and countless third-party tools. GitHub Copilot isn’t just here to help you write code. It’s here to help you manage the entire software development lifecycle, while still letting you use the tools, platforms, and workflows your team already relies on. Custom agents bring that full workflow into Copilot. We’re introducing a growing ecosystem of partner-built custom agents for the GitHub Copilot coding agent (plus the option to create your own). These agents understand your tools, workflows, and standards—and they work everywhere Copilot works: In your terminal through Copilot CLI for fast, end-to-end workflows In VS Code with Copilot Chat In github.com in the Copilot panel Let’s jump in. Run custom agents in the GitHub Copilot CLI Copilot CLI is the fastest way to run multi-step tasks, automate workflows, and integrate agents into scripts or CI. If you live in the terminal, custom agents feel like native extensions of your workflow. Get started with Copilot CLI > What custom agents actually are Custom agents are Markdown-defined domain experts that extend the Copilot coding agent across your tools and workflows. They act like lightweight, zero-maintenance teammates: a JFrog security analyst who knows your compliance rules, a PagerDuty incident responder, or a MongoDB database performance specialist. Defining one looks like this: --- name: readme-specialist description: Expert at creating and maintaining high-quality README documentation --- You are a documentation specialist focused on README files. Your expertise includes: - Creating clear, structured README files following best practices - Including all essential sections: installation, usage, contributing, license - Writing examples that are practical an…

“The local-first rebellion”: How Home Assistant became the most important project in your house
type: item
creator: Andrea Griffiths
date: 2025-12-02T17:19:32Z
subject: Maintainers
subject: Octoverse
subject: Open Source
subject: generative AI
subject: Home Assistant
subject: IoT
subject: open source
subject: python
description: Learn how one of GitHub’s fastest-growing open source projects is redefining smart homes without the cloud. The post “The local-first rebellion”: How Home Assistant became the most important project in your house appeared first on The GitHub Blog.
encoded: Franck Nijhof—better known as Frenck—is one of those maintainers who ended up at the center of a massive open source project not because he chased the spotlight, but because he helped hold together one of the most active, culturally important, and technically demanding open source ecosystems on the planet. As a lead of Home Assistant and a GitHub Star, Frenck guides the project that didn’t just grow. It exploded. This year’s Octoverse report confirms it: Home Assistant was one of the fastest-growing open source projects by contributors, ranking alongside AI infrastructure giants like vLLM, Ollama, and Transformers. It also appeared in the top projects attracting first-time contributors, sitting beside massive developer platforms such as VS Code. In a year dominated by AI tooling, agentic workflows, and typed language growth, Home Assistant stood out as something else entirely: an open source system for the physical world that grew at an AI-era pace. The scale is wild. Home Assistant is now running in more than 2 million households, orchestrating everything from thermostats and door locks to motion sensors and lighting. All on users’ own hardware, not the cloud. The contributor base behind that growth is just as remarkable: 21,000 contributors in a single year, feeding into one of GitHub’s most lively ecosystems at a time when a new developer joins GitHub every second. In our podcast interview, Frenck explains it almost casually. Home Assistant is a free and open source home automation platform. It allows you to connect all your devices together, regardless of the brands they’re from… And it runs locally. Franck Nijhof, lead of Home Assistant He smiles when he describes just how accessible it is. “Flash Home Assistant to an SD card, put it in, and it will start scanning your home,” he says. This is the paradox that makes Home Assistant compelling to developers: it’s simple to use, but technically enormous. A local-first, globally maintained automation engine for the …

How to orchestrate agents using mission control
type: item
creator: Matt Nigh
date: 2025-12-01T17:00:00Z
subject: AI & ML
subject: GitHub Copilot
subject: AI agents
subject: GitHub Copilot coding agent
subject: mission control
description: Run multiple Copilot agents from one place. Learn prompt techniques, how to spot drift early, and how to review agent work efficiently. The post How to orchestrate agents using mission control appeared first on The GitHub Blog.
encoded: We recently shipped Agent HQ’s mission control, a unified interface for managing GitHub Copilot coding agent tasks. Now, you can now assign tasks to Copilot across repos, pick a custom agent, watch real‑time session logs, steer mid-run (pause, refine, or restart), and jump straight into the resulting pull requests—all in one place. Instead of bouncing between pages to see status, rationale, and changes, mission control centralizes assignment, oversight, and review. Having the tool is one thing. Knowing how to use it effectively is another. This guide shows you how to orchestrate multiple agents, when to intervene, and how to review their work efficiently. Being great at orchestrating agents means unblocking parallel work in the same timeframe you’d spend on one task, stepping in when logs show drift, tests fail, or scope creeps. The mental model shift From sequential to parallel If you’re already used to working with an agent one at a time, you know it’s inherently sequential. You submit a prompt, wait for a response, review it, make adjustments, and move to the next task. Mission control changes this. You can kick off multiple tasks in minutes—across one repo or many. Previously, you’d navigate to different repos, open issues in each one, and assign Copilot separately. Now you can enter prompts in one place, and Copilot coding agent goes to work across all of them. That being said, there is a trade-off to keep in mind: Instead of each task taking30 seconds to a few minutes to complete, your agents might spend a few minutes to an hour on a draft. But you’re no longer just waiting. You’re orchestrating. When to stay sequential Not everything belongs in parallel. Use sequential workflows when: Tasks have dependencies You’re exploring unfamiliar territory Complex problems require validating assumptions between steps When assigning multiple tasks from the same repo, consider overlap. Agents working in parallel can create merge conflicts if they touch the same files. Be …