AI Coding: VS Code, Copilot Chat, LLMs

Table of Contents

The Ultimate Guide to Your AI Coding Assistant: VS Code, Copilot Chat, and LLMs

John: Welcome, everyone. Today, we’re diving deep into a trio of technologies that is fundamentally reshaping the software development landscape: Visual Studio Code, GitHub Copilot Chat, and the powerful Large Language Models (LLMs) that fuel them. It’s no exaggeration to say that mastering this combination is quickly becoming as essential as knowing a programming language itself. It’s the new power suit for the modern developer.

Lila: That’s a bold statement, John! When I hear all those names strung together, it sounds a bit intimidating for a newcomer. Is this one giant, complex product, or are they separate pieces we need to assemble? I think a lot of our readers, especially those just starting out, might wonder where to even begin.

John: That’s an excellent question, Lila, and it gets to the heart of understanding this ecosystem. It’s best to think of them as three distinct, synergistic layers. At the base, you have Visual Studio Code (VS Code), which is the environment—the workshop, if you will. It’s a free, incredibly popular code editor from Microsoft where you write your code. The second layer is GitHub Copilot Chat. Think of this as your expert AI-powered assistant who lives in your workshop. It’s an extension you install into VS Code. The final, and perhaps most magical, layer is the Large Language Model (LLM). This is the brain of your assistant. It’s a massive, pre-trained neural network, like OpenAI’s GPT-4, that understands and generates human-like text and code. So, in short: VS Code is the car, Copilot Chat is the advanced AI driver-assist system, and the LLM is the engine powering that system.

Lila: I love that analogy! The car, the driver-assist, and the engine. It makes it so much clearer how they relate. So, the magic really happens when all three are working in concert. You’re not just writing code in an editor; you’re having a conversation with an AI that understands your project, right inside that editor.

How to Get and Set Up Your AI Assistant

John: Precisely. Now, let’s talk about getting this set up. The first step is the easiest: download and install Visual Studio Code from its official website. It’s free and runs on Windows, macOS, and Linux. This gives you the workshop.

Lila: Okay, workshop acquired. Now, how do we hire the AI assistant, Copilot Chat? You mentioned it’s an extension. Does it cost anything?

John: It does. GitHub Copilot is a subscription service. You’ll need a GitHub account, and then you can subscribe to either the “Copilot Individual” or “Copilot Business” plan. They typically offer a free trial, which is a great way to test the waters. It’s also often free for verified students and maintainers of popular open-source projects, which is a fantastic initiative. Once you’re subscribed, you go to the Extensions Marketplace within VS Code, search for “GitHub Copilot Chat,” and click install. After a quick login to your GitHub account, the assistant is ready to work.

Lila: That brings up the third piece: the engine, or the LLM. When I subscribe to Copilot, am I just getting one specific model, like GPT-4? Or do I have a choice? I’ve been hearing a lot about different models having different strengths.

John: You’re touching on one of the most exciting recent developments. Historically, Copilot used a specific, fine-tuned model from OpenAI. But the platform is becoming much more open. While your subscription still gives you default access to GitHub’s state-of-the-art models, recent updates to VS Code have introduced robust model selection capabilities. This means you can tell Copilot which brain you want it to use for a particular task.

Lila: Wow, so you could use a super-powerful model for a complex logic problem, but maybe a faster, lighter model for simple boilerplate code? What about privacy? Can you use models that don’t send your code to the cloud?

John: Exactly right. And your privacy question is key. This new flexibility allows you to configure VS Code to talk to different LLM “endpoints” (the address where the model can be accessed). This includes:

GitHub’s hosted models: The default, powerful options like GPT-4o and the new GPT-4.1.
Other cloud models: You could potentially connect to models from providers like Anthropic (Claude) or Google (Gemini) if you have API access.
Local models: This is the big one for privacy and customization. You can run an open-source LLM, like a model from the Llama or Mistral families, directly on your own machine. Copilot can then be configured to talk to this local model, meaning your code and prompts never leave your computer. It’s a game-changer for developers working with sensitive intellectual property.

The Technical Mechanism: How It All Works

John: Understanding the technical flow is key to using this tool effectively. At its core, Copilot Chat is a master of context. When you ask it a question, it doesn’t just send your words to the LLM in a vacuum. It intelligently gathers relevant information from your workspace to give the LLM the best possible chance of providing a useful answer.

Lila: When you say “context,” what does that actually include? Is it just the code in the file I currently have open?

John: It’s much more sophisticated than that, and this is where a lot of the magic lies. The context can include:

The code you have currently selected.
The contents of your active editor file.
Code from other open tabs.
File names and project structure.
Terminal output.
Even your recent chat history to understand follow-up questions.

