Author name: ITMAITY

In a video game, a single upgrade enhances your abilities, while combining multiple can create an unstoppable power-up. In the world of software development, this combined power does something similar: At GitHub, we believe it can empower developers with an incredible force to tackle any challenge, whether that’s fixing a critical bug, adding a new feature, or shipping your release to production. My recent quest “Stay a while and listen,” as the old Diablo line goes.  One morning, while on a walk, I received an urgent call. A critical feature on a website I collaborate on  was displaying errors. This happened just before a high-visibility demo. I was miles from my laptop, and a traditional fix seemed hours away. That would be far too late to address this immediate need. Rolling back wasn’t an option, as it would remove functionality vital for the presentation. The only tool I had available was my cell phone. Instead of rushing home, I realized I could leverage two powerful GitHub features: GitHub Copilot coding agent and the GitHub Mobile app. I could quickly create an issue on mobile and delegate the problem to Copilot, in order to expedite a resolution. From GitHub Mobile, I scanned recent pull requests and identified a likely culprit: a pull request that added markdown rendering and a rich text editor. I created a new issue, describing the problem and referencing the suspicious pull requests, while also relying on my repository’s copilot-instructions to help guide the agent. With a few taps, I assigned the issue to GitHub Copilot coding agent. Just six minutes later, a notification appeared on GitHub Mobile. GitHub Copilot had generated a pull request with a fix! I reviewed it immediately from my phone. It was a clear, simple solution to the problem. Leveraging existing workflows, I could even test the fix on a preview branch right from my mobile device.  Satisfied, I approved the pull request, which was deployed to production through automated workflows managed with GitHub Actions in my repository. By the time I reached my car, the director confirmed the issue was resolved, and they were ready to proceed with their demo.  This experience, all managed from my phone, revealed a powerful capability within the GitHub Platform. Combining these two features—GitHub Copilot coding agent and GitHub Mobile—unlocked a new ability for me, and prompted me to explore what other combinations within the platform could further power-up my work. Here is a view from my phone using the GitHub Mobile app after reviewing the pull request and approving. We see a summary of Copilot’s fixes for the issue. Using the right tool at the right time It’s important to clarify that I’m not suggesting you delegate all development to Copilot from your mobile device, nor that every fix can be approved instantly from your phone. However, my experience highlights a crucial point: having the right tools for the right situation makes all the difference. GitHub Copilot as an AI pair programmer is a game-changer. By incorporating GitHub Copilot coding agent and GitHub Mobile into my workflow, alongside existing features like GitHub Issues and GitHub Actions, I’ve discovered a new level of efficiency. Here’s how you can gain this same power-up.   Keys to unlock this power-up  Key 1: Leverage instructions files There is a plethora of knowledge available on how you can effectively use GitHub Copilot. One area you’ll certainly come across is custom instructions for GitHub Copilot. These instructions are the guidelines and rules that can influence the results you get from Copilot. A well-defined set of instructions can go a long way.   In my scenario, I used repository custom instructions to give Copilot additional context for understanding important information about my repository. This included the core purpose of the repository, the tech stack used, architecture constraints, coding standards, testing strategy, dependency management, observability, documentation, error handling, and more. It’s important to define the things that are important for GitHub Copilot to have and to understand about your project. For me, identifying things like directory structure, coding standards, and project dependencies were important for identifying a fix with less churn. Custom instructions are written using markdown and including them provide specific guidance to GitHub Copilot Coding Agent, Copilot Chat, and Copilot code review. It’s important to note that instructions in this file apply to all chat requests for the repository. This file exists in the .github directory in your repository right off of the root level.  EXAMPLE: Here’s an example of an instructions file you might see in the .github/copilot-instructions.md file. Remember to tailor these to your project. # Copilot Instructions – Use Next.js App Router with React and TypeScript across the project. – Use pnpm for all package management commands (not npm or yarn). – Use Tailwind CSS v4 with a mobile-first approach; enhance with sm:/md:/lg:/xl: as needed. – Prefer shadcn/ui components before creating new UI; place shadcn/ui in src/components/ui and shared components in src/components/shared. – Always use next/link for internal navigation and next/image for images. – Prefer server components by default; add “use client” only when needed (event handlers, browser APIs). – Implement server actions where appropriate; place them in src/lib/actions. – Put utilities in src/utils and Supabase utilities in src/utils/supabase; define shared types in src/types. – Write tests with Vitest for critical business logic and components; place tests in __tests__ directories. – Follow Next.js performance best practices and implement proper error boundaries and error handling. – Use environment variables (NEXT_PUBLIC_ for client exposure); keep secrets server-side only. – Use Vercel for deploys and GitHub Actions for CI/CD with pnpm scripts (pnpm dev/build/test). – Keep code idiomatic: functional components + hooks, async/await for async, and idiomatic Next.js/React patterns. ## Folder structure reference (high-level) “`text . ├─ app/ # Next.js App Router: route groups, page.tsx, layout.tsx, loading.tsx, error.tsx, route.ts ├─ public/ # Static assets served at / ├─ src/ │ ├─ components/ │ │ ├─ ui/ # shadcn/ui components │ │ └─ shared/ # Shared app-specific components │ ├─ lib/ │ │ └─

