OCT 23, 2026
EngBrief
Search⌘K
LatestTopicsSourcesSaved
Eng&Brief

Engineering insights from the world's best tech companies, curated and summarized.

Weekly brief

Browse

TopicsSourcesFavorites

More

SearchRSS Feed
© 2026 EngBriefUpdated every 4 hours
← Sources
github.blog icon
Developer Tools

GitHub Engineering Blog

29 articles on EngBrief

GitHub Engineering shares how the world's largest code hosting platform is built and maintained. Posts cover developer tools, code search at scale, CI/CD infrastructure, security engineering, and the platform architecture serving 100M+ developers.

Developer ToolsPlatform EngineeringSecurityCode Search
Visit blog →

Latest Articles

GitHub1d ago

The bridge to agent-scale Git infrastructure

We moved a copy of 99.99999% of GitHub's repositories to Azure. Here's how per-reference quorums will bring over the rest, and how object storage lets reads...

DevToolsPlatform
1 min
GitHub7d ago

Staying Evergreen: How we automated secure access and repo hygiene in a shared org

Put native GitHub features to work to review outside collaborator access and archive stale repositories. The post Staying Evergreen: How we automated secure...

DevToolsPlatform
1 min
GitHub8d ago

From 2,500 requests to 24: Rebuilding star history without the stargazers

Our new repo star history API now provides trends without returning individual identities or requiring unbounded database work. These are the engineering...

DevToolsPlatform
1 min
GitHub16d ago

Building Git infrastructure for agent-scale development

We're rebuilding GitHub's Git infrastructure while GitHub keeps running, creating a foundation for agent-scale software development. The post Building Git...

DevToolsPlatform
1 min
GitHub27d ago

Improving site performance by shipping more CSS

A look at how a design system shipped major changes without breaking the world. The post Improving site performance by shipping more CSS appeared first on The...

DevToolsPlatform
1 min
GitHub29d ago

Rendering huge pull requests in the GitHub Copilot app

How we rebuilt the diff surface in the GitHub Copilot app to open a million-line pull request with hundreds of inline review comments. The post Rendering huge...

DevToolsPlatform
1 min
GitHubSep 2, 2026

How we make AI coding more cost efficient without sacrificing task quality

Why shorter outputs can cost more, and how GitHub Copilot reduces wasted work across the complete coding task. The post How we make AI coding more cost...

DevToolsPlatform
1 min
GitHubAug 24, 2026

Your alt text passes automated checks. That doesn’t mean it’s any good.

We built a plugin for the GitHub Accessibility Scanner to make sure your alt text is actually accessible. Here's how it works. The post Your alt text passes...

DevToolsPlatform
1 min
GitHubAug 10, 2026

Using the GitHub Copilot SDK for Java

Here's a 3-sentence summary of the blog post: GitHub's Copilot SDK for Java provides a framework-agnostic way to drive AI from Java-based enterprise applications, without requiring a dependency on a specific AI vendor or provider. The SDK allows developers to create agent sessions, register tools, send prompts, and receive structured responses programmatically, using Jakarta EE 11 as a demo framework. With support for BYOK (Bring Your Own Key), virtual threads, and other modern Java features, the SDK offers a flexible and customizable solution for incorporating AI into Java-based applications.

DevToolsPlatform
1 min
GitHubAug 4, 2026

Turn one giant AI-generated pull request to a reviewable stack

GitHub Engineering uses stacked pull requests to simplify reviews and improve productivity in a development workflow that includes coding agents. To address the issue of giant AI-generated pull requests, the approach involves decomposition, where a large pull request is broken down into smaller, logically ordered pull requests, each scoped to a single concern. This allows for independent review of each layer within the stack.

DevToolsPlatform
1 min
GitHubJul 31, 2026

Don’t stop early: Case-folding source code at memory speed

GitHub engineers optimize case-folding performance by removing an early exit optimization and instead, sweeping the whole buffer for non-ASCII characters. This results in a significant speedup to >45 GiB/s when using vectorization on an Apple M4. Their Rust crate, casefold, implements a branch-free, memory-speed case-folding operation. By removing branches and using arithmetic to test ASCII letters, the engineers achieve a memory-bandwidth-limited performance at >45 GiB/s. However, this step can be a pessimization in scalar code, indicating that the optimal solution is highly dependent on the hardware and the specific use case. In a middle ground, using standard library functions to scan a machine word at a time can achieve a faster performance at around 23 GiB/s, which can be suitable as a general-purpose default.

DevToolsPlatform
1 min
GitHubJul 29, 2026

Tame Dependabot: Group your updates, slow the cadence, keep security fast

