Empowering Your Code: Mastering GitHub Copilot's Agent Mode in VS Code Insiders (Free or Paid)

Disclaimer

‼️Remember, GitHub Copilot is a tool, not a shortcut. It enhances your workflow but doesn't replace hard work and experience. Using this tool doesn't automatically qualify you as a developer, so avoid making promises solely reliant on it.‼️

Introduction

GitHub Copilot’s Agent mode is a new AI-assisted coding feature that acts as an autonomous “AI agent” within your editor. Unlike traditional Copilot usage where you type a prompt or comment and get a one-off suggestion, Agent mode can perform multi-step tasks on its own. It doesn’t just suggest code – it can execute commands, iterate on the code, catch errors, and fix them automatically​. In other words, it’s like having a junior developer agent inside your IDE who can take a high-level request and work through the steps to complete it, including running code and debugging. This is a big shift from the classic prompt-based coding where the AI only reacts to each prompt you give. Agent mode proactively figures out what needs to be done next to fulfill your request. For example, if you ask it to “build a web app for X,” it might create multiple files, run installation commands, and keep refining until the app runs successfully – something traditional Copilot wouldn’t do on its own.

Currently, GitHub Copilot’s Agent mode is exclusive to Visual Studio Code – Insiders (the cutting-edge, preview version of VS Code) while it’s in public preview​. This means you’ll need VS Code Insiders to use it, as the feature isn’t in the stable VS Code yet. (The developers plan to bring Agent mode to all IDEs that Copilot supports once it’s polished.) The Insiders edition is used because Agent mode is experimental and still evolving. Using the Insiders build ensures you get the latest updates to both VS Code and Copilot that make this feature possible. Now, let’s dive into how to set everything up and get started with Copilot’s Agent mode!

Setup Guide

Using Copilot’s Agent mode involves a few setup steps. Don’t worry – we’ll go through each step in order:

1. Install Visual Studio Code – Insiders: If you haven’t already, download and install the VS Code Insiders edition (which can be installed side-by-side with regular VS Code). Agent mode is in preview and available to all Insiders users​, so this is a hard requirement. You can get VS Code Insiders from the official website. Install it like you would the normal VS Code. Here

2. Install the GitHub Copilot extensions: In VS Code Insiders, you need the GitHub Copilot tools. Make sure you have:

• The GitHub Copilot extension (for general autocomplete suggestions), and

• The GitHub Copilot Chat extension (this provides the chat sidebar where Agent mode lives, also known as Copilot Chat/Edits).

Open the Extensions view in VS Code Insiders and search for “GitHub Copilot”. Install “GitHub Copilot” (if not already) and “GitHub Copilot Chat”. After installation, you’ll be prompted to sign in with GitHub and authorize Copilot if it’s your first time. (You’ll need an active Copilot subscription or trial for it to work.) Once signed in, you should see the Copilot chat icon in VS Code’s sidebar.

3. Enable Copilot’s Agent mode in settings: Agent mode is still experimental, so you need to turn it on explicitly. In VS Code Insiders, go to Settings (Ctrl+, or Cmd+, on Mac). In the search bar, type “Copilot Agent”. You should see an option called “Chat: Agent: Enabled (Experimental)”. Check that box to enable it​. (It might be under GitHub Copilot > Chat in settings.)​

Settings in VS Code Insiders: enable “Chat > Agent: Enabled (Experimental)” to turn on Copilot’s Agent mode​.

4. Access the Copilot “Edits” view: Now that Agent mode is enabled, open the Copilot Chat/Edits panel. In VS Code Insiders, click the Copilot icon in the sidebar and switch to the “Copilot Edits” view (sometimes labeled as just “Edits”). You can also use the command palette and search for “Open Copilot Edits”. This panel is where you’ll interact with Copilot for multi-file edits and agent operations.

5. Switch the mode to Agent: At the top of the Copilot Edits panel, you’ll see a dropdown for the mode. By default it might be on Edit mode (which is for manual, step-by-step edits). Click that and select Agent. This toggles Copilot into Agent mode​. In Agent mode, you can type high-level instructions and Copilot will attempt to carry them out autonomously. The panel will indicate you are now in “Agent Mode (Experimental)” UI.

