GitHub Copilot: workflow and limitations

GitHub Copilot is GitHub’s artificial intelligence programming assistant. The overview page sums up what it does: it suggests code as you type, answers questions about a project, reviews changes and carries out tasks you delegate.

This article is based on GitHub’s official documentation, consulted on October 8, 2026, and on academic studies. The newsroom did not test the product for this article. Copilot changes frequently; the features, names and prices cited here apply as of the date consulted.

Assistant and agent: the two ways of working

The documentation divides the features into four groups. Assistive features respond while you work: they suggest, explain and answer, and you review and apply each suggestion. Agentic features receive a goal and work in several steps: they search the repository, propose a plan, edit files, run tools and prepare the result for review. The other two groups are customizations (instructions, reusable prompts, custom agents) and external agents and tools, such as agents from other vendors and MCP servers.

MCP (Model Context Protocol) is an open standard for connecting AI agents to services and data sources. If the concept of an agent is new to you, see what AI agents are.

In all groups, the official text repeats the same sentence in different forms: you remain responsible for reviewing and approving.

In the editor: suggestions, chat and local agent

The page on Copilot in IDEs (development environments such as VS Code, Visual Studio and JetBrains) describes three forms of use.

Inline suggestions appear as dimmed text at the point where you are typing. They may complete part of a line, the whole line or a larger block. You can also write a comment in plain language describing what you want and let Copilot propose the implementation.

Next edit suggestions predict where you will edit next and what you will change. The documentation’s example: after renaming a method, Copilot suggests updating another affected section.

Chat answers questions about the selected code, the open files or the project, suggests fixes, generates tests and compares approaches. For larger tasks, an agentic experience splits the request into steps, inspects the project, edits several files, runs commands in the terminal and reacts to errors. These changes happen in your local environment, and the documentation asks you to review the changes and command output before accepting.

The same page says Copilot works especially well with Python, JavaScript, TypeScript, Ruby, Go, C# and C++. In languages less represented in public repositories, quality tends to drop.

There is also Copilot CLI, the terminal version. According to the agents application card, by default it only accesses the folder where it was started and asks for permission before modifying files and running potentially dangerous commands. Options such as --allow-all unlock everything, which the documentation associates with autonomous mode.

On GitHub.com: cloud agent, review and automations

The page on Copilot on GitHub.com describes the workflow that sets Copilot apart from simple autocomplete. A change can start as an issue (a record of a task or problem), be picked up by the agent, come back as a pull request (a request to include code), go through review and be merged.

The cloud agent (Copilot cloud agent) searches the repository, plans and implements in the background, in a temporary development environment in the cloud, where it can edit files and run tests and linters (automatic style and error checkers). It creates the branch, writes the commit messages and pushes the changes. You can follow the session, talk to the agent while it works and request adjustments by commenting on the pull request with @copilot.

Code review (Copilot code review) analyzes the changes in a pull request, points out problems and suggests fixes that can be applied in a few clicks. The code review page says that, by default, Copilot’s review does not count as a required approval. An option in public preview allows it to count, and the approval is dismissed if new commits arrive.

Automations run tasks defined once, such as triaging issues or preparing release notes every week.

How to guide Copilot with instructions

Instead of repeating context with each request, you can write custom instructions. The customization page lists three levels in the repository: general instructions in a .github/copilot-instructions.md file, path-specific instructions in NAME.instructions.md files inside .github/instructions and agent instructions in AGENTS.md, CLAUDE.md or GEMINI.md files. There are also personal instructions and, on Business and Enterprise plans, organization instructions.

The same page makes an important caveat: because of the non-deterministic nature of AI, Copilot may not follow instructions in exactly the same way every time. Instructions are guidance, not a guarantee. To write better instructions, see prompt engineering.

The limitations GitHub itself declares

GitHub publishes “application cards” that describe intended uses and limits. The points below come from the inline suggestions card, the agents card and the GitHub.com page.

Code that looks right but is not. Copilot may generate apparently valid code that is not correct, either syntactically or semantically, or that does not reflect the developer’s intent. The guidance is to review and test, especially in critical applications. To understand why models make confident mistakes, see AI hallucinations.

Limited view. Inline suggestions are based on the surrounding code, so they may not notice larger design or architecture problems.

Security. Generated code may contain vulnerabilities and, depending on the context, expose sensitive information. GitHub recommends extra care in security-sensitive applications.

Incomplete reviews and false alarms. Code review may miss problems, especially in large or complex changes, and may flag defects that do not exist. The documentation says Copilot “is not guaranteed” to find all problems and calls for complementary human review.

