GitHub Copilot in VS Code With Tabnine Installed: Coexistence Patterns

Running both GitHub Copilot and Tabnine in Visual Studio Code simultaneously can cause unexpected behavior, such as duplicate suggestions, conflicting auto-completions, or one extension overriding the other. This happens because both tools hook into the same editor completion API, and their default settings do not include coordination logic. This article explains how the two extensions interact, how to configure them to work together, and what patterns you can use to get the best results from both.

How GitHub Copilot and Tabnine Interact in VS Code

Both GitHub Copilot and Tabnine extend the VS Code editor by providing inline code completions. They listen to the same editor events and push suggestions through the InlineCompletionItemProvider API. When both are enabled, VS Code may show suggestions from both extensions at the same time, or it may show only the last registered provider depending on the version and settings.

The root cause of conflicts is that neither extension was designed to coordinate with the other. Copilot uses a cloud-based large language model for context-aware completions. Tabnine uses a local or cloud model focused on code patterns and repetition. They do not share a queue or priority system. As a result, you may see two overlapping suggestion windows, flickering suggestions, or completions that do not match your coding style.

VS Code itself does not natively merge suggestions from multiple providers. The editor shows the suggestion from the last provider that responded, which can vary by latency and system load. This means the suggestion you see may come from either extension, and the other suggestion is silently dropped or appears after a delay.

When Both Extensions Are Installed but One Is Disabled

If you disable one extension completely via the Extensions panel, the other works as expected. There is no residual interference. The coexistence issue only appears when both are active simultaneously.

Performance Impact

Running both extensions can increase CPU and memory usage, especially during initial project indexing. Tabnine builds a local model index on first run. Copilot sends keystroke context to its cloud service. Together they may cause brief editor freezes on large files or slow startup times.

Patterns for Configuring Both Extensions to Work Together

You have three practical patterns for running both extensions in VS Code. Choose the pattern that matches your workflow.

Pattern 1: Copilot as Primary Suggester, Tabnine for Chat and Code Review

Use this pattern if you prefer Copilot inline completions but still want Tabnine’s chat assistant or code review features. In this pattern, Tabnine inline completions are disabled.

1. Open the Tabnine configuration panel
   Press Ctrl+Shift+P, type Tabnine: Open Config, and press Enter. The Tabnine Config window opens in a new tab.
2. Disable Tabnine inline completions
   In the Tabnine Config window, locate the Completion section. Set the toggle for Enable Inline Completions to Off. Tabnine will no longer provide code suggestions in the editor.
3. Keep Tabnine chat and code review features active
   Tabnine’s chat panel and code review commands remain available. You can use them alongside Copilot completions without conflict.

Pattern 2: Tabnine as Primary Suggester, Copilot for Chat and Commands

Use this pattern if you prefer Tabnine’s local completions but still want Copilot’s chat interface and slash commands. In this pattern, Copilot inline suggestions are disabled.

1. Open the Copilot status bar menu
   Click the Copilot icon in the VS Code status bar, or press Ctrl+Shift+I to open the Copilot chat panel.
2. Disable Copilot inline suggestions
   In the status bar menu, select Disable Inline Suggestions. Copilot will stop showing inline completions in the editor.
3. Verify Tabnine completions are active
   Start typing in a code file. You should see Tabnine suggestions only. Copilot chat remains accessible via Ctrl+Shift+I or the Copilot icon.

Pattern 3: Let Both Run with Provider Priority

This pattern relies on VS Code’s provider priority mechanism. You do not disable either extension. Instead, you set one as the default provider in settings.json. The editor will prefer the higher-priority provider when both respond.

1. Open VS Code settings.json
   Press Ctrl+Shift+P, type Preferences: Open Settings (JSON), and press Enter.
2. Set inline suggestion provider priority
   Add the following line to give Copilot higher priority: "editor.inlineSuggest.enabled": true. Then add: "github.copilot.enable": {"": true}. For Tabnine, ensure "tabnine.experimentalAutoImports": true is present. Save the file.
3. Test the behavior
   Type a few lines of code. The suggestion you see should come from Copilot because it registers after Tabnine and becomes the last provider. If you see Tabnine suggestions instead, reverse the order of the settings or disable one extension as described in Pattern 1 or 2.

ADVERTISEMENT

Common Issues and How to Resolve Them

Both Extensions Show Suggestions Simultaneously

This is the most common problem. The editor displays two overlapping suggestion windows. To fix this, disable inline completions for one extension using Pattern 1 or 2 above. If the problem persists, restart VS Code after changing the settings.

Copilot Suggestions Are Not Showing

Tabnine may be responding faster and blocking Copilot. Check that "github.copilot.enable": {"": true} is in your settings.json. Also verify that Copilot is signed in by clicking the Copilot icon in the status bar. If it shows a warning icon, sign in again.

Tabnine Indexing Slows Down Copilot

Tabnine indexes your project when it first loads. During indexing, CPU usage spikes and Copilot may lag. Wait for indexing to complete, or exclude large folders in Tabnine settings. Go to Tabnine Config > Indexing and add folders to the exclusion list.

VS Code Crashes or Freezes

Running two memory-intensive extensions can cause instability. Try disabling one extension temporarily. If the crash stops, consider using only one extension for inline completions. You can keep the other for chat or code review features only.

GitHub Copilot vs Tabnine: Key Differences

Item	GitHub Copilot	Tabnine
Completion model	Cloud-based large language model (OpenAI Codex)	Local or cloud-based deep learning model
Privacy	Code context sent to GitHub servers	Local mode keeps code on your machine
Inline completions	Enabled by default	Enabled by default
Chat interface	Built-in chat panel with slash commands	Chat panel available in Pro plan
Code review	Not available	Available in Tabnine Enterprise
Auto-imports	Not supported	Supported with experimental toggle
Pricing	Free tier with limits; Pro at $10/month; Business at $19/month	Free tier with limited completions; Pro at $12/month; Enterprise custom pricing

Both extensions can coexist in VS Code if you configure their inline completion settings properly. The recommended approach is to let one handle inline suggestions and use the other for secondary features like chat or code review. This avoids conflicts and keeps the editor responsive.