GitHub Copilot - Simply Explained

0:00 Most of us assume GitHub copilot writes code so we don't have to. That assumption misses what's actually happening inside. The copilot now finishes your lines, answers questions about your project in plain English, and can even make changes across your whole project on its own. But the part that trips up beginners isn't the technology, it's knowing which mode to reach for and when. Welcome to the M365 FM podcast, where we explore the people, ideas and technologies shaping the future of work. By the end of this, you'll know exactly what copilot is, how it works, and how to use it without getting burned. What copilot actually is start with the plain version, because the plain version is more accurate than the marketing. GitHub copilot is an AI assistant that lives inside the code editor, and the code editor is just the app where you write and save your code.

0:42 If you've ever opened Visual Studio Code, you've already seen the window it plugs into. Picture it less like a robot that replaces you, and more like a very fast junior teammate who has read a huge amount of code and is happy to guess what you want next. That teammate is genuinely useful. It is also sometimes wrong in a way that sounds completely confident. Under the hood. Copilot learned from a very large amount of publicly available code, which is why it can predict the shape of a function it has never actually seen. It isn't searching the web, and it isn't a chat website you visit in a browser. It's a prediction engine that sits right next to the work you're doing. GitHub builds copilot, and GitHub belongs to Microsoft, so it fits neatly into tools you may already use. It runs in the editor, in the terminal, on the desktop app, and on GitHub itself.

1:24 A small example makes this concrete. Say you're building a simple page and you need a form that collects a name and an email address. You type a comment describing what you want, and copilot offers the lines that build it. You read them. You keep the parts that make sense and you fix the parts that don't. The difference that matters for a beginner is simpler than that. Copilot isn't a search engine, and it's not a place you go to look up an answer someone else already wrote. It's a tool that writes alongside you in your file using the clues in front of it. That's why it feels personal. And it's also why it can be wrong in ways the search result never is. You don't have to be a software engineer for copilot to help you if you write formulas, queries, or scripts as part of your job, that's code two and copilot can help with it. None of this means you need to understand machine learning because you don't.

2:07 You just need to know what the tool is good at and what it isn't. Two assumptions fall apart right here. The first is that copilot writes whole applications for you while you watch, and it doesn't do that. It handles small, repetitive pieces and it speeds up someone who already understands what they're building. The second assumption is that it's only for senior developers, which isn't true either. A beginner gets real value from it, as long as they treat it as a helper to check, rather than an oracle to trust. A couple of words will keep coming up, so let's pin them down now. A repository is just a project folder that GitHub keeps track of, so every change gets recorded. A prompt is whatever you type to ask copilot for something, whether that's a full sentence or half a line of code. Neither word is scary once you've seen it used a single time. So the honest picture is this copilot is a fast assistant that predicts and explains code, and it turns into something genuinely useful the moment you learn how to ask it.

2:53 Well, everything from here is about that skill. Three ways to talk to it. Every single thing copilot does comes down to three jobs, and beginners tend to mix them up. Once you can tell the three apart, the tool stops feeling random and starts feeling like a set of buttons. You actually understand one of these three is the job beginners over use, and it's the one that can change the most at once. The first job is the one everybody pictures when they hear the word copilot as you type. It shows faint grey text ahead of your cursor, suggesting how to finish the line or the block, and you press a key to accept it or keep typing to ignore it. Programmers call this ghost text, and newer versions go a step further by suggesting your next edit, rather than only your next keystroke. Think of it as autocomplete that finished school.

3:34 This is the fastest of the three, and it's the one you'll lean on most once you already know roughly what you want to write. The nice part is that you stay in control. Every suggestion is just an offer, and nothing gets written until you accept it. A simple way to feel the difference is to picture who is driving. With completion. You drive and copilot suggests the turns. With chat, you ask for directions. With agent mode, you hand over the keys and check the route afterward. The second job is chat where you ask a question in plain English and copilot answers in plain English. Inside chat. There are two settings worth knowing. Ask mode explains and answers without touching a single file. So it's the safe choice for something like what does this function actually do? Or why is this failing? Edit mode changes the files you pointed at, which makes it the right choice when you already know what you want changed and just want it done.