Code matching public code. Copilot may suggest snippets identical or nearly identical to code from public repositories. According to the IDE page, this occurs in less than 1% of suggestions, and there is a policy to block or flag these cases, with a link to the source and license. The agents card notes that the cloud agent and the CLI may generate this kind of code even with blocking enabled.

Destructive commands. In the CLI, the card warns about commands that delete files or format disks and says responsibility for the commands executed is yours.

Operational limits of the cloud agent. According to the GitHub.com page, each task touches a single repository, works on one branch at a time and opens one pull request per task. Each session has a 59-minute limit, which cannot be extended; the recommendation is to split complex tasks. The agent only works with repositories hosted on GitHub, and incompatible branch protection rules may block it.

The cloud agent’s protections

The agents card describes the barriers that come enabled:

• the agent only responds to users with write permission on the repository;
• it only pushes code to its own branch (such as copilot/...) and cannot write directly to the main branch;
• GitHub Actions workflows triggered by the agent’s pull requests require human approval;
• organization secrets are not available, only those registered in a specific Copilot environment;
• a firewall enabled by default tries to prevent code or data from leaving;
• new code goes through automatic analysis for vulnerabilities (CodeQL), exposed secrets and dependencies known to be vulnerable;
• commits are signed, with Copilot as the author and the person who requested the task as co-author, with a link to the session log.

These protections reduce risks, but the same document insists that you should review everything the agent produces before merging.

How much it costs

As of the date consulted, Copilot measured usage in AI credits. According to the billing page for individuals, each interaction consumes input and output tokens, with a price that depends on the model; the total becomes credits, and 1 credit equals US$ 0.01. A token is the unit of text the model processes; see tokens in AI models.

The plans page, consulted on October 8, 2026, listed:

Plan	Monthly price	AI credits per month
Copilot Free	Free	Limited allowance, automatic model selection only
Copilot Pro	US$ 10	1,500 (1,000 base + 500 flex)
Copilot Pro+	US$ 39	7,000 (3,900 base + 3,100 flex)
Copilot Max	US$ 100	20,000 (10,000 base + 10,000 flex)
Copilot Business	US$ 19 per user	1,900 per user
Copilot Enterprise	US$ 39 per user	3,900 per user

There is also Copilot Student, free for verified students. The “flex” portion (flex allotment) is, according to GitHub, an additional allowance designed to adjust to the evolution of AI costs, meaning it may change. Credits do not roll over: they reset on the first day of each month.

Code suggestions and next edit suggestions do not consume credits and are unlimited on paid plans; the Free plan includes 2,000 code suggestions per month. Chat, CLI, the cloud agent and third-party agents consume credits. The documentation warns that a long agent session with a frontier model, across several files, costs much more than a quick question.

What studies found

The most cited result about Copilot comes from a 2023 controlled experiment: developers with access to Copilot implemented an HTTP server in JavaScript 55.8% faster than the group without the tool. Two things are worth knowing. The authors are affiliated with Microsoft Research, GitHub and MIT, meaning the study is not independent of the manufacturer. And the task was single and well defined, unlike work on a large project.

On security, a 2021 academic study, presented at the 2022 IEEE Symposium on Security and Privacy, asked Copilot to complete 89 scenarios related to common security flaws. Of the 1,689 programs generated, about 40% had vulnerabilities. The test used the version of Copilot available at the time, much older than the current one.

A 2023 study looked at real code in GitHub projects, generated by Copilot and two competing tools. Of the 733 snippets analyzed, 29.5% of the Python snippets and 24.2% of the JavaScript ones had security weaknesses, in 43 categories. When the authors gave Copilot Chat the alerts from static analysis tools, it fixed up to 55.5% of the problems. In the newsroom’s reading, the lesson is practical: combining the assistant with automatic verification tools works better than relying on it alone.

For the broader debate on productivity, see how much work AI automates in programming and how AI is changing software development.

Copilot, Cursor and Claude Code

Copilot stands out for its integration with GitHub itself: issues, pull requests, review and Actions in one place. Cursor is a full editor with a built-in agent; see how to develop software with Cursor. Claude Code, by Anthropic, is an agent that runs in the terminal, in IDEs and on the web; see how Claude Code works. In the newsroom’s assessment, the choice depends more on where your team already works than on a difference in nature between the tools.

Key takeaways

• Copilot works in two places: in the editor, with suggestions, chat and a local agent, and on GitHub.com, with a cloud agent, review and automations.
• Instructions in the repository help, but the documentation admits they may not always be followed in the same way.
• The limits are declared by GitHub itself: incorrect or insecure code, incomplete reviews, code matching public code and a cloud agent restricted to one repository and 59 minutes per session.
• Studies show speed gains on well-defined tasks and significant rates of security flaws; tests and automated analysis remain indispensable.
• Plans, prices and credits change frequently. Check the official page before subscribing.