Góc Học Trò - Hoctro's Place

Ghi lại những mẩu chuyện, cảm nghĩ về âm nhạc và ngành điện toán/tin học, trong đó có trí tuệ nhân tạo (AI) bằng Claude AI. Posting in both English and Vietnamese my thoughts about popular music and Artificial Intelligence using Anthropic's Claude AI and Claude Code CLI. I'm a "Software 3.0" coder, specializing in producing essays using prompting techniques. I have not written a single line of python or javascript code for a year now, just plain English language.

9.21.2026

Visual Studio Code: A Complete Guide

Written by: Claude Sonnet AI.

Curator/Editor: Học Trò.

Visual Studio Code is a free, open-source-core code editor built by Microsoft that has, in about a decade, gone from a surprise announcement at Build 2015 to the tool the largest share of professional developers reach for every day. This guide covers what it is, how it is built, what it can do out of the box, how far its language support really reaches, how its extension ecosystem works, and — in real depth, since the two are now almost inseparable in practice — how GitHub Copilot is woven into it.

1. What Visual Studio Code Is

Visual Studio Code (commonly shortened to "VS Code" or just "Code") is a source-code editor developed by Microsoft for Windows, macOS, and Linux, with a browser-based version available at vscode.dev and github.dev. It is not the same product as Visual Studio, Microsoft's much older, heavier, Windows-first full IDE — the naming is a frequent point of confusion, but VS Code was built from scratch as a lightweight, cross-platform, extensible text editor rather than a slimmed-down Visual Studio.

Microsoft first showed VS Code publicly at the Build developer conference in April 2015 as a preview, released it broadly (still in preview) a few months later, and made it fully open source under the MIT license in November 2015, with the source hosted on GitHub. Version 1.0 shipped in April 2016. Since then it has followed a monthly release cadence — a new numbered version (1.10x) ships essentially every month, each with its own detailed public release notes on code.visualstudio.com.

By design, VS Code out of the box is closer to a very capable text editor than a full IDE: it starts fast, opens folders instead of requiring formal "projects," and keeps its core small. Everything that makes it feel IDE-like — debugging a specific language, linting, refactoring tools, database browsers, deployment tooling — is added through extensions rather than baked into the core. That architectural choice is the single biggest reason VS Code can credibly serve web developers, Python data scientists, C++ embedded engineers, and DevOps engineers writing YAML all with the same editor.

2. Architecture: What It's Actually Built From

VS Code is built on Electron, the same framework used by Slack, Discord, and many other cross-platform desktop apps. Electron bundles a Chromium rendering engine together with a Node.js runtime, which is why VS Code looks and behaves like a web application (because, under the hood, much of it is one) while still being able to read and write files on disk, spawn processes, and talk to a real filesystem the way a web page in a browser tab cannot.

The application itself follows a multi-process model inherited from Chromium's own architecture: a main process handles application lifecycle and window management, a renderer process handles the UI you actually see and interact with, and — critically for stability — extensions run in their own separate "extension host" process rather than inside the UI process. This means a badly behaved or crashing extension does not, in the normal case, take the whole editor down with it.

The text-editing surface itself — the component that actually renders code, handles syntax highlighting, cursors, selections, folding, and the editing gestures you feel when typing — is called Monaco Editor. Monaco is written entirely in TypeScript and is itself a separate open-source project that Microsoft ships as a standalone, embeddable web component; it's the same editor that powers the code-editing panes inside GitHub.com, Azure DevOps, and many third-party products that want "the VS Code editing feel" in a browser without shipping all of VS Code (microsoft/monaco-editor on GitHub). In other words, VS Code the application is a shell — window chrome, panels, command palette, extension host, settings system — wrapped around Monaco as its editing core.

The language VS Code itself is written in is overwhelmingly TypeScript, Microsoft's own statically-typed superset of JavaScript (a language whose lead architect, Anders Hejlsberg, also helped design VS Code — the connection between the two projects is not a coincidence). A smaller amount of native code exists at the edges (platform integration, some performance-sensitive pieces), but the editor, the UI, the extension host, and Monaco are all TypeScript/JavaScript running on Node.js inside Electron (overview of the architecture).