6. Select an AI model (Claude or OpenAI): Next to the mode dropdown, you’ll also see a model picker. GitHub Copilot allows you to choose which AI model powers the responses​. For example, you might see options like GPT-4o (an OpenAI GPT-4 model optimized for Copilot), Claude 3.5 (Anthropic’s model), or others. As of now, Agent mode supports OpenAI’s GPT-4 (referred to as GPT-4o), Anthropic’s Claude 3.5 “Sonnet”, and even Anthropic’s Claude 3.7. You can pick whichever model you want Copilot to use for the agent’s reasoning. (OpenAI’s models are very capable; Anthropic’s Claude is known for a larger context window and certain reasoning strengths – we’ll compare them soon.) In the Copilot panel, click the model name (e.g. “GPT-4o”) and select the model from the dropdown list. For example, you might switch to Claude 3.5/3.7 if you want to try Anthropic’s AI.

“Edit with Copilot” in Agent mode (VS Code Insiders). At the bottom, you can switch between Agent and Edit mode, and pick the AI model (GPT-4o shown here) for the Copilot agent.

Once these steps are done, you have Agent mode enabled and ready to use. To recap, the key parts were enabling the feature in VS Code Insiders settings, and then in the Copilot Edits view choosing “Agent” mode and an AI model. Now you’re set to let Copilot off the leash! Let’s see how to use Agent mode effectively.

Using Agent Mode Effectively

Using Agent mode feels a bit different from the normal Copilot suggestions or chat – you’ll be giving higher-level instructions and the AI will take initiative to execute them. Here’s how to interact with it and some tips for effective use:

How to interact with the Agent: In the Copilot Edits (Agent) panel, you simply type a request or goal in natural language and hit Enter. Think of it like telling a junior developer what you want. For example, you could ask: “Create a simple Express.js app with a homepage and about page,” or “Add a new function to sort a list of numbers in the current file.” When you submit your prompt, Copilot will: (1) analyze your workspace and open files, (2) determine which files or sections need to change or be created, (3) generate code changes, and even (4) run commands or tests if needed to verify the changes. It works in a loop, meaning it might make some edits, then notice it should do another step, do that, and so on until it believes the task is complete​.

Full AI assistance vs. prompt-based input: In traditional prompt-based coding (like using Copilot Chat in normal mode), you might ask for a snippet and then you, the developer, integrate it into your code and run it. With Agent mode, you’re letting the AI handle much more. For example, if you say “Set up a React project with a navbar component,” Copilot in Agent mode could create new files like App.jsx, Navbar.jsx, add needed imports, maybe run npm install for React, etc., without you explicitly prompting each step. You’ve essentially moved from giving one prompt at a time to describing an end goal and having a conversational partner that figures out sub-tasks. This means you should describe your goal or problem clearly. The agent might even infer tasks you didn’t mention but are necessary to get the job done (as an example, if you ask for an API endpoint, it might also add error-handling code or documentation comments because it “assumes” those are useful)​.

What the Agent can do (examples): Copilot’s Agent is quite powerful. It can create new files and scaffolding from scratch, refactor code across multiple files, write and run tests, and more​. For instance:

• Building applications: You can ask for a small app or feature in various languages. “Generate a Python Flask app with two endpoints” or “Create a new Rust project that reads a JSON config and prints stats.” The agent will generate multiple files (if needed), set up the project structure, and even run build/test commands. In fact, GitHub showed an example of Copilot agent mode building a web app to track marathon training from just a prompt​github.blog. It’s like giving a project spec to an assistant.

• Website tasks: You could say “Make a simple HTML page with a CSS stylesheet for a product landing page.” The agent might create an index.html and a styles.css, fill them in, and maybe open a preview.

• Refactoring and editing: Agent mode shines in existing projects too. You can ask “Refactor this code to use async/await instead of callbacks” – Copilot will update multiple files accordingly, run the code or tests to ensure it still works, and even iterate if something breaks.

• Debugging and fixing: If you have a runtime error or failing test, you can tell the agent to fix it. For example, “Fix the TypeError thrown when logging in.” The agent can run the app or tests, see the error, locate the bug, patch the code, and re-run to check if it’s resolved, all in one go (this is the “self-healing” ability). It essentially automates the cycle of “write code -> run -> debug -> fix.”

• Q&A about codebase: You can also use agent mode to ask questions like “How is the user authentication implemented in this repo?” The agent will read through the codebase to explain or even open relevant files. This is similar to chat, but with the ability to open files for you.