Two decades after Linus’s first git commit, contributors from around the world gathered at GitHub HQ in San Francisco—not just to reflect on Git’s history, but to imagine its future. Git Merge 2025 marked 20 years of Git with technical talks, community collaboration, and the kind of hallway chats you can’t capture in slides. More than 100 people joined us in person, and over 600 tuned in online. Day 1: Talks for everyone From deep dives into Git internals to beginner-friendly sessions on creative workflows, this year’s program offered something for everyone. We heard from maintainers, educators, hobbyists, and even a high school student, sharing how Git shapes their work and learning. Speakers joined both in person and remotely from around the globe, making this one of our most accessible and inclusive Git Merge events yet. Attendees gathered in the GitHub HQ amphitheater during Git Merge 2025. Scott Chacon mixed comedy and code in a live demo of the GitButler CLI, while Google’s Martin von Zweigbergk unpacked how Jujutsu integrates with Git. Jacob Stopak reimagined Git learning through visualization and gamification, Steffen Hiller and Zoran Petrovic showcased new ways to visualize how repositories grow over time, and brian m. carlson unpacked what’s next for SHA-256 interoperability. Explore the playlist to watch these talks and more! Day 2: Community at the center The second day focused on collaboration with the annual Git Contributor’s Summit and an Unconference. Core maintainers and contributors met, both in person and remotely, to shape Git’s roadmap for the year ahead in one of our most remote-friendly gatherings yet.  Git Contributor’s Summit During the summit, our Unconference opened the floor to everyone, with whiteboards filling quickly with ideas on branching strategies, Git education, and creative workflows. Thank you Git Merge 2025 wouldn’t have happened without this community. From the speakers who shared their work, to the contributors and volunteers who gave their time, to every attendee who showed up ready to learn and connect… thank you.  Huge thanks to the GitHub teams behind the scenes who made the event seamless for attendees around the world.  And a special thanks to our sponsors, GitButler and Google, for helping bring this year’s celebration to life.  Until the next Git Merge, keep committing. <3 Catch up on the talks from Git Merge 2025 > The post 20 Years of Git, 2 days at GitHub HQ: Git Merge 2025 highlights 🎉 appeared first on The GitHub Blog. ​ Git, Open Source, Git Merge The GitHub Blog

