GitHub Universe: New Features for Developers

Agent HQ: The next chapter for GitHub ✨ Today at Universe, we're announcing Agent HQ with Anthropic, OpenAI, Google, xAI, and Cognition! After nearly twenty years of GitHub being the home for developers, it’s now the home for developers and coding agents. One open way to direct, observe, and manage work across GitHub, Visual Studio Code, CLI, and mobile clients. The way people build software is changing fast. GitHub already serves 180 million developers, 90% of Fortune 500s, and more than 10 million students and teachers. A new developer joins every second and 80% of them use Copilot in their first week. Yet even with all this growth, incredible power remains fragmented across too many tools and interfaces. At GitHub, we’ve always worked to bring that power together by making Git accessible, making code review systematic with pull requests, and making deployment automatic with Actions. Agent HQ is the next shift. It’s an open ecosystem so developers can access any agent, any way they work on the primitives they already know - Git, pull requests, issues. All inside your Copilot subscription. Welcome home, agents! https://lnkd.in/gEpqrrzV 1️⃣Mission Control 🛸Branch controls to decide when CI and checks run on agent‑created code 🛸Agent identity & access so you can see which agent did what, with policy enforcement 🛸One‑click merge conflict resolution, better file navigation, and richer code comments 🛸New integrations for Slack and Linear (alongside Jira, Teams, Azure Boards, Raycast) 2️⃣New customization in VS Code 🛸Plan Mode: Co‑create a step‑by‑step plan with Copilot before any code is written. Catch gaps early, approve, and then implement locally or via a cloud agent. 🛸Custom agents with AGENTS.md: Check in guardrails like “use this logger” or “prefer table‑driven tests,” and your agent follows them every time. 🛸GitHub MCP Registry (in VS Code): Discover and enable MCP services (Stripe, Figma, Sentry, and more) so your agent can tap the same tools your team already uses. 3️⃣Confidence & control for teams 🛸GitHub Code Quality (preview): Org‑wide visibility, governance, and reporting to improve maintainability, reliability, and test coverage. 🛸Code review inside the coding agent workflow: Agents run a first‑line review so issues surface before humans ever see the PR. 🛸Copilot metrics dashboard: Track adoption and impact, with the critical usage signals leaders need. 🛸Control plane: Set security policies, enable audit logging, manage model/data access, and decide which agents are allowed, without slowing developers down.

Today at Github Universe, we’re announcing Agent HQ with Anthropic, OpenAI, Google, xAI, and Cognition! After nearly twenty years of GitHub being the home for developers, it’s now the home for developers and coding agents. One open way to direct, observe, and manage work across GitHub, Visual Studio Code, CLI, and mobile clients.

Big news from GitHub Universe today — #GitHub just announced Agent HQ 🎉 It’s a command and control centre for your AI coding agents — a place to manage, compare, and collaborate with multiple agents (#OpenAI, #Anthropic, #Google, #xAI, #Cognition) right inside GitHub and VS Code. Super cool step toward a more open, flexible AI dev workflow.

It's showing that we are as an engineers should look carefully how AI Agents improve and speed up our work. What I believe will be a next big thing an integration with Platform Engineering, DORA metrics and other terms which we know from engineering. This creates an autonomous Agentic Platform. There will be always space for human but we will be focusing on most complex tasks and we shift left our work in typical SDLC process.

