How to Turn Off Autocomplete in VS Code

VS Code’s autocomplete isn’t one switch. It’s three overlapping systems, and most guides only show you how to silence one of them.

Knowing how to turn off autocomplete in VS Code properly means targeting IntelliSense quick suggestions, word-based completions, and inline ghost text from AI tools like GitHub Copilot or Tabnine, each with its own setting.

This guide covers every method: the Settings UI, settings.json, language-scoped overrides, workspace configs, and extension-specific toggles.

You’ll also learn what stays active after you disable suggestions, including Go-to-Definition, hover docs, and the language server, so nothing breaks in the process.

What Is Autocomplete in VS Code?

Autocomplete in VS Code is not a single feature with a single toggle. It is the IntelliSense suggestion engine, a system of 3 overlapping components that each operate independently and require separate settings to disable.

VS Code is used by 74% of all developers as of the 2024 Stack Overflow Developer Survey (65,000+ respondents). That kind of adoption means its default editor settings, including autocomplete, are configured for the broadest audience, not necessarily for your workflow.

The 3 autocomplete components are:

• Quick suggestions (IntelliSense): the automatic dropdown that appears as you type, controlled by editor.quickSuggestions
• Word-based suggestions: completions drawn from words already in the open file, controlled by editor.wordBasedSuggestions
• Inline completions (ghost text): the gray predictive text from AI tools like GitHub Copilot or Tabnine, controlled by editor.inlineSuggest.enabled

Disabling one does not disable the others. This is the detail most guides miss, and it is why developers often turn off editor.quickSuggestions and still see ghost text appearing.

The suggestion widget (the dropdown popup) and inline suggestions (ghost text) are rendered by completely separate systems. The language server, which powers Go-to-Definition and hover documentation, runs independently of both. Turning off autocomplete leaves those features intact.

How Do You Turn Off Autocomplete in VS Code Using the Settings UI?

The Settings UI is the fastest path if you want to disable autocomplete without touching any config files.

Open Settings with Ctrl+, on Windows and Linux, or Cmd+, on macOS. Changes take effect immediately. No restart required.

Disable Quick Suggestions

In the Settings search bar, type “quick suggestions”. The result is “Editor: Quick Suggestions” with 3 sub-options: other, strings, and comments.

Set all 3 to “off”. This stops the suggestion dropdown from appearing automatically while you type code, inside strings, and inside comments. Each sub-option targets a different context, so setting only one leaves the others active.

Disable Word-Based Suggestions

Search for “word based suggestions” in Settings. The default value is matchingDocuments, which pulls completions from any open file with the same language.

Set this to “off”. If you skip this step, VS Code continues surfacing suggestions from open files even after quick suggestions are disabled.

Disable Trigger Character Suggestions