• Multi-step tasks: If you need to do something like “Add feature X to our project,” Agent mode might: create new files, modify existing ones, run npm test or pytest to ensure everything passes, and keep iterating until tests are green. All from one initial prompt (with your guidance as needed).

Example – Building a Feature with Agent mode: Let’s say we have a JavaScript project and we want to add a new function and its unit tests. In Agent mode, we could write: “Implement a function isPrime(n) in mathUtils.js and add unit tests for it.” Copilot will find or create mathUtils.js, write the isPrime function. It might then create a test file like mathUtils.test.js with several test cases. It could even run the test command (e.g., npm test) if configured, see if tests pass, and if a test fails, automatically fix the code. You, as the developer, would see the agent’s actions streaming in the Edits panel – you can watch as it writes code and possibly asks your permission to run a command. When it suggests running a terminal command (like installing a package or executing tests), it will pause and ask for confirmation. You simply click “Approve” or “Run” for the command when prompted​. This safety check lets you stay in control (it won’t execute anything on your system without you okaying it).

Agent mode UI and controls: While the agent works, you’ll see a list of changes (edits) it proposes in the Copilot Edits panel. You can review these changes. Even though the agent can auto-apply them, you still have the final say – you can accept or revert changes if something looks off. You’ll also notice the “Working Set” area where you can add specific files to focus the agent, but by default it will consider the whole workspace. If the agent wants to run a terminal command (say, to install dependencies or run a build), the Copilot chat will show a notification asking for your approval​. This is a good practice: always review what command it’s about to run and make sure you understand it (e.g., running your test suite is fine, but you wouldn’t want it to run a destructive command). Copilot’s agent will typically run non-destructive things like linters, compilers, or tests that you would run anyway.

Transitioning from prompts to “AI coworker”: It might take a little adjustment to use Agent mode effectively. Here are some tips:

• Be clear in your initial prompt: Describe the end goal or problem, not just a single step. The agent is good at figuring out steps, but it needs to know the objective. For example, instead of prompting “add code for login,” say “add a login feature with username/password, including a login form in the frontend and authentication in the backend.”

• One thing at a time: While you can ask for complex tasks, it’s often wise to tackle one feature or issue per agent session. Let it finish (or stop it if it’s going astray) before moving to the next.

• Interact when needed: You’re not hands-off entirely. You can and should intervene with follow-up instructions. If the agent’s first attempt isn’t perfect, you can say things like “Now fix the styling in the HTML you created” or “The function isPrime isn’t efficient, improve it.” It’s a dialogue – you give high-level feedback and the agent refines the work.

• Review changes: Agent mode can save you a ton of typing, but you should read through what it produced. Think of it as code review. Ensure the logic matches your intentions and no subtle bug crept in. The good news is it often catches and fixes its own bugs, but it’s not infallible.

• Know when to use it: Agent mode is amazing for boilerplate setup, repetitive refactoring, or gluing things together across files. For very delicate, logic-heavy sections, you might still prefer to guide Copilot step-by-step. You have both modes available – Chat (or Edit) for more control, and Agent for letting it handle busywork.

With practice, interacting with the agent will feel like managing a very fast and diligent collaborator: you say what you want, it does a lot automatically, and you course-correct with brief instructions as needed. In the next section, we’ll visually compare how Agent mode fares with different languages and talk about the AI models (Claude vs OpenAI) you can choose.

Comparison – Language Support and AI Models

GitHub Copilot works across many programming languages, but you might wonder which languages Agent mode handles best. Generally, Copilot (and its underlying models) perform especially well for popular languages with lots of training data. According to GitHub, languages like JavaScript/TypeScript, Python, Java, Ruby, Go, C#, and C++ are among those where Copilot excels​. In fact, “JavaScript is one of GitHub Copilot’s best supported languages” due to its abundance in public repos​. For less common languages or obscure frameworks, Copilot may still work, but the suggestions might be less robust.

To illustrate this, here’s a quick overview of Copilot’s performance across languages (information gathered from Copilot docs and user reports):

• JavaScript / TypeScript: Performance is Excellent – Agent mode can handle full-stack JS tasks easily (Node, React, etc.). These languages are well-represented in training data, so the AI is very fluent.

• Python: Excellent – Very strong support (for web, data science, scripts, etc.)​. You can confidently use Agent mode for Python automation or Django/Flask app generation.

• Java: Very Good – Copilot knows common Java patterns (OOP, Android, Spring) and Agent mode can manage multi-file Java projects well.

