GitHub Copilot — Agent Mode Review

The year 2025 is dominated by the new AI buzzword: AI agents. Tools like Cursor, Windsurf, and Cline have been offering so-called agent modes for quite some time, allowing developers to automate programming tasks. Surprisingly, GitHub Copilot, the most well-known AI-powered development tool, had not included such a feature — until now. With the introduction of Agent Mode, available in preview for Visual Studio Code, Copilot has taken a major step towards autonomous coding assistance.

Over the past few days, I have tested this new feature extensively. In this review, I’ll provide an overview of what GitHub Copilot’s Agent Mode can and cannot do, as well as areas where GitHub (or Microsoft) still needs to improve.

What is GitHub Copilot’s Agent Mode?

An AI agent is an autonomous system designed to perform tasks, make decisions, and adapt based on data and user feedback. It operates independently, automating processes across various domains, including software development.

Copilot’s Agent Mode follows this principle: it autonomously reads files, makes decisions, and executes code edits without requiring manual confirmation for each change. Unlike the traditional Copilot mode, users don’t have to approve every single modification. Instead, after the Agent completes a task, users can review and approve or reject the suggested changes.

GitHub Copilot’s new Agent Mode is capable of:

• Iterating on its own code, recognizing errors, and fixing them automatically.

• Suggesting terminal commands and prompting users to execute them.

• Analyzing run-time errors and performing self-healing operations.

Installation

To use the Agent Mode, you need to:

1. Download and install the Insider version of Visual Studio Code.

2. Install the GitHub Copilot plugin (Preview version).

3. Link your GitHub account to enable the feature.

4. Open the Copilot Edit panel and select Agent Mode from the menu at the bottom.

Once these steps are completed, you can start experimenting with Copilot’s new autonomous capabilities.

Use Cases for Copilot Agent

While the standard Copilot Edit Mode is great for implementing small features and making incremental improvements, Agent Mode is designed to handle larger, more complex tasks. Since I primarily work in the Angular ecosystem, I tested Agent Mode with Angular projects, but the workflow remains the same across different frameworks and technologies.

Test #1: Building a TodoMVC App with Angular

For my first test, I asked the Agent to create a TodoMVC application using Angular based on a simple screenshot. Initially, I planned to use Sonnet-3.5, but since Copilot does not yet support image inputs, I had to switch to GPT-4ofor this task.

Unfortunately, the Agent struggled with this seemingly simple request.

• It correctly initialized a new Angular project using the Angular CLI and started generating components and styles.

• However, since GPT-4o was trained on Angular 15, it could not use the latest Angular features in a brand-new project like the new control flow or signals.

• Even worse, the Agent failed to reference files it had previously generated, making it difficult to maintain project context.

• Additionally, it was unable to resolve compile errors autonomously, getting stuck in an infinite loop, focusing on irrelevant files.

Test #2: Enhancing an Existing Next.js App

In my second test, I asked the Agent to add a Testimonial section to an existing Next.js application, ensuring it was responsive. This time, I opted for Sonnet-3.5 instead of GPT-4o.

• The Agent correctly read the project’s package.json to identify relevant dependencies (Next.js, Tailwind, and Radix UI).

• It then generated the required components and integrated them into the application.

• The Next.js config was modified to allow the display of placeholder images.

• The initial implementation looked decent. When I later asked the Agent to enable automatic scrolling when the user reached the section, it also handled this well.

• Unlike in the first test, the Agent successfully fixed compile-time errors autonomously.

This test clearly demonstrated that Copilot’s Agent Mode works significantly better when given access to an existing codebase rather than generating a project from scratch. This aligns with my experience testing other AI coding agents.

Test #3: Code Review and Unit Testing in a Next.js Project

For the third test, I asked the Agent to review the code from the previous task and add unit tests using Jest. My goal was to determine whether:

1. The Agent unnecessarily altered its own previously generated code (a common issue with AI-generated code reviews).

2. It could independently set up Jest, since the project had no existing test setup.

• First, the Agent scanned the entire codebase to confirm that Jest was not yet installed.

• It performed the code review but did not suggest any changes — which was a positive sign.

• It then attempted to set up Jest and create unit tests.

• Interestingly, the Agent aimed for 100% test coverage but encountered a major issue: it got stuck in an infinite loop, failing to resolve JSX-related errors properly.

• Instead of fixing the JSX errors directly, it tried adding unnecessary dependencies, breaking the Jest setup.

• After multiple retries, it eventually managed to resolve the issue.

Preliminary Verdict

GitHub Copilot’s Agent Mode is a long-overdue step forward in AI-powered coding assistance. It enables developers to tackle larger tasks with simple prompts, reducing the need for manual intervention.

However, at the time of writing, Agent Mode still lags behind competitors like Cline and Cursor in key areas:

• Limited LLM support: Unlike its competitors, Copilot currently lacks a variety of model options.

• Context limitations: It does not yet allow for extended context inputs, such as local documentation or web links.

• Lack of robustness: The Agent still struggles with compile-time errors and complex project structures, often getting stuck in loops.

That being said, GitHub has confirmed that Agent Mode will eventually be available in all Copilot-supported IDEs, and they are actively seeking feedback to improve the experience.

I will continue monitoring GitHub Copilot’s Agent Mode and will share updates as new features are released. Stay tuned for future tests and comparisons!