AI Coding Assistants

When I was learning web development, the most a code editor could do for you was suggest a method name after you typed a dot, and it remained that way for most of my professional life. Today, AI tools can write entire functions from a comment, explain unfamiliar code in plain English, refactor across multiple files, and even plan and execute multi-step development tasks on their own. That change happened fast, and the tools are still changing quickly.

In this chapter, we will use GitHub Copilot to experience this new world of AI-assisted development. Copilot was the first tool to bring AI into the mainstream of software development, and it remains one of the most widely used. It launched as a VS Code extension in technical preview in June 2021. It suggested entire functions and blocks of code based on your current file, comments, and function signatures, which no editor plugin had done before.

Using it felt a bit like pair programming with someone who had read a lot of code. You would write a comment like // sort users by last login date and Copilot would generate the function. You would start typing a function name and it would fill in the body. Sometimes the suggestions were exactly right. Sometimes they were close enough that editing them was faster than writing from scratch. Other times they were way off, and you would ignore them entirely.

After a year-long beta, Copilot became generally available in June 2022 as a paid subscription ($10/month for individuals). By that point it was already writing a significant share of code for millions of developers. GitHub later reported that Copilot users accepted roughly 30% of its suggestions. That number is a rough measure at best, but it does tell us the tool was being used heavily.

A few months later, in November 2022, ChatGPT took a different approach. Copilot put AI in your editor, and ChatGPT put AI in a chat window. You could paste a stack trace, describe a bug in plain English, and ask follow-up questions, so you were having a conversation about your code rather than reading suggestions as you typed. That changed what developers expected from AI tools, from generating the next few lines to explaining, debugging, refactoring, and offering a second opinion. Most editor-based assistants have been catching up to that conversational mode ever since, Copilot included, and the Chat view we will spend most of this chapter using grew directly out of that shift.

AI Coding Tools Today

Today, Copilot does much more than just inline suggestions, and there are now many AI coding assistants on the market — from AI-first IDEs like Cursor to CLI agents like Claude Code. They fall into a few broad categories based on how you interact with them and how much autonomy they have:

More control                                          More autonomy
    |                                                      |
    v                                                      v

 Inline          Conversational      AI-first        Agentic
 autocomplete    assistants          IDEs/plugins    tools
 (you write,     (you ask,           (you describe,  (you set a goal,
  AI suggests)    AI explains)        AI edits)       AI executes)

Autocomplete gives you the least autonomy. You use it for routine coding where you know what you want and the AI just saves you keystrokes. It is fast, low-risk, and you never lose control.

Conversational assistants give you more autonomy. You turn to this when you need to think through a problem: understanding an error, exploring an unfamiliar API, or getting a second opinion on an approach.

AI-first IDEs give you still more autonomy. When you know what change you want but it is tedious to do by hand, you describe it and let the AI generate the diff. Refactoring, renaming across files, restructuring code.

Agentic tools give you the most autonomy. When a task is well-defined but involves many steps across many files, you hand it to an agent and review the output. Dependency upgrades, test generation, boilerplate-heavy feature scaffolding.

Copilot in 2026 covers all four categories — inline completions, a conversational chat view, an edit mode for multi-file changes, and an agent mode for autonomous multi-step work — all inside one VS Code extension. That is why we will use it here: one tool lets you experience each level of autonomy, and it happens to be free for you as a student.

Context Engineering

Early on, the focus was on prompt engineering — wording your request precisely so the model would generate what you wanted. That still matters, but it turned out not to be the main factor. What matters more is what the model can actually see when it tries to answer. If you word a prompt carefully but the AI does not have the relevant code in its context, you will get a guess that sounds confident and is often wrong. If you word the prompt plainly but attach the right files and set the right scope, you will often get something close to correct on the first try.

People started calling this context engineering — making sure the AI has the right files, the right rules, the right scope, and not too much else, before it starts answering. Most of the prompting habits we will practice in this chapter are really context habits: attaching specific files to a question, starting a fresh chat when the topic shifts, telling Copilot what you already know so it can skip past it. The wording matters, but what is in the prompt’s context matters more.

Learning to Use These Tools Well

Installing Copilot is easy. Using it well is harder. These tools are assistive, not authoritative. They generate plausible-looking code that is sometimes right, sometimes subtly wrong, and sometimes completely fabricated. Knowing where to trust them, where to verify, and where to write the code yourself is a skill you have to learn, and it is easier to learn it now than to unlearn bad habits later.

Over the rest of this chapter we will use Copilot on a real codebase (the Wordle starter from the previous section) so that you get practice at it. But first, we need to claim our tier and install the tool.