Here's a 3-sentence summary of the blog post: GitHub Engineering optimized Dependabot for a large Java repository by updating the dependabot.yml file to group version updates into a single pull request rather than individual dependencies, slowing the cadence from daily to monthly and covering all ecosystems used. This three-changed approach reduces noise and ensures that important updates are not ignored, while security updates are still raised immediately. Dependabot's default package cooldown, which waits three days for new releases to confirm their stability, provides an additional safety net against supply chain attacks.

DevToolsPlatform
1 min
GitHubJul 17, 2026

The cost of saying yes has changed

GitHub engineers are reevaluating their approach to decision-making, particularly when it comes to small feature requests. Writing the initial code is no longer the expensive step, as tools like AI agents can produce a first draft quickly. This shift in cost highlights the importance of evaluating changes based on their actual impact, rather than just their perceived complexity.

DevToolsPlatform
1 min
GitHubJul 10, 2026

Better tools made Copilot code review worse. Here’s how we actually improved it.

GitHub's Copilot code review initially worsened after switching to better-maintained, shared tools due to incorrect instructions. By rewriting the instructions to reflect a reviewer's workflow, they achieved a 20% lower average review cost while maintaining quality. The original instructions, optimized for general coding-assist purposes, led to unnecessary, broad searches and context gathering, whereas a revised approach prioritized targeted searches, batching, and focused code reads.

DevToolsPlatform
1 min
GitHubJul 8, 2026

Automating cross-repo documentation with GitHub Agentic Workflows

GitHub Engineering used GitHub Agentic Workflows to automate cross-repo documentation, reducing the reverse-engineering tax. They created a workflow that generates a draft in the docs repo based on a pull request in the product repo, ensuring security and accuracy. This resulted in 82 feature-docs pull requests merged at a median of 44.8 hours, with 96% of pull requests reviewed by the engineer who shipped the feature.

DevToolsPlatform
1 min
GitHubMay 14, 2026

From latency to instant: Modernizing GitHub Issues navigation performance

Here's a 3-sentence summary of the engineering blog post: GitHub Engineering modernized GitHub Issues navigation performance by shifting work to the client, optimizing perceived latency, and rendering instantly from locally available data. They built a client-side caching layer backed by IndexedDB, added a preheating strategy, and introduced a service worker to improve cache hit rates and ensure cached data remains usable. The changes resulted in a significant improvement, with 77.4% of all navigations landing in the fast and instant buckets, moving the default path for the majority of sessions to feel faster.

DevToolsPlatform
1 min
GitHubApr 16, 2026

How GitHub uses eBPF to improve deployment safety

GitHub engineers used eBPF to prevent deployment scripts from introducing circular dependencies and ensure reliability in their deployment system. They created a cGroup to isolate and block network egress from the deployment script, using BPF_PROG_TYPE_CGROUP_SKB to selectively monitor and block network calls. This approach allows GitHub to maintain a safe and reliable deployment system without blocking customer traffic on stateful hosts. The engineers also employed a DNS-based blocked list to block access to specific domains, using an eBPF program type of BPF_PROG_TYPE_CGROUP_SOCK_ADDR to intercept DNS queries and reroute them through a userspace DNS proxy.

DevToolsPlatform
1 min
GitHubApr 3, 2026

The uphill climb of making diff lines performant

Here is a 2-3 sentence summary of the article: To improve the performance of the Files changed tab in GitHub, the engineering team implemented multiple targeted approaches to address different pull request sizes and complexities, focusing on focused optimizations for diff-line components, virtualization, and foundational rendering improvements. The team simplified the React component structure for diff lines, reducing the number of DOM elements, JavaScript, and React components, and removed unnecessary elements to improve performance. By making incremental changes, such as reducing event handlers and moving complex state to conditionally rendered child components, the team achieved significant improvements in responsiveness and memory pressure, especially for large pull requests.

DevToolsPlatform
1 min
GitHubMar 31, 2026

Agent-driven development in Copilot Applied Science

Here is a 3-sentence summary of the blog post: The author, an AI researcher, automated their intellectual toil using GitHub Copilot, creating an agent-driven development system to analyze coding agent performance. They applied core principles such as conversational prompting, architectural refactoring, and iterative verification to enable fast development and collaboration, resulting in 11 new agents and over 25,000 lines of new code. By treating agents like engineers and focusing on code quality, the author transformed their project into an agent-first repository, making it easier for Copilot to navigate and understand the codebase.

DevToolsPlatform
1 min
GitHubMar 12, 2026

Continuous AI for accessibility: How GitHub transforms feedback into inclusion

AI automates triage for accessibility feedback, allowing us to focus on fixing barriers—turning a chaotic backlog into continuous, rapid resolutions. The post...

DevToolsPlatform
1 min