• Ruby: Good – Rails conventions are supported and Agent can produce usable code. Possibly fewer training examples than JS/Python, but still effective.

• Go: Good – Copilot can write Go code and handle goroutines, etc. You might see it handle Go projects decently in Agent mode.

• C#: Good – Strong for typical C# usage (e.g., .NET APIs). Copilot has seen a lot of C# code​.

• C/C++: Moderate – Basic generation is fine, but these languages have many low-level details​. Agent mode can help with simpler C/C++ tasks, but for complex systems you might need to guide it more.

• PHP: Good – It can generate PHP code and even simple WordPress plugins or Laravel code​.

• Shell/Bash: Good – Handy for writing scripts; Agent can automate writing of shell scripts and command sequences​.

• HTML/CSS: Good – Copilot can generate boilerplate HTML, CSS styles, and even work from a description or mockup to code (especially with the Vision feature for images).

• Kotlin/Swift: Good – It can assist with mobile app code (Android/iOS) to some extent​.

In summary, Agent mode works best with mainstream languages like JS, Python, Java, etc., where it’s most knowledgeable. It still works with many other languages (even ones not listed above, like PHP, Rust, Scala, etc.), but the more niche the language, the more you may need to verify and tweak the output. The advantage of Agent mode is that it will try to run or compile the code it writes, so it often catches mistakes even in languages it’s less familiar with. That said, you’ll get the smoothest results in the popular ecosystems.

Now, let’s talk about the AI models behind Copilot, and the choice between Claude vs OpenAI in Agent mode. As mentioned, you have access to different LLMs (Large Language Models) in Copilot Chat/Agent. Each has its strengths:

• OpenAI’s GPT-4 (GPT-4_o): This is the default model for Copilot Chat. GPT-4 is very strong in reasoning, coding capabilities, and understanding context. It’s been fine-tuned for code by GitHub (the “o” variant likely indicates an OpenAI model optimized for Copilot). GPT-4 tends to be very accurate in coding tasks and can handle instructions well. It also currently supports things like Vision (image inputs) when using Agent mode (the tech community blog noted GPT-4o supports image uploads in chat​). The downside might be it has a somewhat smaller context window (8K or 32K tokens depending on variant) compared to Anthropic’s model, and it may sometimes be slower.

• Anthropic’s Claude 3.5 (Sonnet) & Claude 3.7 (Sonnet): Claude is another powerful model known for a very large context window (up to 100K+ tokens) and a conversational style. In initial testing, the VS Code team found that Claude performed exceptionally well for Agent mode tasks, even preferring it over GPT-4o in their own usage. This suggests Claude might be better at the multi-step autonomy or handling larger codebases. Claude is also designed to be helpful and less likely to refuse or get stuck on certain tasks. However, Claude might sometimes be a bit more verbose or take creative approaches that you might need to steer.

Claude vs OpenAI – which to use? It’s great that Copilot lets you choose. Some key considerations:

• Both models can understand and generate code in all the major languages we listed. They have been trained on similar data (GitHub code etc.). So you might not notice a huge difference for everyday tasks.

• Claude 3.5 might have an edge in iterative problem-solving and larger projects (due to that large context). If you have a big codebase and ask the agent a broad question (“find all uses of X and refactor to Y”), Claude might handle the extensive context better. The VS Code team saw “significant improvements in Copilot agent mode functionality” with Claude 3.7 (an updated Claude). This implies Claude might make the agent more effective at planning multi-step solutions without as much guidance.

• GPT-4 (OpenAI) is extremely capable and might excel in precise coding tasks and understanding subtle instructions. It’s also the only one (currently) that can accept image inputs in Copilot (for example, you can paste a screenshot of an error or a UI and GPT-4o will understand it in Vision mode). If your task involves analyzing an image (maybe a UI mockup to generate code), GPT-4o is the go-to. The Microsoft blog even recommends GPT-4o for scenarios needing image support.

• Response style: Some users have noted that GPT-4’s style might be a bit more straightforward, whereas Claude can be a bit more chatty. In code generation context, this mostly affects how much explanation or comments the agent provides. You can instruct either model to be more concise if needed.

• Speed and limits: Depending on your Copilot plan, model speeds and rate limits may vary. Sometimes Claude might respond faster or slower than GPT-4, or vice versa, depending on server loads. If one model ever seems unresponsive, you can switch to the other as a fallback.