Like many developers, I use GitHub Copilot through the VS Code/Visual Studio extensions. Copilot helps in everyday development, assisting with everything from simple syntax questions to more complete implementation details. Like any AI tool, it requires a responsible approach: without solid understanding and code review, it's easy to introduce technical debt. To get the most out of Copilot, I've found it works best when: 🔍 Patterns are clear: It's most effective within an established codebase that has consistent patterns to follow. This allows it to handle complex tasks like mapping API calls to database code. 🎯 Prompts are specific: The best results come from well-structured prompts that reference files and code blocks as examples. ⚙️ Task Management: It's great for boilerplate and repetitive work (like generating unit tests). While it's capable of larger implementations, the results are less predictable, requiring closer review. I'm trying out the GitHub Copilot CLI Public Preview (https://lnkd.in/g-K3QzhP). Here are some observations that I thought were notable: ⚡ Faster Feel: The command-line interface feels more immediate and responsive than the integrated extensions. 🪄 Automated Workflow: The ability to delegate tasks to a Copilot coding agent via the /delegate TASK-DESCRIPTION command is a feature that I've been experimenting with. The agent can then automatically create a draft pull request, make changes based on your prompt, and then request a PR review. Seeing those automated notifications feels like I'm working with someone. 💡 Manage Expectations: Because the CLI is disconnected from the IDE, it feels like it should handle more—but it’s still using the same underlying models. My recommendation is to keep tasks simple and always use /delegate to keep the work isolated. Both the IDE extensions and the CLI show the potential of AI-assisted development—as long as we remain intentional and maintain ownership of the final code. Curious how others are experimenting with the GitHub Copilot CLI or combining it with the IDE extension. What's been your experience? #GitHub #Copilot #AI #DeveloperTools #Programming

At work we have been going through a concerted process of experimenting with LLM-supported development, asking ourselves how these tools can help us and how they can't. I have two stories from this week, both assisted by GitHub Copilot. In the first, I built an internal GitHub dashboard to monitor various attributes of our Git repositories with help from Copilot to guide me through making calls to Octokit, which I wasn't familiar with. This worked quite well but once I got it onto staging, I hit two problems: 1. Copilot wasn't particularly concerned about memory efficiency and had taken a silly route to answering "how old is the newest commit" by loading all commits and then taking the first one. In a big repository, this blew memory usage over 1GB and killed it. Turns out there were much simpler ways to do it. 2. Copilot also didn't much care to be efficient with API rate limits and decided to use a search endpoint that was limited to 30 calls per minute to count the number of open PRs. There were other APIs that could have been used that are accounted for under the general rate limits of 5k/hour. So I suppose this experience was OK, but it was clear that the AI would take any route to correctness and wasn't weighting other factors quite as strongly. Quite an interesting experience. The second task was to add a client-side type-ahead filtering box to a page that had a table on it. I had a well-elaborated GitHub issue for this and I prompted Copilot to "Analyse the requirements in Issue #xxxx and implement those requirements in this codebase". Copilot rumbled away for a bit and finished - and it was almost perfect. The field wasn't in the best place on the page, but it worked correctly the first time and it was easily moved. I wrote in my notes "There's something of the Sorcerer's Apprentice about this". ....and I was not wrong. One hour of prompting and refinement had gotten me to a working PR with tests ... which failed. What followed was TWO hours of watching Copilot spiral into madness trying to correctly test these React components to a high degree of confidence. To be fair, that's mostly what happens to me when I try to work with React too. In the end we got to working but it was a bit of a journey. I read a quote once along the lines of "I don't want the AI to make music and art while I do the dishes. I want the AI to do the dishes while I make the music." Today felt a bit like I got to do all the dull and annoying parts of programming after Copilot got to do the fun bit of making the computer do things. I felt like I spent two hours watching the computer spin and learned nothing useful in the process. My previous approach to working with LLMs was to ask ChatGPT questions about the technology I was using like it was the patient teacher I never had. That approach was much better for my own learning and development.

GitHub Copilot in a Multi-Project .NET 9 Workspace (Rating: 3/5) After weeks of hands-on use, I’ve formed a grounded perspective on GitHub Copilot — not from hype, but from real work across a complex .NET 9 repo (Blazor + MAUI + backend services). Here’s my honest breakdown: 🛠️ Where Copilot Helped - **Scaffolding & Boilerplate**: It sped up repetitive tasks like DTOs, basic service methods, and test stubs. For example, generating CRUD endpoints or simple models saved me 40–60 minutes per task. - **Consistent idioms**: It often suggested clean, idiomatic C# patterns — useful for quick prototypes or onboarding junior devs. ⚠️ Where It Struggled - **UI & Design (Blazor/MAUI/XAML)**: Copilot frequently generated syntactically valid markup that failed semantically — wrong lifecycle hooks, broken bindings, or styling mismatches. - **Cross-Project Integration**: Suggestions ignored project boundaries, source-generated types, and platform-specific constraints. I spent hours untangling build errors and fixing namespace or workload mismatches. - **Debugging & Fixes**: For real bugs, Copilot often hallucinated fixes that looked plausible but didn’t address root causes — especially in multi-file or multi-platform contexts. 🧪 Case Study from My Workspace **Task**: Add catalog DTOs, UI list page, and wire up HTTP client in a Blazor + MAUI repo.   - **Manual estimate**: ~4.5 hours   - **Copilot-assisted**:    - ⏱️ Saved ~1 hour on scaffolding    - 🧯 Spent ~3.5 hours fixing Copilot-induced issues (ambiguous types, missing usings, platform assumptions, source-gen mismatches)    - 📉 Net: +2 hours and fragile code (temporary stubs, extra review cycles) 🧭 My Takeaways - Treat Copilot as a **junior assistant**, not a senior engineer. It’s great at typing fast, not thinking deeply. - **Never accept long completions blindly** — always run builds, tests, and static analysis. - For **UI, cross-project wiring, or platform-specific logic**, manual coding remains faster and more reliable. - Copilot is **net positive** for small, isolated tasks. But for integrated, UI-heavy, or architecture-sensitive work, it can become a time sink. 🧩 Final Verdict: 3/5 Copilot is a helpful tool — but only when used with clear boundaries. It’s not a silver bullet. Use it to accelerate scaffolding and prototypes, but don’t expect it to solve complex integration or design problems. Curious to hear how others are using Copilot in multi-platform .NET stacks. Are you seeing similar trade-offs? #GitHubCopilot #DotNet9 #Blazor #MAUI #DevTools #AIinCoding #DeveloperExperience #RealWorldDev #Productivity

The Road to Better Completions: Building a Faster, Smarter GitHub Copilot with a Custom Model As Solution Architects, we often get asked: 👉 “How can AI tools like Copilot truly improve developer productivity?” Recently, we explored that question hands-on — building a custom AI model to supercharge GitHub Copilot. Here’s how we approached it, what we learned, and why it matters for every engineering leader driving AI-enabled delivery. 🔹 1️⃣ Start with Real Value, Not Fancy Tech We began with developer pain points: repetitive boilerplate, slow suggestions, irrelevant completions. The goal wasn’t “build a model” — it was “deliver completions developers trust and use.” By analysing code telemetry and developer feedback, we found where Copilot’s generic model failed — domain-specific libraries, proprietary APIs, and internal design patterns. That became our foundation. 🔹 2️⃣ Architect for Context + Control We designed a two-layer architecture: 🧩 A fine-tuned model, trained on internal code, design standards, and frameworks. ⚙️ An inference pipeline integrated with GitHub Copilot extensions — intercepting completions, re-ranking, and returning the most context-aware suggestion. Our architectural focus: ⏱️ Latency < 250 ms 🔐 Data never leaves trusted boundaries 🌍 Scalable for multi-language teams 🔹 3️⃣ Define Metrics That Matter We tracked three core KPIs: 📈 Latency — improved by ~30% 🤖 Relevance — up by ~45% 🙌 Adoption rate — jumped from 18% to 52% Behind these numbers lies tangible value: less cognitive load, faster reviews, and higher code consistency across projects. 🔹 4️⃣ Govern & Evolve the Model Custom models demand continuous governance. We created: A feedback loop from active repos Quarterly retraining cycles to address drift A cross-functional review board (Architecture + Engineering + Security) This ensures every model update strengthens developer experience without compromising compliance or reliability. 🔹 5️⃣ The Strategic Payoff This isn’t just an AI upgrade — it’s a strategic evolution in how we build software. By owning our Copilot experience, we turn generic assistance into a competitive advantage. AI stops being a plugin; it becomes part of our development DNA. 💡 Final Thought Architecture is about balance — performance, cost, and governance. The same holds true for AI-augmented development. ✅ Build for real value ✅ Architect for performance ✅ Govern for trust For teams exploring AI-assisted coding: start small, measure impact, iterate fast. That’s the real road to better completions. What’s one developer productivity challenge you’d solve with AI next? Let’s discuss 👇

GitHub Universe just wrapped—and what a time to be a developer! Application development is officially at the frontier of AI innovation. No more “I don’t have time to build this”—and gone are the days of asking for permission to explore an idea. I loved this quote from the keynote: “Groundbreaking innovations don’t start with a grand plan—they start with a spark of an idea and the courage to act.” With GitHub Copilot, you dream it, you ship it! 🔥 Big Announcements from Universe: ✨ Agent HQ – The next evolution of GitHub’s open platform. Developers can now orchestrate all their agents to perform tasks across multiple surfaces—GitHub, VS Code, CLI, and mobile—using the primitives they already know. To bring this vision to life, GitHub is partnering with Anthropic, OpenAI, Google, Cognition, xAI, and more. ✅ Mission Control – A unified command center to steer multiple agents across GitHub, VS Code, mobile, and CLI. ✅ Plan Mode in VS Code – Align developers and agents on context and goals before execution. ✅ Custom Agents – Create agents in VS Code with clear rules and guardrails to shape behavior. ✅ Expanded Integrations – GitHub now connects with Teams, Slack, Linear, Jira, Raycast, and Azure Boards. ✅ Code Quality & Copilot Metrics Dashboard – Visibility, reliability, and control as AI adoption accelerates. ✅ Control Plane – Enterprise-grade policy, security, and audit logging for AI agents and models. 💡 The future of software development is agentic, collaborative, and AI-powered. GitHub + Visual Studio is the ultimate platform to accelerate from idea to impact. If you’re still writing every line of code yourself because “it’s a good idea,” that’s like insisting on writing assembly code after the compiler was invented. The game has changed!

The last time I spoke about Git, I sparked a debate. 😅 This time, I’m not but let’s talk. This post is for those who are new and want to use Git and GitHub to do exciting things. 🚀 I find this topic fascinating because many entry-level devs high on vibe coding still wonder why Git is such a big deal. It often feels like we exaggerate the importance of Git, and even when beginners use it, their workflow usually stops at these three commands: $ git add . $ git commit -m "commit message" $ git push But let’s share some cool stuff. 😎 If you’ve always wanted to collaborate with AI-powered builders like #v0, #Bolt, or #Lovable, beyond just saying “build me a full-blown hotel booking web app,” then this will come in handy. Let’s start with some soft commands first. We already know that one button connects GitHub to your project and creates your repository. So what next? 👉 Get it on your laptop: $ git clone <remote-url> Now it’s on your system, and you’re coding away. But wait, it doesn’t update automatically on your laptop. That’s because you haven’t pulled the latest changes. 👉Then you Pull changes: $ git pull Now it’s synced! But you don’t want to keep doing pull, pull, pull forever, you want to get involved too. 👉 Create your own branch: $ git checkout -b my-edits Cool, right? 😎 Because sometimes, you might just want to change a single word… and then the AI decides to go wild. 😂 But that’s not all, there’s more to come. Here are some interesting commands you’ll encounter as you grow: $ git revert $ git fetch origin && git rebase origin/main $ git push -f $ git reset --hard HEAD~1 $ git cherry-pick <commit> $ git stash && git stash apply stash@{n} $ git bisect These commands make collaboration with AI-powered builders and agents feel like having a full dev team working alongside you. 🤖💻 Check out my featured section and subscribe to my newsletter. I’ll be writing an article that’ll help you manage your builds efficiently with AI-powered tools. And if you haven’t followed or connected with me yet Chibuike Nwafor… now’s the best time. #SoftwareEngineering #DevelopersCommunity #AI #GitAndGitHub