Trigger characters like . and ( fire the suggestion dropdown regardless of your editor.quickSuggestions setting.

Search for “suggest on trigger characters” and uncheck the box. This stops the popup from appearing when typing a period in JavaScript or an opening parenthesis in Python.

How Do You Turn Off Autocomplete in VS Code Using settings.json?

The settings.json method is more precise and portable. It is the right choice for developers who share configs across machines via Settings Sync or commit them to version control.

Open the Command Palette with Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (macOS), then type “Open User Settings (JSON)” and press Enter.

The Full Disable Configuration

Paste this block into your settings.json to disable all 3 autocomplete components at once:

{
  "editor.quickSuggestions": {
    "other": "off",
    "comments": "off",
    "strings": "off"
  },
  "editor.suggestOnTriggerCharacters": false,
  "editor.wordBasedSuggestions": "off",
  "editor.inlineSuggest.enabled": false
}

Save the file with Ctrl+S. The settings apply instantly.

User Settings vs. Workspace Settings

User settings apply globally across every project you open in VS Code.

Workspace settings live inside a .vscode/settings.json file at the root of a specific project. Workspace settings override User settings when both exist. If you want autocomplete off for one repo but on for everything else, use the workspace file.

The JSON properties and values are identical in both files. Only the file location differs.

How Do You Disable Autocomplete for a Specific Language Only?

Language-scoped settings let you disable autocomplete in one language while keeping it active in others. This is common among developers who use VS Code for both code and prose, like Markdown documentation alongside Python or JavaScript projects.

Language Scope Syntax

VS Code supports language-specific overrides inside settings.json using bracket notation. The language identifier must match VS Code’s internal ID exactly. These identifiers are case-sensitive.

To disable autocomplete for Markdown only:

{
  "[markdown]": {
    "editor.quickSuggestions": {
      "other": "off",
      "comments": "off",
      "strings": "off"
    },
    "editor.wordBasedSuggestions": "off",
    "editor.suggestOnTriggerCharacters": false
  }
}

Common Language Identifiers

Multiple language blocks can coexist in the same settings.json. Each block only affects files VS Code identifies as that language.

Why Writers Use This

A lot of developers who write technical documentation inside VS Code run into the same frustration: IntelliSense popups interrupt prose flow. Language-scoped settings fix this without touching the VS Code defaults for code files.

The Pylance extension, which powers Python IntelliSense, respects language-scoped settings. So does the TypeScript language server. Both will stop firing suggestion providers when the matching language block sets editor.quickSuggestions to "off".

How Do You Turn Off Inline Completions (GitHub Copilot and AI Suggestions)?

Inline completions are a completely separate layer from IntelliSense. GitHub Copilot generates 46% of all code written by its users on average (GitHub, 2024), and its suggestions appear as ghost text that standard autocomplete settings do not control.

Disabling editor.quickSuggestions has no effect on Copilot’s inline suggestions. This surprises a lot of developers and is one of the most common reasons the disable process feels incomplete.

Disable the Ghost Text Layer

Set "editor.inlineSuggest.enabled": false in your settings.json. This disables the ghost text layer for all inline completion providers, including Copilot, Tabnine, and Codeium.

This is a separate setting from editor.quickSuggestions and must be set independently.

GitHub Copilot-Specific Toggle

GitHub Copilot has its own setting on top of the shared inline suggest layer. To disable Copilot completions specifically without affecting other inline providers:

{
  "github.copilot.inlineSuggest.enable": false
}

Alternatively, click the Copilot icon in the VS Code status bar (bottom right) and select “Disable Completions.” This writes the same setting without opening settings.json.

Tabnine and Codeium

Tabnine: click the Tabnine logo in the status bar and select “Pause Tabnine Completions.” This suspends completions without uninstalling the extension.

Codeium: open the Command Palette, search for “Codeium: Disable,” and run the command. Codeium also has a status bar icon with a disable option.

As of November 2025, Microsoft deprecated IntelliCode (which had accumulated over 70 million downloads in the VS Code Marketplace) and redirected users toward GitHub Copilot. If you previously relied on IntelliCode’s starred completions, those are now gone from VS Code by default (Visual Studio Magazine, 2025).

How Do You Turn Off Autocomplete for a Specific Workspace or Project?

Workspace-level settings scope autocomplete changes to a single project folder. The global User settings stay untouched.

Create a .vscode folder at the root of the project if one does not already exist, then create a settings.json file inside it. The path should be: your-project/.vscode/settings.json.

Workspace Settings Override Logic

When VS Code loads a workspace, it merges User settings and Workspace settings. Workspace settings win on any property where both files define a value.

This means you can keep autocomplete enabled globally while silencing it inside a specific documentation repo, a legacy codebase with noisy suggestions, or a writing project.

Team-Shared Configurations

Committing .vscode/settings.json to version control shares the autocomplete configuration with every developer on the team. This is the standard approach for enforcing consistent editor behavior across a codebase without relying on each developer to configure their own User settings.

The same properties apply: editor.quickSuggestions, editor.wordBasedSuggestions, and editor.suggestOnTriggerCharacters. The only difference is file location, not syntax.

Large monorepos sometimes use workspace-level autocomplete settings to reduce the suggestion noise that comes from the language server scanning enormous node_modules or build directories. That is a separate performance concern from personal preference, but the same .vscode/settings.json file handles it.

How Do You Disable Snippet Suggestions in VS Code?

Snippet suggestions are a distinct autocomplete component. Disabling editor.quickSuggestions reduces the suggestion dropdown but does not remove built-in snippets or extension-provided snippet completions from the list.

The Snippet Suggestions Setting

The setting that controls snippet visibility in the suggestion list is editor.snippetSuggestions.

Set it to “none” to remove snippet suggestions entirely:

{
  "editor.snippetSuggestions": "none"
}

The default value is "inline", which places snippet suggestions alongside other completion items. Setting it to "none" hides them from the dropdown without removing the snippets themselves from VS Code.

What This Does and Does Not Affect

What changes: snippets no longer appear in the automatic suggestion dropdown. What stays the same: Tab-triggered snippet expansion still works if you type a snippet prefix manually and press Tab. The snippets remain installed. Only their automatic appearance in the completion list is suppressed.

Extension-provided snippets, including those from language packs like the Python extension or JavaScript snippet collections from the VS Code Marketplace, are also removed from the dropdown by this setting.

How Do You Turn Off Parameter Hints in VS Code?

Parameter hints are the tooltip popup that appears mid-function call, showing argument names and types as you type inside parentheses.

They are independent from the quick suggestions dropdown. Turning off editor.quickSuggestions does not suppress them.

Disable Parameter Hints Globally

Set "editor.parameterHints.enabled": false in your settings.json. This stops the signature help popup from firing for all languages and all files.

Via the Settings UI: open Settings with Ctrl+,, search “parameter hints”, and uncheck the “Editor: Parameter Hints: Enabled” checkbox.

Dismiss Temporarily Without Disabling

Keyboard shortcut: press Shift+Escape to close an active parameter hint popup without changing any settings.

Pressing Ctrl+Shift+Space (Windows/Linux) or Cmd+Shift+Space (macOS) re-invokes parameter hints manually when you need them. This works even after editor.parameterHints.enabled is set to false.

Disable for One Language Only

The language-scope pattern applies here too. To disable parameter hints for JavaScript while keeping them in Python:

{
  "[javascript]": {
    "editor.parameterHints.enabled": false
  }
}

Extensions like Pylance (Python) and the TypeScript language server respect this override. Some C++ language server configurations may require a matching extension-level setting to fully suppress signature help.

How Do You Disable Autocomplete Without Losing Go-to-Definition and Hover Docs?

This is the concern that stops most developers from disabling autocomplete. The worry is understandable but unfounded.

Go-to-Definition, Peek Definition, hover documentation, and Find All References all run through the Language Server Protocol, not through the suggestion widget system. They are separate features of the language service.

What Stays Active After Disabling Autocomplete

Manual Trigger Still Works

Key point: disabling editor.quickSuggestions removes the automatic popup, not the capability.

Pressing Ctrl+Space still opens the suggestion widget on demand after autocomplete is disabled. The suggestion list appears exactly when you ask for it and disappears when you dismiss it.

GitHub’s own research shows 73% of developers report staying in flow state when using coding tools that do not interrupt their focus (GitHub, 2024). Removing automatic popups while keeping on-demand access is the middle path most experienced developers settle on.

Hover Docs Are a Separate Toggle

If you want hover documentation off too, that requires "editor.hover.enabled": false as an additional setting.

Most developers leave hover docs on. It is a passive feature that only fires on deliberate mouse-over, not as an interruption mid-keystroke.

How Do You Temporarily Turn Off Autocomplete in VS Code?

Not every situation calls for a permanent settings change. Sometimes you want to suppress suggestions for 10 minutes without editing any JSON.

Research from UC Irvine shows that after a single interruption, it takes an average of 23 minutes to regain full focus. Even brief popups mid-keystroke count as interruptions for developers in deep work.

Dismiss on the Fly

Escape: closes the active suggestion popup immediately without changing settings. The next character you type may re-trigger it.

Ctrl+Space: toggles the suggestion list open or closed manually. Press once to open, press again to close.

Add a Toggle Keybinding

VS Code has no built-in shortcut to toggle editor.quickSuggestions on and off. You can add one via keybindings.json.

Open keybindings.json through Ctrl+Shift+P and “Open Keyboard Shortcuts (JSON)”, then add:

[
  {
    "key": "ctrl+alt+s",
    "command": "settings.cycle",
    "args": {
      "id": "editor.quickSuggestions",
      "values": [
        { "other": "on", "comments": "off", "strings": "off" },
        { "other": "off", "comments": "off", "strings": "off" }
      ]
    }
  }
]

This requires the Settings Cycler extension to work. Without it, you can bind a workspace settings write command or simply use the Settings UI toggle as your “temporary” method.

The On-Demand Workflow

A practical middle ground: disable editor.quickSuggestions permanently in settings.json, but keep Ctrl+Space available for when you want the completion list.

This approach gives you the VS Code suggestion engine on your terms rather than the editor’s terms. Many experienced developers describe this as their preferred setup after trying full autocomplete for years.

How Do Autocomplete Settings Interact with Extensions?

Extensions register their own completion providers independently of the VS Code core suggestion engine. This is the most common source of confusion after disabling autocomplete.

Enabling more than one AI autocomplete extension at the same time causes trigger collisions where suggestions from both providers vanish instead of appearing (Chaos and Order, 2026). One extension per category is the current best practice.

How to Identify Which Extension Is Providing a Suggestion

Hover over any item in the suggestion dropdown. The tooltip shows the completion item’s source label, which identifies the provider.

• Built-in completions show the language identifier (e.g., “TypeScript” or “Python”)
• GitHub Copilot completions are labeled with the Copilot icon
• Tabnine and Codeium show their own brand labels

If the label shows an extension you thought you disabled, the extension-level setting was not applied correctly.

Extension-Level Disable vs. Core Settings

Core settings (editor.quickSuggestions, editor.inlineSuggest.enabled) control VS Code’s built-in suggestion engine only.

Extension settings control each AI provider’s own suggestion layer. Both must be set to fully disable all autocomplete from that provider.

To disable an extension entirely without uninstalling it, open the Extensions panel with Ctrl+Shift+X, right-click the extension, and select “Disable.” This is the cleanest option when settings-level control is not working.

The Cursor and Windsurf Case

Cursor and Windsurf (formerly Codeium’s IDE) are VS Code forks with autocomplete baked into the editor core rather than delivered via extension. Disabling inline suggestions in settings.json works, but the fork may re-enable them through its own settings layer.

In those editors, look for the fork-specific settings panel (Cursor: Cursor Settings, Windsurf: Windsurf Settings) and disable AI completions there first, then apply the standard VS Code settings on top.

How Do You Re-enable Autocomplete in VS Code After Turning It Off?

Reversing the changes is straightforward. The process depends on how you disabled autocomplete in the first place.

Restore Default Values in settings.json

These are the VS Code default values for every autocomplete setting that was covered in this guide:

{
  "editor.quickSuggestions": {
    "other": "on",
    "comments": "off",
    "strings": "off"
  },
  "editor.suggestOnTriggerCharacters": true,
  "editor.wordBasedSuggestions": "matchingDocuments",
  "editor.inlineSuggest.enabled": true,
  "editor.parameterHints.enabled": true,
  "editor.snippetSuggestions": "inline"
}

Paste this into your User settings.json to restore defaults. Or delete the properties entirely. VS Code falls back to built-in defaults for any property not present in the file.

Reset via the Settings UI

Each setting in the Settings UI has a gear icon to its left. Click the gear icon next to any autocomplete setting and select “Reset Setting” to restore its default value individually.

This is useful when you want to restore one setting (like parameter hints) without touching others you intentionally left off.

Remove Language-Scoped Overrides

If you added language-specific blocks like [markdown] or [python] to disable autocomplete for those file types, delete those blocks from settings.json.

Language-scoped overrides persist until explicitly removed. Restoring global defaults does not cancel a [markdown] block that sets editor.quickSuggestions to "off".

Check the workspace settings.json Too

If autocomplete stays off after restoring User settings, check for a .vscode/settings.json file inside the open project folder.

Workspace settings override User settings. A project-level disable persists until the .vscode/settings.json file is edited or deleted, regardless of what User settings say.

FAQ on How To Turn Off Autocomplete In VS Code

How do I completely turn off autocomplete in VS Code?

Set editor.quickSuggestions to "off" for all 3 sub-options (other, strings, comments) in settings.json. Also set editor.wordBasedSuggestions to "off" and editor.suggestOnTriggerCharacters to false. All 3 properties are required for a full disable.

Why does autocomplete still appear after I disabled it?

A third-party extension like GitHub Copilot or Tabnine is providing suggestions independently of VS Code’s built-in IntelliSense engine. Core settings only control the native suggestion widget. Each AI extension needs its own disable setting applied separately.

Does turning off autocomplete also disable Go-to-Definition?

No. Go-to-Definition, Peek Definition, and hover documentation run through the Language Server Protocol, which is separate from the suggestion widget system. Disabling editor.quickSuggestions has no effect on those features.

Can I disable autocomplete for Markdown only?

Yes. Use a language-scoped block in settings.json: "[markdown]": { "editor.quickSuggestions": { "other": "off" } }. This silences suggestions only in Markdown files while keeping IntelliSense active in Python, JavaScript, and other languages.

How do I turn off GitHub Copilot inline suggestions specifically?

Set "github.copilot.inlineSuggest.enable": false in settings.json, or click the Copilot icon in the VS Code status bar and select “Disable Completions.” Setting editor.inlineSuggest.enabled to false also suppresses Copilot ghost text.

Can I still trigger suggestions manually after disabling autocomplete?

Yes. Pressing Ctrl+Space opens the suggestion widget on demand even after editor.quickSuggestions is set to "off". The completion list appears when you ask for it and closes when you dismiss it with Escape.

How do I disable autocomplete for a specific project only?

Create a .vscode/settings.json file inside the project root and add the same autocomplete settings there. Workspace settings override User settings, so the change applies only to that project without affecting your global editor configuration.

What is the difference between quick suggestions and inline suggestions?

Quick suggestions appear as a dropdown popup list controlled by editor.quickSuggestions. Inline suggestions appear as gray ghost text controlled by editor.inlineSuggest.enabled. These are separate systems and each requires its own setting to disable.

How do I turn off snippet suggestions without disabling all autocomplete?

Set "editor.snippetSuggestions": "none" in settings.json. This removes built-in and extension-provided snippet completions from the suggestion dropdown while leaving IntelliSense word-based and language server suggestions fully active.

How do I re-enable autocomplete after turning it off?

Set editor.quickSuggestions back to { "other": "on" } and editor.wordBasedSuggestions to "matchingDocuments". Or open Settings, click the gear icon next to each autocomplete setting, and select “Reset Setting” to restore VS Code defaults individually.

Conclusion

This conclusion is for an article presenting how to turn off autocomplete in VS Code across every layer: the suggestion widget, word-based completions, snippet suggestions, parameter hints, and AI-powered ghost text.

The key takeaway is that editor.quickSuggestions alone is never enough. Extensions like GitHub Copilot and Tabnine operate through their own completion providers and need separate disable settings.

Whether you applied the change globally via User settings, scoped it to a single language, or locked it to a workspace with .vscode/settings.json, the language server stays intact.

Go-to-Definition, Ctrl+Space on-demand suggestions, and hover documentation all remain available. You are not losing IntelliSense. You are deciding when it runs.

• Author
• Recent Posts

Bogdan Sandu

Bogdan Sandu is a front-end developer at TMS Outsource with 8+ years of experience in web technologies. He writes about developer tools, software platforms, and web workflows based on daily hands-on use.

Latest posts by Bogdan Sandu (see all)

• Laravel Cheat Sheet - September 13, 2026
• How to Use GitHub Projects to Manage Your Work - September 12, 2026
• How To Visualize and Optimize Lead Flow Using Kanban Principles - September 12, 2026