GitHub Copilot for software and platform teams

GitHub Copilot is an AI coding assistant that integrates with editors, the terminal and the GitHub website. It generates code suggestions in real time, answers questions about your repository and can plan and execute multi-step tasks. Copilot is more than a prompt generator: its agent mode can analyse your codebase, propose changes, run commands and iterate until tests pass. This post explains how to set up Copilot, how its workflow differs from other tools, its memory feature, strengths and limits, and when to pick it.

What Copilot is

At its core, Copilot provides inline code suggestions in your editor and a chat interface. In the editor it predicts the next lines of code or entire functions from the surrounding context. Chat can answer questions about code, suggest fixes and generate documentation. Copilot also has a command-line interface, a code review feature that suggests improvements on your changes, and pull request summaries that describe what a change does. Agent mode is the most capable surface: it interprets a high-level goal, plans a sequence of steps, runs commands and tests, and refines its work over several iterations.

Setup and access

Copilot is available to subscribers on certain personal and enterprise plans, so check the GitHub documentation for current availability. To get started, install the Copilot extension in Visual Studio Code or JetBrains IDEs, or enable it on GitHub. For the terminal, install the Copilot CLI, which is generally available and adds a copilot command; you install it with npm (npm install -g @github/copilot, which needs a recent Node.js release, currently Node.js 22 or later; check the install docs for the current minimum), then launch it by typing copilot and authenticating with /login. Copilot Memory is enabled per user rather than per repository, and repository owners can review and delete the repository-level facts stored for their repository.

Core workflow

In typical use, Copilot runs in your editor and offers suggestions as you type. You accept a suggestion with the tab key or ask chat for clarification or alternatives. You can ask Copilot to write unit tests, refactor functions or explain code. In the terminal, the copilot command provides an agentic chat that can run commands, edit files and interact with GitHub.com.

Agent mode changes the workflow. Instead of producing a single suggestion, Copilot plans an end-to-end solution. It reads your repository, understands dependencies, proposes a plan and then executes by editing files and running commands, looping through planning, applying changes, running tests and refining until the goal is met. It can detect errors in terminal output, test results and builds, and iterate to fix them. You can review each step and adjust the plan. The Model Context Protocol lets you add custom tools and external resources that agent mode can call.

Memory

Copilot's agentic memory stores repository-level facts and user-level preferences. Repository facts cover conventions, build commands and cross-file dependencies, and are available to anyone with access to Copilot Memory in that repository. User preferences capture personal coding style and are visible only to that user, though on Business and Enterprise plans an organisation or enterprise administrator can export or delete them. Memory is shared across the Copilot coding agent, code review and the CLI, so a fact captured by one can be used by another. Unused facts and preferences are deleted automatically after a period of disuse (currently 28 days). Repository-level facts are scoped to the repository they came from, while user preferences follow the user across their interactions.

Strengths

• Context-aware suggestions. Copilot reads multiple files, learns your style and suggests idiomatic code, and its memory keeps suggestions consistent across sessions.
• Integrated chat and review. Chat answers questions, while code review suggests improvements and pull request summaries describe what changed, saving time during review cycles.
• Agentic automation. For tasks like migrating frameworks, adding tests or refactoring large modules, agent mode handles the repetitive steps, runs tests and iterates.
• Cross-surface availability. Copilot works in editors, the terminal and on GitHub, so you can use it where you work.

Limitations

Copilot is not a replacement for engineering judgement. It can generate incorrect or insecure code and relies on tests and human review to catch mistakes. Agent mode increases autonomy but still has limits and works best with clear goals and good tests. Repository-level memory is scoped to a single repository and unused entries expire automatically after a period of disuse, so it does not carry knowledge between unrelated projects on its own. Finally, Copilot is a paid product whose access is controlled by GitHub and may not be available in all regions.

When to choose Copilot

Use Copilot when you want an AI assistant deeply integrated with GitHub and your editor. It excels at routine coding, boilerplate generation and code review. Agent mode is valuable when you have well-defined goals and tests that the agent can run repeatedly, such as migrating a codebase to a new framework or adding comprehensive tests. Because its memory is repository-scoped for facts and its behaviour is governed by your approval settings, it fits teams that want automation with clear guardrails. It is less suitable where strict local control is required or where open source tools are preferred.