Thoughts on Github Copilot Agent Mode

What it Github Copilot

GitHub Copilot is a coding assistant developed by GitHub. It integrates directly into popular code editors like Visual Studio Code and IntelliJ IDEA providing real-time code suggestions, auto-completions, and even entire function or class implementations as you type. Copilot leverages a large language model trained on codebases of public code, enabling it to understand context, infer intent, and generate code snippets in dozens of programming languages.

What is Github Copilot Agent Mode

GitHub Copilot Agent Mode is an advanced feature that transforms Copilot from a passive code completion tool into an interactive, task-oriented coding assistant. In Agent Mode, Copilot can execute multi-step instructions, manage files, generate and refactor code, write documentation, and even run tests. All within the context of your project. Instead of just suggesting code line-by-line, the agent can take on broader tasks, updating documentation, or implementing a set of unit tests based on your requirements.

Agent Mode is designed to work conversationally: you describe what you want to achieve in natural language, and the agent interprets your intent, plans the necessary steps, and executes them. It can reference your project’s files, follow architectural guidelines, and maintain context across multiple actions. This makes it especially powerful for rapid prototyping, automating repetitive workflows, and managing project-wide changes.

How to get Agent mode working

Getting started with GitHub Copilot Agent Mode is straightforward, but there are a few prerequisites and steps to ensure a smooth setup. Here’s how you can enable and start using Agent Mode in Visual Studio Code:

1. Prerequisites

Before you begin, make sure you have the following:

• A GitHub Copilot Subscription: Agent Mode is available to users with an active Copilot subscription (individual or business).
• Visual Studio Code Installed: Download and install VS Code if you haven’t already.
• Latest GitHub Copilot Extension: Ensure you have the latest version of the GitHub Copilot extension installed in VS Code.

2. Enabling Agent Mode

Once your environment is ready, follow these steps:

1. Open VS Code and navigate to the Extensions sidebar.
2. Search for “GitHub Copilot” and install or update the extension if needed.
3. Sign in to GitHub within VS Code. You’ll be prompted to authenticate your GitHub account and verify your Copilot subscription.
4. Access Copilot Chat:
   • Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P on Mac).
   • Type “Copilot: Chat” and select it. This opens the Copilot Chat panel, which is where Agent Mode lives.
5. Activate Agent Mode:
   • You will see something like this hopefuly:
   • Where you see “Ask” change to “Agent”

Use-case - Simple Toolset Becomes Easier

When it comes to building or extending a simple toolset think utility scripts, helper classes, or basic automation—GitHub Copilot Agent Mode shines. For these straightforward tasks, the agent can often deliver results in minutes that might otherwise take you half a day or more, especially if you’re juggling boilerplate, repetitive code, or tedious setup.

Where Agent Mode excels:
If your requirements are clear and the scope is limited (for example, generating a file parser, scaffolding a CLI tool, or creating a set of data transformation functions), you can describe your intent in natural language and let the agent handle the heavy lifting. In my experience, for these “simple toolset” scenarios, Copilot Agent Mode is not just fast—it’s surprisingly accurate. You can often skip the usual cycle of manual setup, copy-pasting from Stack Overflow, or reading the documentation of libraries to find the most appropriate solution for a particular case.

Tips for best results:

• Be explicit: Even for simple tools, provide a clear description of what you want. For example, “Create a Python script that reads a CSV and outputs a JSON file” works better than “Make a CSV tool.”
• Iterate conversationally: If the first result isn’t perfect, refine your prompt or ask the agent to tweak specific parts. The conversational flow makes it easy to adjust requirements on the fly.
• Review the output: While Agent Mode is great for simple tasks, always review the generated code for correctness, security, and style. For anything that touches production or sensitive data, at least quick manual check is a must.

When to add more rigor:
If your project starts to grow in complexity—maybe you need to handle edge cases, integrate with external APIs, or enforce strict architectural patterns—consider supplementing Agent Mode with automated tests and more detailed requirements. The more context you provide (sample inputs/outputs, constraints, edge cases), the better the agent performs. For anything beyond “simple,” I recommend setting up tests early to catch regressions as the agent makes changes.

Bottom line:
For simple, well-defined tools, Copilot Agent Mode is a genuine productivity booster. It’s like having a colleague developer who never gets tired of writing code or wiring up basic logic. Just remember: the simpler the task, the more likely you’ll get a near-perfect result on the first try.

Don’t forget documentation

Agent can easily help on writing documentation, be careful on reviewing it appropriately so that it doesn’t become confusing. Lack of documentation is bad , but misleading, not clear and overly complex documentation is not better!

Tests, tests, tests

Even if you don’t start with tests upfront, consider using it to cover a few scenarios it won’t likely be 100% complete but will be a start and now it is even easier!

What about instructions.md?

GitHub Copilot’s .instructions.md feature is, in essence, a repository-level system prompt. By placing this file in your repo, you’re giving Copilot a persistent, always-on set of instructions - just like Beck’s system prompt( check the references for more!). This file can encode your team’s coding standards, preferred libraries, architectural patterns, and even project-specific quirks. The result: Copilot’s suggestions become more consistent, relevant, and tailored to your actual workflow.

Conclusion

GitHub Copilot Agent Mode is a powerful leap forward for developer productivity, especially when paired with thoughtful workflows and a bit of discipline. The real magic happens when you treat the agent as a junior collaborator: give it clear instructions, set boundaries, and always review its work.

Following Kent Beck’s approach, creating a “system prompt” - a guiding document or set of instructions to refer to throughout the session yields the most consistent results, or if specifically using Github Copilot you might also find instructions.md interesting! For example, keeping a plan.md in the project that outlines requirements, edge cases, and test scenarios serves as a living reference for both your own thinking and for guiding Copilot’s actions. This method helps maintain clarity and context as the project evolves.

Embrace a test-driven approach whenever possible. Let the agent help you scaffold tests, then iterate on the implementation. While Copilot can generate both code and tests, always review and refine what it produces - especially for anything critical. Don’t hesitate to restart the session or clarify your instructions if the agent starts to drift or lose context; a fresh start can often get things back on track.

In summary:

• Always have tests—whether auto-generated or hand-written—to validate your use cases and catch regressions.
• Agent Mode shines for small projects, prototypes, and utility scripts where speed and iteration matter more than perfect architecture.
• It’s a great way to explore new languages or frameworks, letting you see how different technologies fit together with minimal friction.

Used thoughtfully, Copilot Agent Mode can be a genuine force multiplier. It won’t replace your expertise or judgement, but it will free you from boilerplate, accelerate prototyping, and let you focus on the creative, high-value parts of software development. Treat it as a partner, not a replacement—and you’ll get the best of both worlds.

References

Augmented Coding: Beyond the Vibes - by Kent Beck Adding repository custom instructions for GitHub Copilot - GitHub Docs