
GitHub Copilot has an interface most people never use properly. Context-aware code suggestions are the headline, but code comments to implementation is the feature that changes your habits. You write what you want in plain language above a stub, and it fills the body. That is a different relationship with the tool from autocomplete, and it is where most of the value sits.
The rest of the package follows from GitHub: repo understanding, editor integrations, and the fact that your code is probably already there. Improvements keep arriving — better multi-line completions, improved test generation, more language support, new team collaboration tools. So output quality is a moving target rather than a fixed number.
This guide covers the comment habit, what the free access is actually for, and the two failure modes that matter: overconfidence and secrets.
Write the comment, then judge the code
Using a comment to guide Copilot is the highest-leverage habit available. The pattern is mechanical: write a comment that states what the next thing should do in one line, add a function signature, and let the body arrive.
The example prompts are good models of the shape. Write a function to parse JSON safely in JavaScript. Generate a unit test for this Python function. Refactor this loop into a cleaner Python comprehension. Each names an artefact, a language and a constraint. None of them says "improve my code".
Refactoring is the underrated one. Refactoring code is a core use case, and a refactor request is ideal for the comment interface because you already know exactly what the output should look like. Which means you can check the suggestion in seconds instead of auditing it. Learning APIs is another good fit, for the same reason: the correct answer is knowable, so a wrong answer is obvious.
Repo understanding is the part you cannot fake
GitHub repo understanding is what separates this from a generic code completion box, and deep repo integration is the strength that leads the list. Asking what a function does, where a type lives, or how a pattern is used elsewhere in the same repository only works if the tool has seen the repository.
Which gives you a maintenance obligation: keeping your repo context clean is the ongoing work. Dead files, generated artefacts and abandoned experiments all become context, and context is what degrades a suggestion. Before blaming the tool for a bad answer, check whether the answer is a fair reading of a repository you have tidied lately.
Adding tests is a core use case, and improved test generation is a recent improvement. Tests also happen to be the most reliable output to trust, because a test either passes or it does not — you do not have to reason about whether it is correct, only run it.
Where the free access is genuinely generous
Copilot has a real $0 Free plan, not a student-only courtesy. It caps chat and agent usage and still includes the CLI and agent mode. Pro is $10 a month, Pro+ $39 and Max $100, all metered through GitHub AI Credits. Many users do need a subscription, which is the first real drawback, but for daily professional work it is close to a rounding error against the time saved.
The free path is nonetheless unusually generous for the two groups that get it. A student gets a professional-grade assistant for no cost, which is a large deal while learning. A maintainer gets it on the repositories that are their actual job. If you are either, check eligibility before deciding it is not worth installing.
Two practical notes. You need a GitHub sign-in, so there is no anonymous evaluation. And the editor list is specific — VS Code, Visual Studio, JetBrains IDEs and Neovim — so if your editor is not on it, the tool is not available to you regardless of subscription.
The failure mode is confidence, not incompetence
Sometimes overconfident answers is a real con, and it deserves more attention than it usually gets. The suggestion is not obviously wrong. It is fluent, idiomatic, and confidently handles a case the author did not consider. And that is harder to catch than an obvious mistake, because obvious mistakes get read and confident ones get accepted.
Three habits are the countermeasure, and they work as a set. Verify all generated code. Use comments to guide it, which keeps you the author of the intent rather than the reviewer of a stranger's idea. And keep your repo context clean, so the confidence is at least confident about the right thing.
Two habits close the loop. Ignore style and lint rules at your own peril — a suggestion that is correct but formatted against your conventions will be caught by a linter far more reliably than by your eyes. And production code without review is a case not to use it for, so decide the review boundary before the first commit rather than during an incident.
Secrets are the one mistake that is not about quality
Inserting secrets in prompts is a mistake, and handling secrets in prompts is a case not to use it for. Everything else in this guide is about efficiency; this one is about not creating an incident. Sensitive proprietary code without a policy is the third item on the not-for list, and the three together are the entire security conversation.
The practical version: if a file contains a key, a token, a customer name, or anything under an NDA, treat it as a file where assistance is switched off. Disabling it in sensitive files if needed is the sensible move, and it is far easier to configure once at the start than to reconstruct what left the building afterwards.
It can also suggest insecure code, which is a real con, and the mitigation is not a setting — it is the same review discipline as everything else, applied with more attention. An authentication helper, an input sanitiser or a query builder is exactly where a fluent suggestion is most likely to be subtly wrong, and exactly where being subtly wrong costs the most.
Copilot, or something else
| Dimension | Where Copilot is strong | Where it stops |
|---|---|---|
| Repository context | GitHub repo understanding and deep repo integration | Only as good as the repository is maintained |
| Intent | Code comments to implementation | — |
| Refactoring | Refactoring code is a core use case | — |
| Tests | Adding tests is a core use case; improved test generation is recent | — |
| Learning an API | Learning APIs is a core use case | — |
| Access | Free $0 plan, capped chat and agent usage; CLI and agent mode included | GitHub sign-in needed |
| Editors | VS Code, Visual Studio, JetBrains IDEs, Neovim | Anything outside that list |
| Correctness | Recent work on multi-line completions | Can suggest insecure code; sometimes overconfident answers |
| Secrets and confidential code | — | A case not to use it for without a policy |
| Offline work | — | A case not to use it for |
| Cross-editor flexibility | — | If you live in Vim, Neovim, Emacs or dozens of others, an editor-agnostic assistant with unlimited suggestions fits your setup better |
| Getting a runnable app to show someone | Wrong tool | A cloud IDE with instant hosting solves that, Copilot does not |
Verdict
Who it suits: developers whose code already lives on GitHub, who write intent in comments, and who verify before they commit.
Who it does not suit: anyone in an unsupported editor, working offline, or putting secrets anywhere near a prompt.
Frequently Asked Questions
I am neither a student nor a maintainer — is a subscription worth it?
That is a judgement only you can make, but the structure helps. Free access is for verified students and open source maintainers, and everyone else needs a paid subscription, and many users do need one. If you fall into either free group, check eligibility before concluding it is not worth installing. You need a GitHub sign-in either way, so there is no anonymous way to try it.
Should I write a guiding comment, or just accept the completion?
Write the comment. Code comments to implementation is a core feature and using a comment to guide Copilot is how you get the most from it. So state in one line what the next thing should do, add the function signature, and let the body arrive. The example prompts each name an artefact, a language and a constraint rather than asking for an improvement.
Refactoring requests and test generation are the best fits, because you already know what the right answer looks like.
The suggestion looked fluent and I took it. What am I exposed to?
Mainly to not having read it carefully enough. Copying outputs without review and trusting every suggestion are the same mistake twice. And the two specific risks are that it can suggest insecure code and that it can be overconfident rather than obviously wrong. Verify all generated code before you commit, and let your linter catch style and lint violations your eyes will miss.
Which files should never come near a prompt?
Anything holding a key, a token, a customer name, or material under an NDA. Inserting secrets in prompts is a mistake, and both handling secrets in prompts and sensitive proprietary code without a policy are cases not to use it for. Disabling it in sensitive files if needed is the sensible move, and far easier to configure once at the start than to reconstruct afterwards.