But the real power comes from how you can *manually guide* the context.

Lila: Manually guide it? How do you do that? Do you just paste a bunch of code into the chat box?

John: You could, but there’s a much more elegant way. Copilot Chat uses what are called “context variables” or #-mentions (hash-mentions). For example, you can type:

#file: to reference one or more specific files in your workspace, even if they aren’t open.
#selection: to explicitly refer to the code you have highlighted.
#symbol: to reference a specific function or class definition.
#terminal: to include the output of the last terminal command.

So you could ask, “Based on the interfaces in #file:api/types.ts, can you refactor the function at #symbol:processUserData to be more efficient?” This level of precision is incredibly powerful.

Lila: That makes so much sense. You’re not just talking to the AI; you’re giving it a precise reading list. You also mentioned something called the ‘MCP’ in our prep. It sounds like an important piece of this puzzle.

John: It is. MCP stands for Model Context Protocol. It’s a new standard that Microsoft is finalizing. Think of it as a universal language for packaging and sending context to an LLM. Before MCP, connecting a new model to VS Code could be a messy, custom-built process. MCP standardizes it. It defines exactly how the editor should bundle up all that rich context—the files, symbols, selections—and present it to any model that also “speaks” MCP. This protocol is the foundation that will allow for a flourishing ecosystem of AI agents and tools that can seamlessly plug into VS Code, regardless of who made them.

The Team and the Community: Corporate Power Meets Open Source

John: The primary driving forces behind this technology stack are, of course, Microsoft, the creator of VS Code, and its subsidiary, GitHub, the home of Copilot. This provides an immense amount of resources, funding, and engineering talent. It’s a top-down, corporate-led initiative to integrate AI deeply into the developer workflow.

Lila: That seems straightforward enough. But I’ve heard VS Code and other parts of this described as “open source.” How does that square with a massive corporate project? It feels like a contradiction.

John: It’s a fascinating and modern hybrid model. While Microsoft and GitHub steer the ship, they’ve been making significant moves towards openness. VS Code itself is built on an open-source project (`Code – OSS`). But the really big news, which we’ll touch on later, is that in mid-2025, Microsoft open-sourced the GitHub Copilot Chat extension itself.

Lila: Wow, they open-sourced the AI assistant’s code? Why would they do that? What does it mean for a regular developer like me?

John: It’s a strategic move with huge implications. It does two main things. First, it builds trust and transparency. Developers were using this powerful AI tool, but it was a “black box.” Now, anyone can go to the GitHub repository, read the source code, and understand exactly how it works. They can see the system prompts used to instruct the AI, the logic for gathering context, and even the telemetry it collects. Second, it invites community contribution. If you have an idea for a new feature or see a bug, you can contribute a fix directly. This allows the tool to evolve much faster and in ways the core team might not have imagined. It’s turning a product into a platform.

Lila: So the community is shifting from being just users to active participants and co-creators. It’s a way of blending the stability of corporate backing with the innovation and transparency of the open-source world. That’s a very powerful combination.

Use-Cases and the Future Outlook

John: Let’s ground this in reality. What can you actually *do* with it day-to-day? The use-cases are vast and growing. We can start with the simple and move to the complex:

Boilerplate and Code Generation: Asking it to “create a React component with a form for user login” or “write a Python function to read a CSV file and return a list of dictionaries.” This saves immense amounts of time.
Code Explanation: This is a superpower for learning. Highlight a complex block of legacy code and ask `/explain`. Copilot will break it down into plain English.
Debugging and Error Fixing: You can paste an error message into the chat and ask, “Why am I getting this error?” Copilot can often spot the mistake, whether it’s a simple typo or a complex logical flaw.
Refactoring Code: You can ask it to “take this long, messy function and refactor it into smaller, single-responsibility functions” or “convert this code from using Promises to async/await.”
Writing Tests: This is often a tedious task for developers. You can point Copilot at a function and say, “Write a set of comprehensive unit tests for this using the Jest framework.”
Learning and Exploration: You can use it as an interactive tutor. “What is the difference between `let`, `const`, and `var` in JavaScript? Show me an example from #file:main.js.”

Lila: Those are all fantastic for developers. But what about the wider team? Could a project manager or a designer get any value from this?

John: Absolutely. It’s a powerful tool for bridging communication gaps between technical and non-technical team members. A project manager could highlight a section of code and ask, “In simple terms, what is the business logic being implemented here?” It can translate code into documentation and requirements, making the codebase more accessible to everyone.

Lila: Looking ahead, where does this go? Is the end goal just a smarter autocomplete?

