Choosing useful VS Code extensions is an exercise in restraint. Too many unnecessary or competing extensions can increase resource use and complicate troubleshooting. The best choices depend on your language, project and security requirements rather than a universal ranking.
This guide covers the small number of extensions that genuinely earn their place, grouped by what they do: formatting and code quality, Git, AI assistance, and web development. It then explains which once popular extensions you should no longer install, because the editor now does the job natively, and how to keep your setup fast as it grows.
The Best VS Code Extensions To Install First
| Tool | Purpose | Check Before Installing |
|---|---|---|
| Prettier | Formatting | Supported Languages And Project Rules |
| ESLint | Linting | Project ESLint Configuration |
| GitLens | Git History | Built-In Git And Required Features |
| Live Server | Static Page Preview | Existing Development Server |
Before installing the first extension, open a small trusted project and inspect its existing configuration. A JavaScript project might already define its formatter, linter and scripts. A Python project may instead specify its own formatting and analysis tools. The editor should cooperate with that configuration rather than silently replacing it. Use the Extensions view, search by exact identifier and inspect the publisher, feature details and dependencies. Install only if the extension meets the actual need.
For a JavaScript project that intentionally uses Prettier, select its default formatter for that language and try formatting a disposable file manually before enabling format on save. Review the change in source control. If the project has a configuration file, follow that configuration instead of imposing personal preferences. Formatting should be an explainable, reviewable change. ESLint should be configured separately for the rules the project uses. A formatting extension cannot detect all incorrect application behavior, and a lint rule can report a warning without proving a bug exists.
When you are working on a shared repository, agree with the team about formatting and lint rules. One person using different line wrapping and another changing quotes can produce unnecessary changes in nearly every commit. Store the project’s supported rule configuration with the project, and run its checks outside the editor too. This helps detect issues on another machine or in continuous integration. Avoid copying an entire settings file from a stranger’s repository, because it may contain unrelated, outdated, or unsafe configuration.
For JavaScript, TypeScript and other supported formats, Prettier (esbenp.prettier-vscode) is a practical formatting option. It uses defined rules to produce consistent layout; enable format on save only if that suits the project. Check the project’s existing formatting configuration first.
ESLint (dbaeumer.vscode-eslint) integrates the project’s linter with VS Code. Configured rules can identify unused variables and other patterns; this is not a proof of correctness. Install or configure ESLint in the project as needed, and avoid competing style rules if Prettier handles formatting.
GitLens can be useful when a project requires detailed history and blame information. Search for the exact identifier eamodio.gitlens, verify its publisher and current feature terms, and compare its capabilities with VS Code’s built-in source control before installing. Git must also be available in the relevant development environment.
Extensions For Web Development
A basic static page is a useful way to test the development-server workflow. In a trusted practice folder, create a small index.html file and make a visible text change. Start a supported local preview, open the local address and save the file to check the reload behavior. Stop the server after practice. Do not preview a folder containing confidential files through a server exposed to other devices. A project that uses a framework may require its own established build and development scripts, so consult its documentation first.
For path completion and tag navigation, test the editor’s native behavior in that same small project. Rename an HTML tag, follow a stylesheet link and look for definitions. If you can already do those things comfortably, a separate extension may add little value. If your project contains many templates or uses a framework-specific file format, the project’s official language tooling may offer a more accurate result than a general-purpose helper.
API request collections require additional care. When evaluating an HTTP client extension, first use a harmless public learning endpoint or a local test service with no credentials. Verify request method, headers, body and status code. Check how the extension stores environment variables and secrets, and never commit genuine tokens to the repository. An API testing extension should reduce friction, not expose sensitive data.
For a simple static HTML and CSS project, Live Server (ritwickdey.LiveServer) can provide a local server and reload the browser when files change. A framework project may already provide a suitable development server. Keep a local preview private unless you deliberately configure and secure network access.
Auto Rename Tag can help synchronize paired HTML tags, but check whether VS Code’s built-in linked editing is sufficient for your language and file type first. Path Intellisense can provide additional path suggestions if built-in completion is inadequate. Inspect the current Marketplace listing and publisher before installing either helper.
CSS Peek and Import Cost are examples of optional helpers for style navigation and estimating imported package sizes. Check their current support for your project; an estimate does not equal the final compressed production bundle. A REST client extension can be useful for authorized API testing, but remove real credentials and private endpoints from request files before sharing or committing them.
AI Assistants Inside The Editor
AI coding extensions are optional. GitHub Copilot offers inline suggestions and other editor features according to its configuration and account plan. Check the current official product documentation and your organization’s policies rather than relying on a fixed pricing claim.
Alternative coding assistants may offer different completion, hosting and privacy arrangements. Tabnine and the products historically associated with Codeium are examples to evaluate separately. Verify current names, availability, licensing, data-handling terms and deployment modes with each provider. Do not assume any assistant is local or private by default.
Read and test suggested code before accepting it. Do not submit secrets, confidential code or personal data to services without authorization. Disable or limit optional assistance when working in a sensitive project according to its policies. A generated answer can be plausible while still being wrong or insecure.
What You No Longer Need To Install
VS Code can highlight nested bracket pairs without the old Bracket Pair Colorizer extension. Enable the built-in editor.bracketPairColorization.enabled setting if needed. See the official code navigation documentation. Do not install a deprecated extension merely because an older tutorial recommends it.
VS Code includes language-dependent completion and built-in Git integration. Some projects still require a language extension or external language server. Check built-in capabilities before installing a helper; add GitLens only if its deeper history tools match an actual need.
Consult the official editor documentation before adding a utility for a feature the editor may already support. Temporarily disable a nonessential extension and try an ordinary workflow if you want to compare. Restore it if an important feature depends on it.
How To Keep Your Editor Fast
To investigate performance, create a baseline in a trusted project: compare ordinary startup, opening a file, typing and switching tabs. Keep the same folder, files and activity when you repeat the test. An extension may perform useful indexing after a project opens; high activity during indexing is not automatically a defect. Record whether delays persist after ordinary initialization finishes.
The official Extensions view permits disabling extensions globally or for the current workspace. Disable one nonessential candidate and restart the extension host if prompted. Retest your baseline. If the slowdown persists, restore the original setting and investigate another candidate. For a repeatable symptom with many installed extensions, Extension Bisect can narrow candidates by testing subsets. Follow the prompts and restore normal operation afterward. A disabled extension may make some project-specific language features temporarily unavailable, so do not treat their absence as a separate defect.
For a reproducible list, use the built-in CLI command code --list-extensions --show-versions in a shell where the VS Code command is installed. The output can assist comparison across machines. Do not automatically install every item from another developer’s output. An identifier and version record are useful for diagnosis but do not certify publisher trust or suitability.
Extensions can affect startup, responsiveness, memory and project behavior, depending on what they load and when they activate. Measure a reproducible symptom instead of assuming that every installed extension has equal overhead.
- Use the Developer: Show Running Extensions command to inspect active extensions. For a reproducible extension-related problem, use the supported Extension Bisect utility in the Extensions view.
- Disable extensions you rarely use rather than leaving them active in every window.
- Enable an extension for a single workspace when it only applies to one project or language.
- Review what you have installed every few months and remove anything you cannot remember using.
- Verify the exact publisher, identifier, documentation, update history, dependencies and permissions. Download counts and ratings are clues, not proof of security.
Extensions can exercise the editor’s permissions, including access to workspace material. Review publisher trust and the supported security controls. Microsoft’s Extension Marketplace documentation explains installation, publisher confirmation and extension management. Never approve an unfamiliar publisher solely because an extension has a convincing name.
Building Your Own Shortlist
For a team, a minimal workspace recommendation file can contain the identifiers for tools the team actually uses. For example, a project that intentionally uses both Prettier and ESLint can include these two recommendations: esbenp.prettier-vscode and dbaeumer.vscode-eslint. The actual dependencies and rules still belong to the project setup. A recommendation is an invitation to review and install an extension, not a reason to trust unfamiliar third-party code automatically.
Review your installed extensions periodically, especially when switching projects. Check whether a tool is deprecated, has a supported successor, or duplicates a built-in feature. A small starter set can grow as concrete requirements appear. Keep publisher trust, update support and project compatibility ahead of download counts or rankings. Read the developer tools handbook for the broader workflow.
Start with the language-specific capabilities you need. JavaScript and TypeScript developers may benefit from Prettier and ESLint; a Python or Go project has different tools. Add GitLens only if native Git integration does not meet your history needs.
From there, add one extension at a time and only when you notice a specific friction. If you keep mistyping import paths, install Path Intellisense. If you keep reloading the browser by hand, install Live Server. Adding tools in response to real annoyances, rather than in anticipation of them, keeps your editor fast and means you remember why each one is there.
Settings Sync can share selected settings and extensions across trusted installations. For team projects, a .vscode/extensions.json file can recommend agreed extension identifiers. It does not install every dependency or enforce identical formatter configuration. Link to our VS Code setup guide for initial configuration.
Frequently Asked Questions
What Are The Best VS Code Extensions To Start With?
Choose extensions for the project. Prettier handles supported formatting, ESLint integrates configured JavaScript or TypeScript linting, and GitLens can provide deeper Git history. Install language-specific tooling only when needed.
Do Too Many Extensions Slow Down VS Code?
Yes, some extensions can increase activation time or resource usage, or conflict with other tools. Compare actual behavior and use Extension Bisect to isolate reproducible problems.
Is Bracket Pair Colorizer Still Recommended?
No, VS Code supports bracket-pair colorization natively. Check the relevant built-in setting before installing a deprecated helper.
Which AI Coding Extension Should I Use?
Choose an optional assistant based on supported features, account terms, privacy, organization approval and the ability to review generated code. There is no universally best choice.
Are VS Code Extensions Safe To Install?
Not automatically. Extensions can have substantial access within the editor environment. Verify publishers and exact identifiers, review features and permissions, and decline untrusted installations.