4:18 A good beginner habit is to highlight a block of code, ask why it breaks on an empty input, and read the answer before you touch anything. Ask mode is where most people should start because it's read only. Read only means exactly what it sounds like since it can look at everything and change nothing. The third job is agent mode, and this is the one that surprises people. Instead of a question, you hand copilot a goal and it decides which files to open, makes the edits, runs commands to check its own work, and keeps going until the task is finished. Ask it to add logging to every part of a small project, and it will open the files, make the changes, and come back when it's done. There's a close cousin called the coding Agent where you assign a task on GitHub, and it works in the background and opens a pull request, which is simply a proposed set of changes waiting for your review.

5:01 So here's the practical rule, and it's worth remembering. Use completion when you're mid-thought and you want momentum, use ask when you want to understand something before you touch it. Use edit when you know the exact change you want. Reach for agent mode. When the job spans several files and you're comfortable reviewing a larger batch of changes afterward, the real tension is that Agent Mode feels the most impressive and is also the easiest to misuse, because it can change a lot at once. That's why so many beginners feel uneasy. After their first agent run, they handed over a vague goal and they got back a pile of edits they never fully read. You still have to review what it did the same way you'd review work from a new teammate. And one thing decides how well all three of these modes perform for you. None of them work particularly well if copilot can't see what you're actually working on, that's the next piece, and it changes how you use every one of these modes, how it knows about your code.

5:47 Copilot only knows what you show it. And this single idea explains almost every complaint people have about it. It builds its picture of your project from what's open and what sits near your cursor, which means the file you're editing the code around the line, you're on, the comments you've written, and the imports at the top of the file that pull in other pieces. So when you ask a vague question in an empty file, you get a vague and generic answer. Open the right file, put your cursor in the right place. And that very same question suddenly gets an answer that fits your project. Same tool, same words, and a completely different result. You might think it's about the cleverness of the tool, but it's actually about the context you hand it. You can point copilot more precisely whenever it needs a nudge by referencing a specific file, your whole project, the text you've selected, or the last command you ran in the terminal.

6:30 Think of these as ways of saying, look here. So it stops guessing and starts working from what you meant. A practical way to think about it is that context is your steering wheel. The tool has plenty of power, and the context decides which direction that power goes. It's worth being clear about what it can't do on its own. Copilot doesn't automatically read your entire project in the background, and it doesn't automatically know about every file you've ever written. It works with what's in front of it right now, plus whatever you deliberately pointed toward. That's why two people using the same tool on the same project can get very different results. Pointed at a single file by name and it answers about that file instead of guessing at the whole project. There are shortcuts here too, and they're worth a few minutes of your time. You can type a slash command to ask copilot to explain the code on your screen to fix it, or to write tests for it, instead of spelling out that whole request every time.

7:16 These are just pre-written prompts, so they save you words and they keep your request focused. The lesson underneath all of this is blunt, and it's the most useful thing in this whole episode. Copilot's output is only as good as the context. You feed it, give it nothing, and it fills the gap with something generic. Give it the right files and a clear ask and it can look like it. Read your mind what it costs. Now for the money. Because this is usually the point where a beginner stops and wonders whether any of it is worth it. The short answer is that you can start for free, and the paid plans start at ten dollars a month. Copilot free costs nothing and comes with limits attached. You get two thousand code completions a month and fifty chat requests a month, and a few of the more advanced chat skills in the editor simply aren't included. That's enough to get a real feel for how it works, and it isn't enough for someone who leans on it every day.

8:00 If you're just curious, it's the right place to begin. Two thousand completions sounds like plenty until you've had a productive afternoon. If you want more room, Copilot Pro runs ten dollars per user per month, and Copilot Pro Plus runs thirty nine dollars per user per month. Those higher tiers are built for people who want access to more models and higher limits, and most beginners won't need them on day one. A model in this context, is simply the engine behind the answers, and different engines are better at different jobs. The plans for companies work differently because an organization buys them per seat, rather than one person buying for themselves. Copilot business costs nineteen dollars per user per month and includes nineteen hundred AI credits per user, while Copilot Enterprise costs thirty nine dollars per user per month and includes one thousand nine hundred AI credits per user.