John: Not at all. The future outlook is centered on the concept of AI agents. Right now, Copilot is mostly a reactive assistant—you ask, it answers. The next step is a proactive agent that can handle complex, multi-step tasks. The vision is to be able to give it a high-level goal, like “add a new user profile page to the application,” and the agent would be able to perform the entire workflow: identify the necessary files to change, write the backend API endpoint, create the frontend UI components, add the necessary tests, and then present you with a pull request for review. The Model Context Protocol (MCP) we discussed is the bedrock that will enable these sophisticated agentic workflows.

Lila: So it’s evolving from a “pair programmer” you can talk to, into a junior developer you can delegate tasks to. That’s a monumental leap.

How It Stacks Up: Competitor Comparison

John: While the VS Code and Copilot combination is a dominant force, it’s certainly not the only player in the game. The landscape is rich with alternatives, each with its own philosophy.

JetBrains AI Assistant: This is the most direct competitor. It’s deeply integrated into the JetBrains family of IDEs (Integrated Development Environments) like IntelliJ IDEA for Java, PyCharm for Python, and WebStorm for web development. Its key strength is its seamless integration into the already powerful refactoring and code-analysis tools of the JetBrains ecosystem.
Cursor: This is a very interesting one. Cursor is an “AI-first” code editor that is actually a “fork” (a modified version) of VS Code itself. It was built from the ground up with AI at its core, offering features like an AI-powered project-wide search and edit capability that can feel more “magical” than Copilot at times.
Amazon CodeWhisperer: This is Amazon’s offering, and its main selling point is its deep integration with the Amazon Web Services (AWS) ecosystem. It can provide suggestions that are specifically optimized for using AWS APIs and services.
Open-Source & BYOM (Bring Your Own Model) Tools: There are tools like Continue and Tabby that are built specifically to let you connect any LLM, especially local and open-source ones, to your editor. They are for developers who want maximum control and privacy.

Lila: With all those options, what makes the VS Code/Copilot pairing the one so many people are talking about?

John: It comes down to a few key advantages. First, ubiquity and ecosystem. VS Code is the world’s most popular code editor. Its vast user base and enormous extension marketplace create a network effect that’s hard to beat. Second, flexibility and openness. As we’ve discussed, with the open-sourcing of the chat extension and the standardization of MCP, Microsoft is building a platform, not just a product. It’s becoming the most adaptable and extensible environment for AI development. It may not always be the single most polished tool for one specific task out of the box, but its potential for customization is unparalleled.

Risks, Cautions, and Responsibilities

John: This power is not without its pitfalls. It’s crucial for every developer to use these tools with a healthy dose of critical thinking. The first and foremost risk is code quality and security. The LLM can and will generate code that is buggy, inefficient, or contains security vulnerabilities. It’s a suggestion, not a perfect solution. You, the developer, are always the final authority and are responsible for the code you commit.

Lila: That’s the ‘trust but verify’ principle. It’s like having a brilliant but occasionally very overconfident junior partner. You have to review their work carefully. What about privacy?

John: Data privacy is a huge concern, especially for corporations. When you use the default cloud-based models, your prompts and code snippets are sent to Microsoft’s servers for processing. While their policies state this data isn’t used to train their public models and is deleted after a short period, this is a non-starter for companies with highly sensitive code. This is precisely why the ability to use locally-hosted LLMs is such a critical feature.

Lila: I’ve also heard people worry about the impact on learning. If the AI can write the code for you, will new developers ever learn the fundamentals properly? The “deskilling” argument.

John: It’s a very valid and hotly debated topic. There’s a real risk of becoming a “prompt monkey” who can’t actually code without the AI’s help. The key is discipline. The tool must be used to augment learning, not replace it. Use it to explain concepts you don’t understand (`/explain`), to show you a better way to do something, and to handle tedious boilerplate. But if you’re just using it to bypass the act of thinking and problem-solving, you’re doing yourself a great disservice in the long run.

Lila: One last thing: I remember some early controversy about the AI spitting out code that looked like it was copied from a public repository. Is that still a risk?

John: That’s the issue of license contamination and code attribution. The models are trained on billions of lines of code from public GitHub repositories, which have all sorts of different open-source licenses. There’s a small chance the model could reproduce a chunk of code that is substantial enough to be subject to a restrictive license, potentially creating legal problems for your commercial project. GitHub has implemented filters and features to detect and cite such code, but the ultimate responsibility lies with the developer to ensure their project complies with all licensing requirements.

Expert Opinions and Analysis

John: The reaction from the developer community has been fascinating to watch. It’s a spectrum. On one end, you have a large contingent of senior developers and architects who herald it as the most significant productivity leap since the advent of the modern IDE. They see it as a tool that eliminates drudgery, allowing them to focus their brainpower on higher-level architectural design and complex problem-solving, which is where their true value lies.