Many developers begin their AI explorations with a prompt. Perhaps you started the same way: You opened GitHub Copilot, started asking questions in natural language, and hoped for a usable output. This approach can work for simple fixes and code suggestions, but as your needs get more complex—or as your work gets more collaborative—you’re going to need a more foolproof strategy.  This guide will introduce you to a three-part framework that transforms this ad-hoc style of AI experimentation into a repeatable and reliable engineering practice. At its core are two concepts: agentic primitives, which are reusable, configurable building blocks that enable AI agents to work systematically; and context engineering, which ensures your AI agents always focus on the right information. By familiarizing yourself with these concepts, you’ll be able to build AI systems that can not only code independently, but do so reliably, predictably, and consistently. The AI-native development frameworkMarkdown prompt engineering + agent primitives + context engineering = reliability Whether you’re new to AI-native development or looking to bring deeper reliability to your agent workflows, this guide will give you the foundation you need to build, scale, and share intelligent systems that learn and improve with every use. 🧠 Try it yourself: Build and run agentic workflows with GitHub Copilot CLI Bring your agent primitives to life right from your terminal. The new GitHub Copilot CLI lets you run, debug, and automate AI workflows locally—no setup scripts, no context loss. It connects directly to your repositories, pull requests, and issues through GitHub MCP, giving your agents the same context they’d have in your IDE.  👉 Get started with GitHub Copilot CLI > What are agent primitives?  The three-layer framework below turns ad-hoc AI experimentation into a reliable, repeatable process. It does this by combining the structure of Markdown; the power of agent primitives, simple building blocks that give your AI agents clear instructions and capabilities; and smart context management, so your agents always get the right information (not just more information).  Layer 1: Use Markdown for more strategic prompt engineering We’ve written about the importance of prompt engineering. But here’s what you need to know: The clearer, more precise, more context-rich your prompt, the better, more accurate your outcome. This is where Markdown comes in. With Markdown’s structure (its headers, lists, and links), you can naturally guide AI’s reasoning, making outputs more predictable and consistent.  To provide a strong foundation for your prompt engineering, try these techniques with Markdown as your guide:  Context loading: [Review existing patterns](./src/patterns/). In this case, links become context injection points that pull in relevant information, either from files or websites. Structured thinking: Use headers and bullets to create clear reasoning pathways for the AI to follow. Role activation: Use phrases like “You are an expert [in this role].” This triggers specialized knowledge domains and will focus the AI’s responses. Tool integration: Use MCP tool tool-name. This lets your AI agent run code in a controlled, repeatable, and predictable way on MCP servers. Precise language: Eliminate ambiguity through specific instructions. Validation gates: “Stop and get user approval.” Make sure there is always human oversight at critical decision points. For example, instead of saying, Find and fix the bug, use the following: You are an expert debugger, specialized in debugging complex programming issues. You are particularly great at debugging this project, which architecture and quirks can be consulted in the [architecture document](./docs/architecture.md). Follow these steps: 1. Review the [error logs](./logs/error.log) and identify the root cause. 2. Use the `azmcp-monitor-log-query` MCP tool to retrieve infrastructure logs from Azure. 3. Once you find the root cause, think about 3 potential solutions with trade-offs 4. Present your root cause analysis and suggested solutions with trade-offs to the user and seek validation before proceeding with fixes – do not change any files. Once you’re comfortable with structured prompting, you’ll quickly realize that manually crafting perfect prompts for every task is unsustainable. (Who has the time?) This is where the second step comes in: turning your prompt engineering insights into reusable, configurable systems. Layer 2: Agentic primitives: Deploying your new prompt engineering techniques Now it’s time to implement all of your new strategies more systematically, instead of prompting ad hoc. These configurable tools will help you do just that. Core agent primitives When it comes to AI-native development, a core agent primitive refers to a simple, reusable file or module that provides a specific capability or rule for an agent.  Here are some examples: Instructions files: Deploy structured guidance through modular .instructions.md files with targeted scope. At GitHub, we offer custom instructions to give Copilot repository-specific guidance and preferences.  Chat modes: Deploy role-based expertise through .chatmode.md files with MCP tool boundaries that prevent security breaches and cross-domain interference. For example, professional licenses that keep architects from building and engineers from planning. Agentic workflows: Deploy reusable prompts through .prompt.md files with built-in validation. Specification files: Create implementation-ready blueprints through .spec.md files that ensure repeatable results, whether the work is done by a person or by AI. Agent memory files: Preserve knowledge across sessions through .memory.md files. Context helper files: Optimize information retrieval through .context.md files. How using a core agent primitive can transform a prompt and its outcome Technique: Using Markdown prompt engineering, your prompt can be: “Implement secure user authentication system”  Primitives: You’ll select backend-dev chat mode → Auto-triggers security.instructions.md via applyTo: “auth/**” → Loads context from [Previous auth patterns](.memory.md#security) and [API Security Standards](api-security.context.md#rest) → Generates user-auth.spec.md using structured templates → Executes implement-from-spec.prompt.md workflow with validation gates. Outcome: Developer-driven knowledge accumulation where you capture implementation failures in .memory.md, document successful patterns in .instructions.md, and refine workflows in .prompt.md files—creating compound intelligence that improves through your iterative refinement. This transformation might seem complex, but notice the pattern: What started as an ad-hoc request became a systematic workflow with clear handoff points, automatic context loading, and built-in validation.  When you use these files and modules, you can keep adjusting and improving how your AI agent works at every step. Every time you

You already live in the terminal. You clone repositories there, install dependencies, debug issues, and run builds. But until now, when you needed AI help, you had to leave the CLI and open your editor or browser. Not anymore. GitHub Copilot CLI brings that same assistance straight to your shell. No switching contexts, no breaking flow. Just you, your terminal, and an AI that can actually help you get things done. Install once, authenticate, and start working With Copilot CLI, you don’t have to juggle your API keys. Just install the assistant, sign in with your existing GitHub Copilot Pro, Pro+, Business, or Enterprise plan, and go.   # 1. Install via npm npm install -g @github/copilot # 2. Launch Copilot CLI copilot # Authenticate with your GitHub account /login Requirements: Node v22+ npm version 10 or later Launch Copilot CLI Log in with your GitHub account  From here, you can get hands-on immediately—debugging tests, spinning up preview deploys, or writing one-off scripts—without leaving your terminal.  Use case: From clone to pull request in the terminal Imagine this: You’ve just cloned a repository you want to contribute to. Normally, you’d spend time reading through the README, manually checking dependencies, and combing through open issues to find a place to start. But with Copilot CLI, you can offload all of that. 1. Clone and launch Copilot First things first. Grab the repository you want to work on and run Copilot CLI in your terminal.  gh repo clone github/spec-kit cd spec-kit copilot Copilot greets you in the terminal. Type / at any time to see available commands, or use Ctrl+R to see logs of the commands Copilot has run on your behalf. 2. Get oriented in a new codebase Once you’re inside the project, the first step is understanding how everything fits together. Instead of scrolling through files manually or piecing it together from the README, ask Copilot to explain it for you. You say: Explain the layout of this project. Copilot inspects the repository using find, tree, and the README, then returns a clean Markdown summary. No more hunting through nested directories trying to figure out where things live. 3. Check your environment After you know the lay of the land, the next question is: can you actually build it? Normally, you’d spend time hunting for dependencies and making sure you’ve installed the right versions. Copilot now handles that. You say: Make sure my environment is ready to build this project. Copilot verifies dependencies, installs missing tools (like Go for the GitHub CLI), and confirms you can build locally. All without you having to comb through setup docs or run trial-and-error commands. 4. Find a good first issue Now that you’re set up, you’ll want to start contributing. Instead of browsing through dozens of open issues, let Copilot surface the ones that make sense for you. You say: Find good first issues in this repository and rank them by difficulty. Copilot queries GitHub Issues with its built-in GitHub MCP server and suggests a curated list, complete with difficulty levels. Instead of scanning dozens of issues, you can dive straight into a task that matches your comfort zone. 5. Start implementing Now comes the real work. Normally, after finding an issue to work on, you’d create a branch, open the right files, make edits, and double-check your changes before committing. With Copilot CLI, you can let it draft the fix for you while you stay in control at every step. You say: Start implementing issue #1234. Show me the diff before applying. Copilot drafts a plan, makes the edits, and presents the diff. You stay in control, review, and approve before changes are applied.  👀 Pro tip: You can @-mention files in your prompt if you want Copilot to focus on specific parts of the code. 6. Commit and open a draft pull request  Once the changes look good, the next step is packaging them up and sharing your work. Normally, that means staging files, writing a commit message, pushing a branch, and opening a pull request, which is all a bit of a dance in Git. Copilot CLI streamlines the whole flow so you can stay focused on the code. You say: Stage changes, write a commit referencing #1234, and open a draft PR. Copilot will then stage files, write the commit message, and open a draft pull request for you to review.  7. Bonus: Kill that process hogging your port Let’s say you’ve hit another common headache: a process hogging a port. You know, that moment when you try to start your dev server and it tells you a port (let’s say 8080 for this example) is already in use, and you have to go hunting for the right lsof command and flags. You say: What process is using port 8080? Kill it and verify the port is free. Copilot runs the right lsof command, shows the PID, kills the process, and verifies it’s gone. No more Googling arcane flags or trying to remember if it’s lsof -i :8080 or lsof -t -i:8080 or something else entirely. I’m horrible at remembering commands, especially ones I use infrequently. With Copilot CLI, I just defer these tasks straight to it. Maybe I’ll remember the command next time, or maybe (probably) not. But I’ll definitely ask Copilot again. Stay in control Copilot always asks before running commands or accessing directories. This is critical when you’re giving an AI access to run things on your machine. Before Copilot can execute anything, it will prompt you to: Allow once Allow always for this command Deny You can also: Use /session to view what’s currently allowed Reset permissions at any time with /reset Add directories to your allowed list with /add-directory Extend with MCP servers Copilot CLI ships with the GitHub MCP server already installed and running. This is what powers the issue search and repository interactions. But you can add any MCP server you want from the registry using /mcp. Want to add Playwright

Picture this: you’re a developer in 2025, and your company just told you they need to modernize a mainframe system that processes millions of ATM transactions daily. We’re talking about COBOL, a programming language that’s been around for 65 years. That’s older than the internet. Now, your first instinct might be to laugh or maybe cry a little. But here’s the thing—COBOL isn’t going anywhere. In fact, it’s powering some of the largest and most critical systems on the planet right now. The problem? Finding developers who understand COBOL is like finding unicorns. The original developers are retiring, and yet 200 billion lines of COBOL code are still running our banks, insurance companies, and government systems. But here’s the plot twist: we now have the opportunity to support the unicorns. We have GitHub Copilot and autonomous AI agents. Meet the developer who’s modernizing COBOL (without learning COBOL) I recently spoke with Julia Kordick, Microsoft Global Black Belt, who’s modernizing COBOL systems using AI. What’s remarkable? She never learned COBOL. Julia brought her AI expertise and worked directly with the people who had decades of domain knowledge. That partnership is the key insight here. She didn’t need to become a COBOL expert. Instead, she focused on what she does best: designing intelligent solutions. The COBOL experts provided the legacy system knowledge. When this whole idea of Gen AI appeared, we were thinking about how we can actually use AI to solve this problem that has not been really solved yet. Julia Kordick, Microsoft Global Black Belt The three-step framework for AI-powered legacy modernization Julia and her team at Microsoft have cracked the code (pun intended) with a systematic approach that works for any legacy modernization project, not just COBOL. Here’s their GitHub Copilot powered, battle-tested framework. Step 1: Code preparation (reverse engineering) The biggest problem with legacy systems? Organizations have no idea what their code actually does anymore. They use it, they depend on it, but understanding it? That’s another story. This is where GitHub Copilot becomes your archaeological tool. Instead of hiring consultants to spend months analyzing code, you can use AI to: Extract business logic from legacy files. Document everything in markdown for human review. Automatically identify call chains and dependencies. Clean up irrelevant comments and historical logs. Add additional information as comments where needed. 💡Pro tip: Always have human experts review AI-generated analysis. AI is incredible at pattern recognition, but domain knowledge still matters for business context. Here’s what GitHub Copilot generates for you:  # Business Logic Analysis Generated by GitHub Copilot ## File Inventory – listings.cobol: List management functionality (~100 lines) – mainframe-example.cobol: Full mainframe program (~10K lines, high complexity) ## Business Purpose Customer account validation with balance checking – Validates account numbers against master file – Performs balance calculations with overdraft protection – Generates transaction logs for audit compliance ## Dependencies Discovered – DB2 database connections via SQLCA – External validation service calls – Legacy print queue system Step 2: Enrichment (making code AI-digestible) You usually need to add context to help AI understand your code better. Here’s what that looks like: Translation: If your code has Danish, German, or other non-English comments, translate them. Models work better with English context. Structural analysis: COBOL has deterministic patterns. Even if you’ve never written COBOL, you can leverage these patterns because they’re predictable. Here’s how: COBOL programs always follow the same four-division structure: IDENTIFICATION DIVISION (metadata about the program) ENVIRONMENT DIVISION (file and system configurations) DATA DIVISION (variable declarations and data structures) PROCEDURE DIVISION (the actual business logic) Ask GitHub Copilot to map these divisions for you. Use prompts like: “Identify all the divisions in this COBOL file and summarize what each one does” “List all data structures defined in the DATA DIVISION and their purpose” “Extract the main business logic flow from the PROCEDURE DIVISION” The AI can parse these structured sections and explain them in plain English. You don’t need to understand COBOL syntax. You just need to know that COBOL’s rigid structure makes it easier for AI to analyze than more flexible languages. Documentation as source of truth: Save everything AI generates as markdown files that become the primary reference. Julia explained it this way: “Everything that you let Copilot generate as a preparation, write it down as a markdown file so that it can actually reference these markdown files as source of truth.” 💡Pro tip: COBOL’s verbosity is actually an advantage here. Statements like ADD TOTAL-SALES TO ANNUAL-REVENUE are almost self-documenting. Ask Copilot to extract these business rules into natural language descriptions. Step 3: Automation Aids (Scaling the Process) Once you’ve analyzed and enriched individual files, you need to understand how they all fit together. This is where you move from using Copilot interactively to building automated workflows with AI agents. Julia’s team built a framework using Microsoft Semantic Kernel, which orchestrates multiple specialized agents. Each agent has a specific job, and they work together to handle the complexity that would overwhelm a single AI call. Here’s what this orchestration looks like in practice: Call chain mapping: Generate Mermaid diagrams showing how files interact. One agent reads your COBOL files, another traces the CALL statements between programs, and a third generates a visual diagram. You end up with a map of your entire system without manually tracing dependencies. Test-driven modernization: Extract business logic (agent 1), generate test cases that validate that logic (agent 2), then generate modern code that passes those tests (agent 3). The tests become your safety net during migration. Dependency optimization: Identify utility classes and libraries that you can replace with modern equivalents. An agent analyzes what third-party COBOL libraries you’re using, checks if modern alternatives exist, and flags opportunities to simplify your migration. Think of it like this: Copilot in your IDE is a conversation. This framework is a production line. Each agent does one thing well, and the orchestration layer manages the workflow between them. 💡Pro tip: Use Mermaid diagrams to visualize complex dependencies before making any changes.

You probably remember when GitHub Copilot first showed up in your editor with that little gray box. It was fast, surprising, and sometimes weird. But it hinted at something bigger: AI could actually help you code, not just autocomplete it. Fast forward to today, and AI is part of our daily workflows. From Cursor to Windsurf and Claude Code to Gemini to OpenAI Codex, there’s no shortage of new tools. And that’s great. Developers need options. But with 20 million-plus developers across IDEs, the command line, and pull requests, GitHub Copilot is the most-used AI tool among developers, according to a recent Pragmatic Engineer survey. Devs have used Copilot to accept more than 3 billion code suggestions to date. And every month, Copilot helps deliver millions of code reviews and contribute 1.2 million pull requests, directly inside GitHub. And because GitHub is where your code already lives (plus your pull requests, reviews, and tests), Copilot doesn’t stop at writing code. It plugs into everything you rely on via the GitHub MCP Server. We haven’t always been the fastest (though our Changelog may beg to differ) or the loudest. But we’ve been building Copilot since before ChatGPT existed, and we are focused on one purpose: to help developers turn TODOs into committed code. And while some chase the bleeding edge, we know developers don’t want their production code balanced on it.  All that to say: if you tried Copilot early on, things have changed in some pretty big ways.  From autocomplete to actual collaboration 💻 If 2024 was about showing what’s possible with AI, 2025 is about making it practical. Copilot has quietly grown from a neat autocomplete trick into a multi-modal, multi-model assistant that actually understands your projects and helps you move them forward. After opening up support for multiple models from different providers in 2024,  we’ve been shipping new models almost as fast as they drop from OpenAI’s latest releases to Google’s Gemini 2.0 Flash.  This evolution didn’t happen by accident. Developers told us what worked, what didn’t, and that they wanted more powerful agentic workflows and multi-file editing. So we made that happen.  And that’s just one part of how far Copilot’s come. It’s all part of a bigger goal: making Copilot smarter without you ever needing to install or configure a thing.  Built into the platform you use every day Every AI vendor is racing to bolt their agentic tools into GitHub. That’s because agents don’t ship code in a vacuum. They plan tasks, open branches, run tests, and submit pull requests. And all of that already happens on GitHub where developers are collaborating on over 518 million projects. Since Copilot lives inside the GitHub stack and has native support for GitHub MCP server, its agentic capabilities act on real repository context. It respects branch protections, works within your review cycles, and integrates directly with your CI/CD and security checks. From idea to merge in record time ⚡ Over the last year, raw speed and agentic workflows helped define a new crop of AI tools. We took that as a challenge. Agent mode: Copilot now takes on cross-file tasks, runs commands, refactors entire modules, and suggests terminal operations—all without leaving your editor. Coding agent: Assign an issue to Copilot, and it drafts a pull request with code, tests, and context from your project. Coding agent now contributes to roughly 1.2 million pull requests per month. Next-edit suggestions: Copilot predicts the next change you’ll make and offers it inline. One Tab and you’re done. Low-latency completions: Most Copilot responses now render in under 400 ms (fast enough that you stop noticing them). Copilot CLI: The same brains, now in your terminal. Setup, debug, and script without switching windows. Multi-model routing: Different jobs call for different brains. Copilot gives you access to multiple LLMs from leading frontier AI firms.  The result: fewer interruptions, faster loops, and a workflow that finally keeps pace with how you think. AI that scales with your workflow 📐 Copilot doesn’t live in a new environment you need to learn. It’s part of the same ecosystem you already use, and scales with it.  JetBrains + VS Code + CLI parity: Same Copilot, wherever you build. Custom instructions: Drop a .copilot-instructions.md file in to teach Copilot your naming conventions, test frameworks, comment formats. GitHub MCP Server: Lets any AI tool securely access your GitHub context (pull requests, issues, actions) without leaving GitHub. Workspace prompt files: Reusable blueprints for consistent prompts across teams. 20M+ developers strong: Every Copilot update compounds through the world’s largest network of real developer data (and feedback). Copilot isn’t a separate tool you “add” to GitHub. It’s part of what makes GitHub a full-stack development platform. Other tools might help you code; Copilot helps you build, test, secure, and ship. Smarter, cleaner, and safer code 🔍 Fast is nice. Correct is better (ask us how we know). We’ve spent a lot of cycles quietly leveling up Copilot’s overall code quality and security guardrails where they matter most to you.  Copilot Autofix: Detects and patches vulnerabilities automatically (it was used to fix over a million vulnerabilities this year alone). Code review: Summarizes diffs, flags logic bugs, and suggests fixes right inside your pull requests with a tool that powers millions of code reviews a month on GitHub. Improved model reasoning: Generates more readable, test-passing code with fewer lint errors and less regressions. CodeQL integration: Integrations with GitHub Advanced Security, Dependabot, and GitHub Actions keeps your supply chain solid. Built-in privacy: Enterprise isolation, audit logs, and tenant-level control mean your work stays off the grid.  Our research shows new code written with Copilot tends to have higher readability, better reliability, and improved maintainability scores.  Here’s the good news: Copilot’s backed by the same security stack that protects the world’s largest open source ecosystem and more than 90% of Fortune 100 companies. Real talk: Copilot vs. the rest 👀 Let’s be honest: there are some great tools out there that make agentic coding workflows feel intuitive

We know that the idea of big tech conferences can be overwhelming, especially if you’re introverted, anxious, or are used to spending most of your day behind your computer. (Which is most of us.) And that’s okay!  The good news is that GitHub Universe was designed for folks like you. This isn’t just one long conference in a room with thousands of people and no exit. Universe offers all sorts of opportunities to take breaks, hang in small groups, or watch virtually, so that you can learn and network at whatever pace works for you. We’ve built in events to make the experience extra comfortable, safe, and exciting for all. [Get your IRL pass] If you’ve already got your pass but are feeling a bit shaky on how it’ll all go, here are some practical tips for how to navigate tech conferences, like GitHub Universe. 1. Attend smaller sessions or workshops Instead of signing up for the largest, busiest sessions, go for the smaller workshops, niche panels, and breakout sessions. Small-group sessions often foster deeper connections and conversations, and they can help keep you from getting lost in the crowd.  This year’s Universe will feature many interactive workshops (explore the full list), where the guest list will be small, and the conversations will be deep. You can also add demo-style sandbox sessions to your agenda, which include practical exercises, to keep your mind engaged!  You may also want to check out gatherings in our discussions lounge, where two to three facilitators will guide small groups through specific topics of interest, prioritizing active participation and collaboration.  2. Find quiet zones and recharge spaces We all know that introverts recharge alone. So if you need to step away and take some time to reflect, you should! At Universe, we’ve created dedicated lounges and recharge spaces, so you don’t have to choose between skipping content and protecting your peace. Need a few minutes to unwind? We’ll have a quiet room for phone-free decompression, meditation, and prayer. We’ll also have plenty of drink options, snacks, and meals available if you need to keep your blood sugar up. And don’t forget to step outside and take in the stunning waterfront views at Fort Mason—a quick breath of ocean air can do wonders between sessions. 3. Join curated networking activities If large mixers without a planned topic of conversation feel daunting, you can look for guided or themed activities where the conversation already has a starting point.  At Universe, you can connect with people who share your passions at structured networking meetup spots, including:  Recess!: Meet fellow attendees over your shared interests beyond the code. Whether you’re a Lego enthusiast or a die-hard Swiftie, there’s an opportunity for everyone to connect and simply have fun. Makerspace: Create interactive projects, from art to AI and music to robotics. Whether you build or just tinker, this is your playground. Open Source Zone: Connect with contributors and maintainers, explore open source projects, and celebrate the power of community-led software.  4. Set personal goals and boundaries Decide ahead of time what you want to get out of the event. Take a look at the agenda. What are your must-see sessions? Who are the people you want to meet? Build in plenty of breaks—without guilt!  Did you know that we offer a Universe agenda builder, curated schedules, and content tracks, so you can figure out the right sessions for your interests and goals? This makes it simple to stick to your plan (and pace yourself!).  5. Bring a conversation starter Wearing a T-shirt, pin, or sticker related to your passions makes it easy for someone else to approach you. It may even give you the confidence to approach someone else, too.  Universe swag (and plenty of community stickers) are designed to help spark those natural, low-pressure conversations. And if you don’t have any swag before the event, you can always visit The GitHub Shop and grab something day-of. We’ll have a brand new GitHub Universe collection, so you’ll be able to rep our latest and greatest.  6. Take it online with livestream or on-demand sessions If attending in-person still doesn’t feel right, don’t forget that you can attend GitHub Universe virtually or catch keynotes and select session recordings later on-demand. Our goal: Make sure you can still participate and stay connected in a way that works best for you.  To note: This might not always be an option at other tech conferences or events, but it’s always worth checking to see if there are ways to learn and connect from home if that’s your preferred method.  Conclusion We hope you see you at GitHub Universe this year. Don’t forget that however you plan to attend—in-person, virtually, just a few workshops, or somewhere in between—it’s all in your control. Whether you’re introverted (like us) or extroverted, or somewhere in between, we hope you have the best time!  [Register now] The post How to navigate GitHub Universe (or any tech conference) if you’re an introvert appeared first on The GitHub Blog. ​ Company news, News & insights, GitHub Universe The GitHub Blog

AI is driving a power surge—data centers could use 10% of U.S. electricity by 2028.   ​  ​AI is driving a power surge—data centers could use 10% of U.S. electricity by 2028. AI Services Blog | Dell

Discover expert insights on practical solutions for today’s AI workloads.   ​  ​Discover expert insights on practical solutions for today’s AI workloads. Artificial Intelligence Blog | Dell

See why we’re a leader in the Gartner® Magic Quadrant™ for Enterprise Storage Platforms.   ​  ​See why we’re a leader in the Gartner® Magic Quadrant™ for Enterprise Storage Platforms. PowerStore Blog | Dell

Cybercriminals target SMBs. Discover 8 strategies to boost cyber resilience and stay ahead of attackers.   ​  ​Cybercriminals target SMBs. Discover 8 strategies to boost cyber resilience and stay ahead of attackers. Endpoint Security Blog | Dell

Dell Reconnect program expansion – new Las Vegas pilot launched with The Salvation Army US.   ​  ​Dell Reconnect program expansion – new Las Vegas pilot launched with The Salvation Army US. Services Technology and Tools Blog | Dell

Break AI limits at your desk. Dell Pro Max with GB10 powers models up to 400B parameters—data center capabilities, right at your desk.   ​  ​Break AI limits at your desk. Dell Pro Max with GB10 powers models up to 400B parameters—data center capabilities, right at your desk. Launch Blog | Dell

Alienware’s ‘Parallel Realities’ blurs gaming and life. Spot the glitches, explore new dimensions, and redefine what’s possible.   ​  ​Alienware’s ‘Parallel Realities’ blurs gaming and life. Spot the glitches, explore new dimensions, and redefine what’s possible. Innovation Blog | Dell

Open, scalable, efficient infrastructure—AI-ready and enterprise-delivered.   ​  ​Open, scalable, efficient infrastructure—AI-ready and enterprise-delivered. Events Blog | Dell

Discover 5 key trends in multicloud storage that are helping businesses eliminate data silos and achieve unified, secure ecosystems.   ​  ​Discover 5 key trends in multicloud storage that are helping businesses eliminate data silos and achieve unified, secure ecosystems. Multicloud Blog | Dell

Harness the power of NPUs in your AI PCs with services for Dell Pro AI Studio.   ​  ​Harness the power of NPUs in your AI PCs with services for Dell Pro AI Studio. Artificial Intelligence Blog | Dell

Dell Federal 5G is an end-to-end solution designed and manufactured in North America to enable mission-critical use cases.   ​  ​Dell Federal 5G is an end-to-end solution designed and manufactured in North America to enable mission-critical use cases. Government Blog | Dell