8:43 Those AI credits are simply a usage allowance that sits on top of the seat, so heavier users draw down more of it. One more difference matters here. When a company buys business or enterprise, an administrator decides which models and features people are allowed to use, and that same administrator can put guardrails around what the tool is allowed to see. When you buy for yourself, you make those calls on your own. Neither one is better because they're built for two different situations. So the free plan answers one question, which is whether this is for you. The paid plans answer a different one, which is whether you can rely on it every single day. Privacy. And who owns the code. This is the part that makes beginners hesitate, and it deserves a straight answer instead of a scary one. The rules depend on which plan you're on, so let's take them one at a time. On the personal plans, which are free pro and pro plus, your interactions can be used to improve the models and that happens by default.

9:28 The good news is that you can switch it off. There's an opt out sitting in your account settings, and if you're working with anything sensitive on a personal plan, you should go find it before you type another line. It's a setting most people never open, and it's the one worth changing. If you only remember one thing about privacy, make it that one. On the business plans, which are business and enterprise. The terms are tighter, prompts and suggestions aren't retained and aren't used to train models, and an administrator can exclude specific files or whole projects, so copilot never sees them at all. That last control is called content exclusion, and it exists for exactly the teams that can't risk code leaving the building. If you've ever worried about a client contract landing in the wrong place, that feature is the answer. Now for the thing everyone actually asks about, which is ownership.

10:09 GitHub's terms say you own the suggestions it generates, and GitHub doesn't claim your code as its own. That sounds like the end of the story, and it isn't quite. US guidance suggests that code generated by AI may not be protectable by copyright at all, so owning it and being able to stop someone else from using it turn out to be two separate things. None of this is meant to scare you off. It's meant to make sure you walk in with your eyes open. There's one more wrinkle worth knowing about. Copilot learned from an enormous amount of public code. So once in a while, a suggestion can resemble something that already exists somewhere else. GitHub handles this in two ways. A duplication filter can block a suggestion that looks too close to public code, and a feature called code referencing shows you when a match happens, so you can check the license before you rely on it.

10:50 The plain English rule for a beginner is short Don't paste passwords, keys, or client code you're not allowed to share into a personal plan and treat anything. Copilot writes as something to review rather than something to trust. Mistakes beginners make. Knowing the risks is half the job and the other half is building the habits that keep you out of trouble. These are the mistakes that catch almost everyone at the start. The biggest one is trusting a suggestion without reading it. Copilot can be confidently wrong, and GitHub's own guidance says to validate what it gives you. That isn't a reason to avoid the tool, and it's a reason to stay in the habit of reading every line before you keep it. A suggestion that runs without errors can still be doing the wrong thing. The next mistake is pasting secrets into a personal plan. API keys, passwords, and private client code don't belong in a free or personal account, because that data can be used to improve the models unless you've opted out.

11:36 Once a key has left your machine, changing that key is the only real fix. A third mistake is reaching for agent mode. When a simple question would have done the job, people handed a big goal, watch a, change a dozen files, and then feel completely out of their depth. Start with ask or completion until you trust the tool and grow into Agent mode. Once you understand what it actually does. Then there's the vague prompt followed by the unfair conclusion that copilot is useless. A giant request gets a generic answer, while several small and specific requests get you something you can actually use. That's true whether you're asking for code or asking for an explanation. And the deepest mistake of all is treating copilot as a replacement for understanding. It speeds up people who can read what it produces, and it exposes people who can't. The tool raises your ceiling and it doesn't remove the floor.

12:17 Every one of these mistakes has the same fix, and the fix is patience. Read before you accept. Keep your secrets out and start small. None of that is complicated and all of it takes a little discipline. Copilot is a helper inside your editor with three modes completion for momentum, chat for questions and edits, and agent mode for bigger jobs. It works from the context you give it. It's free to try and on personal plans, your data may be used unless you opt out. Which part of your own work would you hand to copilot first and which part would you never let it touch? Tell me in the comments, because that line decides whether a tool like this helps you or gets you into trouble.