Lila: But it can’t be all sunshine and roses. What are the dissenting voices saying? I’ve seen some grumbling online about “AI bloat.”

John: You have. The skeptics and critics raise important points. Some worry about the over-reliance we just discussed. Others are concerned that the craft of software engineering is being replaced by the less-rigorous skill of “prompt engineering.” And the “AI bloat” argument is a real one. Some developers feel that VS Code, once a lightweight and snappy editor, is becoming weighed down by these deeply integrated, resource-intensive AI features. They argue that these tools should remain optional plugins, not a core part of the experience.

Lila: So, the verdict is still out? Or is there a consensus forming?

John: The consensus is that this technology is transformative and here to stay. The debate is no longer *if* we should use AI in development, but *how*. The industry is currently in a dynamic phase of establishing best practices, navigating the ethical and practical challenges, and figuring out how to integrate these powerful tools into our workflows in a way that is responsible, sustainable, and truly productive.

Latest News and Roadmap (as of July 2025)

John: The pace of innovation here is staggering, and the last month has been particularly eventful, primarily due to the Visual Studio Code 1.102 release, also known as the June 2025 update.

Lila: Let’s break that down. What were the headline features of that release?

John: There were several major announcements that align perfectly with the themes we’ve been discussing.

The GitHub Copilot Chat Extension is Now Open Source: As we mentioned, this is huge. Microsoft released the full source code for the extension under the permissive MIT license. Developers can now inspect, contribute to, and build upon the official Copilot Chat client. This is a massive step towards making VS Code a truly open AI editor.
Model Context Protocol (MCP) is Generally Available: The MCP standard is no longer experimental. It’s a stable, first-class citizen in VS Code. This solidifies the foundation for a future where many different AI agents and tools can plug into the editor seamlessly.
Enhanced Model Selection and Customization: The update brought a more refined UI for choosing which LLM you want to use. You can now more easily assign specific models to specific “chat modes” (pre-configured personalities for the chat, like a “code reviewer” or a “documentation writer”).
Chat Interaction Improvements: They added a number of quality-of-life features, like the ability to easily edit and resubmit a previous chat prompt, and a way to have the AI generate terminal commands that you can approve with a single click, streamlining DevOps workflows.

Lila: It really sounds like the roadmap is doubling down on openness, flexibility, and user control. They’re not trying to give you a single magic box, but rather a powerful, configurable workbench.

John: That’s the perfect summary. The strategy is clear: make VS Code the most versatile and transparent platform for building with and alongside AI. The future isn’t about one AI to rule them all; it’s about giving developers the tools to choose and orchestrate a whole suite of specialized AI assistants.

Frequently Asked Questions (FAQ)

Lila: This has been incredibly thorough, John. Let’s wrap up with a quick FAQ section to tackle some of the most common questions our readers might still have. I’ll fire away. First: Is GitHub Copilot free?

John: For most users, no. It’s a subscription service. GitHub Copilot Individual has a monthly or yearly fee. However, it is provided for free to verified students, teachers, and maintainers of popular open-source projects. Most plans also come with a free trial period.

Lila: Next question: Does Copilot Chat send my entire private project to Microsoft?

John: No, it does not upload your entire codebase. It works by sending relevant context—which includes snippets from your current file and other files you reference, file names, and your prompt—to the cloud service to generate a response. However, the fact that any code leaves your machine is why the new support for local, offline LLMs is a critical feature for privacy-conscious users and organizations.

Lila: Can I use Copilot Chat if I’m not connected to the internet?

John: This depends entirely on your setup. If you are using the default configuration that connects to GitHub’s cloud-based LLMs, you need an active internet connection. If you have gone through the process of setting up a local LLM on your own machine and configured Copilot to use it, then you can work completely offline.

Lila: The big one: Is GitHub Copilot going to take my job as a developer?

John: The overwhelming consensus is no, it’s not going to take your job, but it is going to fundamentally change it. It automates tedious and repetitive tasks, acting as a powerful force multiplier. Developers who learn to effectively leverage AI tools will be significantly more productive than those who don’t. The job is evolving away from writing boilerplate and towards higher-level system design, problem-solving, and critically reviewing AI-generated code. The job title remains, but the day-to-day tasks will shift.

Lila: Last one: What’s the real difference between the gray “ghost text” suggestions I see while typing and the Copilot Chat window?

John: That’s a great distinction to make. The “ghost text” is called inline completion or code completion. That’s Copilot’s original feature, where it proactively suggests the next few lines of code as you type. Copilot Chat is the interactive, conversational interface. It’s a separate panel where you can ask questions in natural language, request entire functions or classes, ask for explanations, get help with debugging, and have a back-and-forth dialogue about your code.

Our Mission

Design. Strategy. Brand.

About Us