Practically, you can experiment with both Claude and OpenAI models for the same task to see which one you prefer. The good news is you can change the model on the fly: as you saw in the setup, the model picker lets you select GPT-4o, Claude, etc., even in the middle of a session. (When you switch, you might want to retry the prompt so the new model processes it from scratch.)

To sum up the comparison: Copilot’s Agent mode works across many languages (best with popular ones like Python/JS/etc.), and you have a choice of top-tier AI models (OpenAI GPT-4 or Anthropic Claude) to power it. Each model is competent; OpenAI’s might handle certain coding queries slightly better, while Anthropic’s might handle longer, more complex sessions. The nice part is you have the freedom to choose the one that feels most “helpful” for your project​.

Use Cases and Examples

Let’s explore a few concrete scenarios where Copilot’s Agent mode can boost your productivity, and some best practices to get the most out of it:

1. Project Setup and Scaffolding: Imagine you want to set up a new project quickly. For example, “Create a new Node.js Express server with a few basic routes and Dockerfile.” Using Agent mode, you can ask for that in one go. The AI will initialize a project (generating package.json, perhaps running npm init internally), create an index.js with an Express app, add routes, and even generate a Dockerfile. It might even suggest running npm install express – which you can approve – to make sure the code runs. In a few minutes, you have a runnable skeleton of your app without manually typing all boilerplate. This no-code or low-code project bootstrap is a huge time-saver. (There’s a YouTube video titled “Build Project with no-code | GitHub Copilot” demonstrating something similar, where they use VSCode Insiders and Copilot to create a project without writing code themselves.)

2. Adding a Feature to an Existing App: Suppose you have a Python Django application and you need to add a new model and corresponding REST API endpoints. Traditionally, you’d write the model, migrations, views, serializer, URL config, etc. With Agent mode, you can instruct: “Add a Product model with fields name, price, and create REST API endpoints to list, create, update, delete products.” Copilot will: create or modify the Django model in models.py, generate a serializer in serializers.py, add views (maybe using Django REST Framework) in views.py, update urls.py with new routes, and so on. It will essentially perform a multi-file edit session for this feature. After generating, it could run python manage.py makemigrations and migrate (if you allow) to apply the database changes, and maybe even run the development server to verify things. This kind of end-to-end feature implementation showcases how you can turn a high-level spec into working code quickly. Your job becomes reviewing those changes and maybe adjusting any business logic nuances.

3. Fixing a Bug Across Multiple Files: Let’s say your project has a bug – whenever a user tries to upload an image, an error is thrown in the log. You only know the error message or general area. You can prompt: “Fix the error that occurs when uploading an image (the error says undefined variable imagePath).” Agent mode will search your code for where this might be happening. It might find that in one file the variable is misnamed, or not passed correctly. It can then apply a fix. If it’s not sure, it might ask for permission to run the app or tests to reproduce the error. Upon finding the error, it will change the code (maybe adding a check for imagePath or correcting the variable name). It will then suggest running the function or test again. This iterative loop continues until the error is resolved – all orchestrated by the AI agent​. This is far more efficient than manually grepping through the code and fixing in piecemeal fashion.

4. Documentation and Explanation: Another use case is getting documentation or understanding code via Agent. You can ask, “Generate documentation comments for all functions in this file,” and it will insert docstrings or comments in the code where appropriate. Or “Explain how the authentication flow works in this repository,” and it will gather context from various files (models, controllers, etc.) and present you an explanation. This is useful when you inherit a new codebase – Copilot can act as a tutor walking you through it. Just remember to verify its explanations align with reality (it’s usually correct when describing code, especially if it cites the code, but subtle logic might need double-checking).

5. Front-end UI generation (using Vision): A very cool example: you have a design mockup (say, an image of a webpage or a hand-drawn UI). Copilot Chat (with GPT-4 model) has a feature called Vision that can take images. In VS Code Insiders, in Agent mode, you could attach an image (e.g., a screenshot of a simple form design) and prompt: “Generate an HTML/CSS page based on this design.” Copilot (with GPT-4o) will analyze the image and produce the corresponding HTML and CSS code​. This is cutting-edge and might require that you selected GPT-4 as the model, but it shows how Agent mode can integrate different modalities (code + images) to build things. Microsoft’s blog post actually demonstrated generating a Python Flask app from a UI screenshot using Copilot Agent mode​. The agent created the necessary frontend and backend code in one go.

