GitHub Copilot

1. Code completion and Next Edit
   Code completion is Copilot’s oldest and most stable feature. As you type, it can complete the next line or suggest several lines at once. It’s especially useful for repetitive work like React components, API calls, and test boilerplate.
   Next Edit goes a step further. Instead of only guessing what you’ll type next, it also predicts which part of the code you’re likely to edit next. It’s not a flashy feature, but over time it feels much closer to how real development actually works.
2. Copilot Chat
   Chat is now basically a standard part of Copilot. You can ask about code logic, error causes, generate tests, or get debugging help directly from the IDE sidebar. It can reference files and project context, so you don’t have to manually paste large blocks of code every time.
   Personally, I use it less for “write me a function” and more for questions like “Why is this module designed this way?” or “Where is this error actually coming from?” In practice, those use cases are often more useful than having AI write code directly.
3. Agent mode
   Agent mode is a much bigger shift. You don’t have to tell it every step. You can simply give it a goal, such as:
   “Make this API asynchronous and update every place that calls it.”
   Copilot can then find the relevant files, make changes, run commands, and continue working through the follow-up issues.
   None of these tasks is especially difficult to do manually, but they’re fragmented. The real value of Agent mode is removing the mechanical work of searching, jumping between files, and making repetitive changes.
4. Background coding agent
   This is probably one of Copilot’s most distinctive features now.
   You can assign it a GitHub Issue and close your computer. It can keep working in the background: reading the code, creating a branch, making changes, running tests, and eventually opening a Pull Request.
   I tried this once by handing it a small bug before leaving work. By the next morning, there was already a PR waiting. The changes weren’t amazing, but the scope was fairly controlled and it had added tests as well.
   That experience of “it keeps working while I’m offline” is genuinely convenient.
5. Code Review
   Copilot can now participate directly in PR reviews.
   It leaves comments on specific lines and catches common issues such as unused variables, null references, or inconsistent error handling.
   I wouldn’t treat it as the final reviewer, but it works well as a first-pass filter. On a large PR, letting it scan everything once can save some mental effort.
6. Semantic code search
   This is particularly useful in older codebases.
   You don’t need to remember exact function names or rely only on keywords. You can ask things like:
   “Where is login failure handled?”
   “Which module handles payment timeouts?”
   Copilot can search the code based on meaning rather than exact text.
   When you’re taking over an unfamiliar project, that can save a lot of time compared with traditional search.

I used Copilot continuously for three weeks on a medium-sized full-stack project.

The most reliable part was still code completion.

No real surprise there.

When writing components, APIs, or test boilerplate, it was almost always working quietly in the background. You don’t need to open a special panel—the suggestions just appear as you type.

The part I liked most was that it doesn’t interrupt your flow.

A lot of AI tools make you stop what you’re doing and start a conversation.

Copilot’s completion doesn’t work like that.

You keep typing, it keeps predicting. If the suggestion looks right, press Tab. If not, ignore it.

Microsoft has published a 61% acceptance rate for Java developers using code completion. My own experience felt fairly close to that—its suggestions are often usable as-is.

The background coding agent is a different kind of experience.

I didn’t expect much from it at first.

Then one evening, just before leaving work, I assigned it a bug-fix Issue. When I came back the next morning, there was already a PR waiting.

I reviewed the diff.

The changes weren’t particularly sophisticated, but it stayed within scope, didn’t touch unrelated files, and added tests.

I only made a few small adjustments before merging it.

That feels very different from a local agent.

With a local agent, you still tend to watch what it’s doing.

A background agent feels more like you’ve genuinely handed off a piece of work.

What distracts me most about Copilot now, though, isn’t code quality.

It’s Credits.

Pro includes a fixed amount of AI Credits each month.

One morning, I ran a moderately complex refactoring task for several hours and watched the balance drop much faster than I expected.

I rarely used to think about Copilot usage.

Now I do.

That’s a noticeable shift.

Once an Agent starts repeatedly reading context, calling tools, and using more expensive models, Credits can disappear quickly.

After a while, you start asking yourself:

“Is this task really worth running through an Agent?”

I don’t particularly like having to think that way, but right now, that trade-off is real.

Pros

Code completion is still extremely smooth.
This remains Copilot’s strongest foundation. It stays out of the way and rarely forces you to switch context.

The GitHub ecosystem advantage is substantial.
Issues, PRs, and Actions already live on the same platform, so background agents and code review fit naturally into the workflow.

Model choice is flexible.
You can switch between GPT, Claude, Gemini, and others without replacing your entire toolchain just to access a different model.

Broad IDE support.
It works across VS Code, JetBrains, Neovim, Xcode, Eclipse, and more, which makes team adoption easier.

The free tier is genuinely usable.
If you only want to try code completion and basic Chat, you don’t necessarily need to pay upfront.

Cons

Credit usage is hard to predict.
Normal completion is fine, but Agent workflows and premium models can burn through Credits quickly.

The Agent still isn’t at the very top tier.
For complex multi-file tasks, it can feel less autonomous than Claude Code or Cursor.

Heavy features increasingly feel metered.
Agents, Opus, background coding agents, and similar features all consume Credits, so heavy users end up watching the balance more closely.

The value drops outside the GitHub ecosystem.
If your team mainly uses GitLab, Bitbucket, or self-hosted Git, you lose much of what makes Copilot especially compelling.

Who it’s good for

Developers and teams deeply invested in GitHub

If your Issues, PRs, and Actions already live on GitHub, Copilot can slot directly into the existing workflow.

Teams with mixed IDE preferences

Some people can use VS Code, others JetBrains or Neovim, without making Copilot harder to adopt.

People on a budget who want to try AI coding

The free tier makes it easy to experiment before deciding whether to upgrade.

Developers who mainly use completion and Chat

If you’re not running Agents heavily every day, Pro is often enough.

Who it’s not ideal for

People running lots of complex Agent tasks every day

In that usage pattern, Credits can disappear quickly and costs become much less predictable.

People who prioritize maximum Agent autonomy

If your goal is to let an Agent handle long, complex refactors with minimal supervision, Claude Code or Cursor may be a better fit.

Teams outside the GitHub ecosystem

Without GitHub-specific integrations, Copilot becomes much more like a standard AI coding tool.

By 2026, Copilot is no longer just the “code completion plugin” it started out as.

Code completion is still its most reliable feature, and the GitHub ecosystem remains a major advantage that’s hard to replicate.

What really changed the experience is Agent mode and background agents.

Before, using AI usually meant staying in the editor and interacting with it continuously.

Now, some tasks can simply be handed off, and you can come back later to review the result.

That’s genuinely convenient.

But it also introduces a new problem:

the more you rely on Agents, the more you have to pay attention to Credits.

If you mainly use completion and Chat, Copilot Pro is still very good value.

If you run complex Agent tasks every day, though, you can’t judge the cost by the monthly subscription alone.

You also need to factor in actual usage.

At this point, I prefer to think of Copilot as a set of development resources rather than a fixed-price software product.

Use it lightly, and it’s inexpensive.

Use it heavily, and the cost rises noticeably.