On licensing: the code in the microsoft/vscode repository is genuinely open source, released under the MIT license, and anyone can read it, fork it, or build their own editor from it. The specific binary Microsoft distributes as "Visual Studio Code," however, ships under a separate Microsoft product license because it adds a small number of proprietary touches on top of the open-source core — the official product branding and icons, telemetry/usage reporting, and integration with the official Visual Studio Marketplace (the closed marketplace that hosts extensions like the C# and Python language support). This split is exactly why a project called VSCodium exists: it builds the same MIT-licensed source with the Microsoft branding, telemetry, and marketplace ties stripped out, for people who want the identical editor without those pieces (license/architecture discussion).

The name "Visual Studio Code" is also sometimes shortened carelessly to just "Visual Studio" in casual conversation, which is worth untangling once and for all: Visual Studio proper long predates VS Code (its roots go back to the 1990s), is far heavier, is historically much more Windows- and .NET-centric, and targets large enterprise and game-development teams working in C++, C#, and related Microsoft-stack languages. VS Code, by contrast, was conceived from day one as cross-platform, lightweight, and language-agnostic, and the two products, despite sharing a corporate parent and a family name, have almost entirely separate codebases, separate teams, and separate release cadences. A developer who has only used one should not assume much about the other beyond a shared visual design language and the Microsoft account/Marketplace plumbing they both plug into.

3. Core Editing Features

Stripped of any extension, VS Code already behaves like a serious editor rather than a bare text box:

IntelliSense — context-aware code completion, parameter hints, and quick documentation, which for many languages is powered by a real language analysis engine rather than simple word-matching.
Multi-cursor and multi-select editing — placing several cursors at once (by Alt/Option-click or by selecting all occurrences of a word) to edit multiple locations simultaneously.
Command Palette (Ctrl/Cmd+Shift+P) — a searchable list of literally every command the editor and its installed extensions expose, which doubles as VS Code's de facto menu system and is often the fastest way to do anything once you're used to it.
Quick Open (Ctrl/Cmd+P) — fuzzy-search file opening across an entire project folder.
Integrated terminal — a real shell (PowerShell, bash, zsh, cmd, WSL, etc.) docked inside the editor window, so you never have to alt-tab to a separate terminal app for git commands, builds, or test runs.
Code folding, minimap, breadcrumbs, and a Peek view for jumping to (and previewing) a definition or reference without leaving your current file.
Built-in diff and merge editors, including a three-way merge editor for resolving Git conflicts visually.
Zen Mode and Settings Sync — a distraction-free full-screen mode, and a system for syncing settings, keybindings, snippets, and installed extensions across machines via a Microsoft or GitHub account.
Multi-root workspaces — opening several unrelated folders (e.g., a frontend repo and a backend repo) as one logical workspace with shared search and settings.

A related but less-discussed feature is snippets — small, reusable blocks of boilerplate code (a for loop skeleton, a React component template, a license header) that expand from a short trigger prefix into full code, with tab-stops that let you jump between the placeholders that need filling in. VS Code ships a set of default snippets per language and lets any extension or any individual user define their own in a simple JSON format, and teams frequently check a shared .vscode/*.code-snippets file into a repository so everyone on the project gets the same boilerplate shortcuts. Search is similarly full-featured out of the box: a global find-and-replace panel supports regular expressions, whole-word and case-sensitive matching, and include/exclude glob patterns, letting you rewrite a pattern across an entire multi-thousand-file repository in one operation with a live preview of every match before committing to the replacement.

4. Language Support: How Broad, and How

VS Code does not "know" any programming language natively in a deep sense — its core ships with only basic syntax highlighting for a large list of common languages via TextMate-style grammars. Real, deep language intelligence — accurate autocomplete, go-to-definition, find-all-references, inline error checking, safe renaming/refactoring — comes from a separate piece of software called a language server, which VS Code talks to over the Language Server Protocol (LSP).

LSP is arguably VS Code's most consequential contribution to the wider developer-tools world. Before it existed, every editor that wanted good support for, say, Python, had to write and maintain its own Python-understanding logic from scratch — an enormous duplicated effort repeated across every text editor for every language. The VS Code team, building on ideas already used inside Visual Studio's own tooling and taking the TypeScript language server's design as a starting point, defined a standard JSON-RPC-based protocol so that a single language server (say, one Python analysis engine) could be written once and plugged into any compliant editor — VS Code, but also Vim, Emacs, Eclipse, Sublime Text, and others (LSP protocol history). That standardization effort is a large part of why the modern editor landscape looks the way it does: dozens of editors now share the same underlying language intelligence instead of reinventing it.

A parallel protocol, the Debug Adapter Protocol (DAP), does the same job for debugging: it decouples the debugger UI (breakpoints, call stacks, variable inspection) from the language- or runtime-specific logic needed to actually control a debuggee process, so a debug adapter written once can be reused by any DAP-compliant client (DAP overview).

Practically, this means VS Code has first-class or near-first-class support — via official or community extensions built on LSP/DAP — for essentially every language in wide professional use: JavaScript and TypeScript (built in, since the extension is maintained by the same team), Python, C/C++, C#/.NET, Java, Go, Rust, PHP, Ruby, Swift, Kotlin, Dart/Flutter, SQL dialects, and markup/config languages like HTML, CSS, JSON, YAML, and Markdown. Beyond general-purpose languages, there is equally strong support for infrastructure and data work: Dockerfiles, Kubernetes manifests, Terraform, Jupyter notebooks (rendered and editable directly inside VS Code, cell by cell, with the same kernel model as classic Jupyter), and shell scripting.

5. Debugging, Tasks, and Version Control

Debugging in VS Code is unified behind the Debug Adapter Protocol described above: you set breakpoints, step through code, inspect the call stack and variables, and watch expressions using the same UI regardless of whether the underlying process is Node.js, Python, a compiled C++ binary via GDB/LLDB, or a remote process over SSH. Launch configurations live in a project's .vscode/launch.json file, which is itself just JSON and is commonly checked into source control so a whole team shares the same debug setup.

Tasks are VS Code's built-in way to wire up build systems, test runners, linters, or any other shell command as a first-class, keyboard-triggerable action (tasks.json), so "build" or "run tests" becomes one keystroke instead of remembering and retyping a command.

Git integration is built in, not an extension: the Source Control panel shows changed files, staged/unstaged diffs, and lets you commit, branch, push, and pull without leaving the editor, and inline "gutter" indicators show which lines changed relative to the last commit as you type. On top of that built-in baseline, extensions such as GitLens add much deeper history exploration (blame annotations inline, commit graphs, comparing branches), and the official GitHub Pull Requests and Issues extension lets you review, comment on, and even check out a pull request entirely inside the editor.

6. The Extension Marketplace and Ecosystem

The extension model is the mechanism that turns a lean core editor into whatever kind of IDE a given developer needs. Extensions are published to the Visual Studio Marketplace and can add language support, themes, debuggers, linters, snippet packs, entirely new UI panels, or — as covered in depth below — AI assistance. The marketplace has grown into one of the largest software extension ecosystems in existence, with tens of thousands of published extensions covering essentially every corner of software development, from .env file syntax highlighting to full database GUI clients to Kubernetes cluster explorers.

This extensibility is also the top reason VS Code shows up repeatedly at the top of developer surveys. In the 2025 Stack Overflow Developer Survey — drawing more than 49,000 responses from 177 countries — Visual Studio Code led all code editors and IDEs with 75.9% usage share, more than 2.6 times the usage of Microsoft's own full Visual Studio IDE at 29%, and well ahead of Notepad++ (27.4%), IntelliJ IDEA (27.1%), and Vim (24.3%) (2025 Stack Overflow Developer Survey; coverage of the results). Even the newer wave of AI-native forked editors hasn't dethroned it: the same survey found Cursor at 17.9%, Claude Code at 9.7%, and Windsurf at 4.9% — all real, fast-growing competitors, but each still far below VS Code's own share. Separately, Microsoft has reported VS Code passing 36 million monthly active users in 2024, up 20% year over year from 30 million the prior year (usage statistics summary).

7. Remote Development, Containers, and the Web

One of VS Code's more distinctive capabilities is that the editor's UI and the code it's editing don't have to be on the same machine. The Remote Development extension pack lets the VS Code window you see run locally while the actual file system, terminal, and language servers run somewhere else entirely:

Remote - SSH connects to any remote Linux, macOS, or Windows machine over SSH and edits/debugs there directly, as if the files were local.
Dev Containers runs your entire development environment inside a Docker container defined by a checked-in devcontainer.json, so "it works on my machine" becomes "it works in the exact same container on every machine," including CI.
WSL integration lets Windows users edit and run Linux-native tooling through the Windows Subsystem for Linux with the same seamless feel.
GitHub Codespaces takes this further into the cloud: a full dev container, provisioned on GitHub's infrastructure and accessible either through a browser tab or through the desktop VS Code app connecting to it remotely, so a contributor can go from "open this repo" to a fully configured, running dev environment with no local setup at all.

For lighter needs, VS Code also runs as a genuine web application with no install at all: vscode.dev loads a browser-only version of the editor (backed by the File System Access API for local files or GitHub's API for repos), and github.dev does the same but is reachable by pressing the . key on any GitHub repository page, dropping you straight into a full editing UI for that repo in seconds.

8. Notebooks, Testing, Accessibility, and Customization

VS Code's Notebooks support renders .ipynb Jupyter notebooks natively, cell by cell, with the same rich output rendering (plots, tables, images) as classic Jupyter, while still giving you VS Code's IntelliSense, debugging, and source control inside the notebook. A unified Testing view (the Test Explorer) discovers tests from frameworks like pytest, Jest, or the .NET test runners and lets you run, debug, and see pass/fail status per test, per file, or for the whole suite, from one panel regardless of language.

Accessibility has had sustained, dedicated investment: full screen-reader support, an accessible view for chat and terminal content, adjustable and independently scalable UI/editor font sizes, high-contrast themes, and keyboard-only navigation for essentially the entire application.

Customization runs deep by design: virtually every keybinding can be rebound, settings.json exposes hundreds of fine-grained options as plain JSON (with full IntelliSense while you edit it), Profiles let you save and switch between entire configurations (extensions, settings, keybindings, UI layout) — useful for keeping, say, a "Python data science" profile cleanly separate from a "Node backend" profile on the same machine — and thousands of color and icon themes are available to change the editor's look without touching functionality at all.

It's worth being concrete about what these protocols mean for a working developer rather than leaving it abstract. Before LSP, a company maintaining, say, a Rust compiler toolchain that wanted good editor support had a choice between writing bespoke plugins for every popular editor separately (an enormous, perpetually out-of-date maintenance burden) or accepting that most editors would only ever offer shallow syntax coloring for the language. After LSP, that same team writes one Rust language server once (in this case, rust-analyzer), and any LSP-compliant editor — VS Code, Neovim, Helix, Zed, Emacs with the right plugin — gets real autocomplete, real error checking, and real refactoring support for free, simply by speaking the same protocol. This is also why a language server written for VS Code by one vendor is routinely reused, unmodified, inside completely unrelated commercial products; the protocol, not the specific editor, is the actual point of leverage.

9. Forks, Derivatives, and Where VS Code Sits in the Market

Because the core is open source, VS Code has become a common foundation for other products rather than only a finished end-user tool. VSCodium rebuilds the same source without Microsoft's branding, telemetry, or marketplace ties. Eclipse Theia, an unrelated but philosophically similar open-source project, reuses many of the same protocols (LSP, DAP) to build a cloud- and desktop-capable IDE framework used by products like Google Cloud's Cloud Shell Editor and Gitpod (Eclipse Theia). More notably for the current moment, several of the fastest-growing "AI-native" code editors — Cursor and Windsurf chief among them — are themselves forks of VS Code's open-source core, reusing its editor, extension compatibility, and general UI while replacing or deeply augmenting the AI layer. That lineage is a large part of why an experienced VS Code user can sit down at Cursor or Windsurf and feel at home within minutes: underneath the AI-specific chrome, it is substantially the same editor.

10. GitHub Copilot Integration in VS Code

No account of modern VS Code is complete without a close look at GitHub Copilot, because for a very large share of today's users the two are no longer really experienced as separate products — Copilot is the layer that turned VS Code from "an excellent, fast, extensible editor" into "the default place a great many developers now write code with an AI collaborator sitting next to (and increasingly inside) every keystroke." Copilot ships as an official Microsoft/GitHub extension (actually a pair of extensions — GitHub Copilot for completions, and GitHub Copilot Chat for the conversational and agentic features) rather than as a built-in part of VS Code's MIT-licensed core, which keeps the base editor free and open while the AI layer sits on top as a separate, primarily paid, product.

Inline (ghost-text) completions. The original and still-foundational Copilot feature is inline code suggestion: as you type, gray "ghost text" appears ahead of your cursor proposing the rest of the current line, or the next several lines, based on the surrounding code, open files, and (depending on settings and plan) broader repository context. Accepting a suggestion is a single Tab press; VS Code also exposes commands to cycle between alternative suggestions or accept just the next word rather than the whole block. A closely related feature, next-edit suggestions, goes further than simple completion: it watches the edit you just made elsewhere in the file and proactively suggests the next logical edit needed to keep the code consistent — for example, updating a second call site after you rename a function's parameter. According to GitHub's own 2026 pricing documentation, these baseline completion and next-edit features remain free and effectively unlimited across every paid plan, and are also available (with reduced monthly limits) on the free tier — unlike the heavier chat and agent features described next, which draw down a metered credit allowance (GitHub Copilot plans & pricing).

Copilot Chat. A dedicated chat panel lives alongside the editor (and, as of 2026, can also open as a separate "side chat" so you can run more than one conversation thread at once) for asking questions in natural language about the currently open code, getting an explanation of a confusing function, requesting a fix for a specific error, or asking for a whole new piece of code to be drafted. Chat understands "participants" and slash commands that scope a request — for instance directing a question specifically at the workspace, at a particular extension's own Copilot integration, or at a terminal command — and it can be given explicit context (a file, a selection, a whole folder, terminal output, or the current set of compiler errors) so its answers are grounded in your actual project rather than generic training knowledge.

Agent mode. This is the feature that has done the most to change how Copilot is actually used day to day, and it is a genuine step beyond autocomplete-style assistance. In agent mode, you describe a task in plain language — implement a feature, fix a failing test, refactor a module — and Copilot autonomously plans a sequence of steps, edits multiple files across the codebase as needed, runs terminal commands (installing a dependency, running a build, running the test suite), reads the output of those commands, and if something fails or an error appears, it iterates and self-corrects, continuing until the task is complete or it needs your input, all without you manually directing each individual step (Copilot agent mode overview). As of the 2026 releases, agents can also run for longer, more complex tasks with more visibility and control given back to the user mid-run: you can talk to a running agent and interrupt or redirect it while it's working rather than only reviewing its output after the fact, you can schedule agent tasks to run recurringly (hourly, daily, or weekly) or trigger them on demand, and a "prompt timeline" control lets you navigate back through a long agent transcript to a specific earlier prompt and review exactly what file changes happened around it (VS Code January 2026 / v1.109 release notes; GitHub Copilot in VS Code, August 2026 changelog).

Model choice and interoperability. On paid plans, Copilot Chat is not locked to a single underlying model — users can switch between model providers, including recent GPT, Gemini, and Anthropic Claude models (GitHub's own 2026 changelog specifically mentions choosing between Claude Opus and other models depending on subscription and plan tier), directly from a dropdown in the chat UI. Interoperability has gone further still: VS Code's January 2026 release added the ability to reuse Claude configuration files directly inside VS Code, and the August 2026 release lets a user switch model providers within a Claude session in VS Code between their Anthropic subscription and their Copilot subscription, and view or continue a recent Copilot or Claude agent session that was originally started in a different application from a shared "Sessions" list inside VS Code (VS Code February 2026 / v1.110 release notes). In practice this means the boundary between "using Copilot" and "using Claude" inside VS Code has become much softer than the product names alone would suggest — the editor increasingly treats different AI coding assistants as interchangeable backends behind one shared chat and agent interface, including a common Agent Plugins 1.0 standard, introduced in 2026, for portable agent extensions that work across VS Code and other compatible clients.

MCP support. Since mid-2026, Copilot's agent mode in VS Code supports the Model Context Protocol (MCP), an open standard (originated by Anthropic and since adopted broadly across the industry) for connecting an AI agent to external tools, databases, and services in a structured, reusable way. Practically, this lets a Copilot agent in VS Code do things well beyond editing files in the open workspace — querying a live database, calling an internal company API, checking a ticket tracker, or driving a browser — by connecting to any MCP server a team has configured, using the same protocol other MCP-compatible clients (including Claude Desktop and Claude Code) already speak (Copilot agent mode and MCP guide).

Code review and pull requests. Copilot's reach extends past the local editing session into collaboration: it can perform automated code review on a pull request, leaving inline comments the way a human reviewer would, and it integrates with the GitHub Pull Requests extension so review, discussion, and even Copilot-suggested fixes can happen without leaving VS Code.

Pricing and plans. GitHub restructured Copilot's billing on June 1, 2026, moving every plan — individual and organizational — onto usage-based billing through GitHub AI Credits (1 credit = $0.01), metered by token usage at each underlying model's own rate, with every paid plan bundling a monthly credit allowance roughly equal to its price. As of the 2026 pricing page, individual plans run Free ($0), Pro ($10/month, including $15 of monthly credits), Pro+ ($39/month, including $70 of credits), and Max ($100/month, including $200 of credits); organizational plans run Business ($19/seat/month) and Enterprise ($39/seat/month) (GitHub Copilot plans & pricing; usage-based billing announcement). Under this model, the lightweight inline completions and next-edit suggestions remain free and effectively unlimited on every plan including Free, while heavier features — chat, agent mode, and code review — draw down the credit allowance, which is the mechanism GitHub uses to let a single subscription flex across cheaper and more expensive underlying models rather than charging a flat fee regardless of which model does the work.

Taken together, these pieces mean that "GitHub Copilot in VS Code" in 2026 is no longer accurately described as "autocomplete with a subscription." It is a multi-model, tool-using, increasingly autonomous agent layer, natively wired into the editor's file system, terminal, debugger, and source control, that a developer can direct at the level of a single line, a whole feature, or a whole recurring maintenance task — while VS Code itself has been steadily reshaped, release by release through 2026, around the assumption that a session now regularly includes one or more AI agents working alongside the human, not just a human typing alone.

It's also worth naming the competitive picture VS Code sits inside rather than treating it as unchallenged. On the traditional side, JetBrains's family of IDEs (IntelliJ IDEA, PyCharm, WebStorm, and siblings) remains the preferred choice for many developers who want deep, opinionated, language-specific tooling built in from the start rather than assembled from extensions — the 2025 Stack Overflow survey put IntelliJ IDEA at 27.1% usage, a real and durable base rather than a rounding error. Sublime Text and Vim/Neovim retain loyal followings among developers who prioritize raw startup speed and keyboard-driven editing over IDE-style features. On the newer side, the AI-native forks discussed above — Cursor, Windsurf, and others — compete less on the editing experience itself (which they mostly inherited from VS Code) and more on how aggressively and by default they weave AI into the core workflow, sometimes offering a more opinionated or more unified agent experience than VS Code's extension-based approach provides. VS Code's response, visible across the 2026 release notes cited throughout this guide, has effectively been to absorb the most compelling parts of that competition directly into the base product and its official Copilot extension rather than cede that ground — multi-agent session management, model switching, MCP support, and Claude interoperability all arrived within a matter of months of each other through 2026, a release cadence aimed squarely at keeping the free, open core editor competitive with paid, AI-first forks built from its own source code.

11. Conclusion

Visual Studio Code succeeded by making an unusual bet for its time: keep the core small, fast, and free; make almost everything else pluggable; and open-source enough of it that the wider ecosystem — language maintainers, tool vendors, and eventually entire forked products — would have a reason to build on top of it rather than around it. A decade on, that bet looks vindicated by the numbers alone, let alone by how completely "open VS Code" has become a default reflex across the industry — the phrase itself, uttered dozens of times a day in standups and screen-shares worldwide, is a small piece of evidence for how thoroughly the editor won the mindshare battle it entered as an underdog in 2015. The arrival of deeply integrated AI assistance, led by GitHub Copilot but no longer limited to it, is the biggest change to that story since the original 2015 launch — not because it replaced anything VS Code already did well, but because it was layered on top of exactly the extensible architecture that made all of VS Code's earlier growth possible in the first place.

Sources

Written by: Claude AI.