Best Practices for Efficiency:

• Small Iterations: If you have a huge task, break it into smaller prompts. This helps the agent not get overwhelmed and keeps the context focused. You can do step 1, verify, then step 2, etc., rather than one giant prompt that might produce too much to review.

• Leverage the Working Set: In the Copilot Edits view, you can add specific files to the “working set” (a list of files of interest). In Edit mode this is used to limit where changes happen. In Agent mode, it can serve as a hint of which areas are relevant. If you know the changes should only occur in certain files, consider adding them to the working set to keep the agent focused.

• Review and Test: After the agent finishes, always run your application or tests (if it hasn’t already) to ensure everything truly works. While Agent mode does a good job of self-checking (it can run tests), it’s good to double-check in your environment. Also run any linters/formatters – Copilot might not automatically format exactly to your standards, though it often does a decent job.

• Provide Feedback: If Copilot does something not quite right, you can correct it or ask it to fix it. For example, “That function isn’t thread-safe, please fix it.” This back-and-forth can hone the result. Also, giving a thumbs-up/down in the chat UI for its answers helps improve the product.

• Security and Privacy: Be mindful that Copilot’s AI doesn’t have awareness of proprietary requirements unless you tell it. So if you have certain security constraints (e.g., “don’t log user passwords”), make sure to mention or check for those. The agent won’t intentionally write insecure code, but it may not know your app’s specific policies unless instructed.

By using Copilot’s Agent mode in these ways, you can accelerate development for both new projects (scaffolding a lot quickly) and existing ones (automating repetitive refactors or fixes). It’s like a superpower for tedious coding tasks – letting you focus on the logic and design while the AI handles the grunt work.

Conclusion

GitHub Copilot’s Agent mode represents a significant leap in AI-assisted development. To recap, Agent mode allows Copilot to not just suggest code, but to act as an autonomous coding assistant – it can write multi-file solutions, execute commands, and iteratively refine its output until your request is fulfilled​. This can dramatically speed up tasks like project setup, codebase refactoring, bug fixing, and more, by automating the usually time-consuming parts. The key benefits include saving time on boilerplate and routine code, catching errors faster (since the agent often runs and tests the code it writes), and enabling you to work at a more abstract level (“tell the computer what to do” rather than “how to do it line-by-line”).

We also discussed how it’s currently only available in VS Code Insiders while in preview, and how to enable it and choose between different AI models. With a couple of clicks, you can switch between OpenAI’s and Anthropic’s models – giving you flexibility to use the AI that best suits your needs (or even compare them side by side for fun!). Many developers find that after getting used to Agent mode, it feels like having a co-developer who can handle the boilerplate and mechanical parts of coding, allowing you to stay in the creative flow.

Keep in mind: Copilot’s Agent is powerful, but it’s not infallible. Always keep an eye on what it produces – review the code, run your tests, and ensure it meets your requirements. Think of Agent mode as a very capable assistant: it does a lot of the heavy lifting, but you’re the lead developer who makes final decisions. Used wisely, it can significantly boost your productivity and even help you learn (by observing how it approaches problems or frameworks you’re less familiar with).

We encourage you to experiment with Agent mode on a side project or a piece of code you’re comfortable with. Try asking it to build something simple, or perform a refactor you’ve been putting off, just to see how it operates. You might be surprised at how much it can do. As you grow more confident, you can gradually let it handle more complex tasks. Remember, you can always fall back to the regular Copilot suggestion mode or do manual edits – Agent mode doesn’t take that away; it’s an added tool in your toolbox.

In conclusion, GitHub Copilot’s Agent mode can be a game-changer for both beginners and experienced developers. Beginners get to see whole solutions come together (which is great for learning by example), and seasoned devs can automate mundane tasks and focus on higher-level architecture or critical algorithms. It’s like having a pair programmer who never gets tired of doing the boring stuff!

Give it a try in VS Code Insiders, and have fun coding with your new AI assistant. Happy coding, and welcome to the future of software development where you can “tell” your IDE what you need and watch it happen!

Additional Resources: If you want to learn more, check out the official GitHub Copilot docs (especially the sections on Copilot Chat and Agents), and the GitHub Blog post “The agent awakens” introducing Agent mode​. There are also community tutorials and videos coming out as developers explore this feature – you’re on the cutting edge, so enjoy the journey of discovering what Copilot Agent can do for you. Good luck, and happy experimenting with Agent mode!