Last updated: March 16, 2026

Tabnine AI models cannot be directly imported into Supermaven because the two platforms use different model architectures and training approaches. Instead, back up your Tabnine configuration from ~/.tabnine/user.config.json and custom models from the models/ subdirectory, then configure Supermaven’s settings to match your preferences. Supermaven’s adaptive learning will personalize suggestions to your coding style within a few hours of active use.

Table of Contents

Why Developers Switch from Tabnine to Supermaven

Supermaven has gained popularity among developers for its faster inference speeds and competitive pricing model. Some developers find that Supermaven’s contextual understanding better matches their coding style, while others appreciate its more straightforward subscription tiers. The primary reasons developers cite when making this switch include:

Regardless of your reason for switching, understanding how to handle your existing Tabnine data ensures a smooth transition with minimal disruption to your workflow.

Prerequisites

Before you begin, make sure you have the following ready:

Step 1: Understand Tabnine Model Storage

Tabnine stores its AI models and configuration data in specific directories on your system. The exact location depends on your operating system and editor configuration.

Default Model Locations

On macOS, Tabnine typically stores its data in:

~/.tabnine

On Linux systems, you will find the data in:

~/.config/Tabnine

On Windows, the data resides in:

%APPDATA%\Tabnine

Within these directories, you will encounter several key folders and files:

To get a quick picture of what Tabnine has stored on your machine, run:

# macOS / Linux
ls -lah ~/.tabnine/
du -sh ~/.tabnine/models/

This helps you understand the total size of model files before you decide whether to archive or discard them.

Step 2: Exporting Your Tabnine Configuration

Before uninstalling Tabnine, export your configuration to preserve your settings. This ensures you can recreate similar preferences in Supermaven.

Navigate to your Tabnine configuration directory and locate the user.config.json file. This file contains settings such as:

Create a backup by copying this file to a secure location:

# Create backup directory
mkdir -p ~/tabnine-backup

# Backup Tabnine configuration
cp ~/.tabnine/user.config.json ~/tabnine-backup/config.json

If you have custom-trained models (available in Tabnine Pro), the model files themselves are stored in the models/ subdirectory. Copy these files as well:

# Backup custom models
cp -r ~/.tabnine/models ~/tabnine-backup/

Once you have a backup, open user.config.json in a text editor and note the key values. Write these down in a simple reference file, because you will translate them manually into Supermaven’s configuration format.

Step 3: Can Supermaven Import Tabnine Models?

Supermaven does not natively import Tabnine model files directly. The two platforms use different model architectures and training approaches, making direct model transfer impossible. However, this does not mean your Tabnine experience is wasted.

Supermaven uses its own proprietary models that are pre-trained on extensive codebases. The good news is that Supermaven quickly learns from your coding patterns through its own adaptation process, so you will not need to wait long for personalized suggestions.

If you were using Tabnine’s custom model training feature—available in Tabnine Enterprise—to train on your private codebase, Supermaven does not have a direct equivalent. In that case, evaluate whether Supermaven’s base model quality meets your needs before committing to the switch. Running both tools in different editors for a week is a low-risk way to compare output quality on your actual codebase.

Step 4: Set Up Supermaven After Tabnine

After uninstalling Tabnine, install Supermaven through your preferred editor’s extension marketplace or package manager. VS Code users can install it from the Marketplace, while Neovim users can use their plugin manager.

Basic Supermaven Configuration

Supermaven uses a configuration file located in its data directory. On macOS and Linux:

~/.config/Supermaven

On Windows:

%APPDATA%\Supermaven

Create or edit the configuration file to match your preferences:

{
  "max_tokens": 250,
  "use_single_line": false,
  "fuzzy_match_threshold": 0.7,
  "notification_mode": "ambient"
}

These settings control suggestion length, single-line completion behavior, fuzzy matching sensitivity, and notification style.

Editor-Specific Setup

VS Code: After installing the Supermaven extension, open the Command Palette (Cmd+Shift+P) and run “Supermaven: Sign In” to authenticate. The extension activates automatically for supported file types.

Neovim with lazy.nvim:

{
  "supermaven-inc/supermaven-nvim",
  config = function()
    require("supermaven-nvim").setup({
      keymaps = {
        accept_suggestion = "<Tab>",
        clear_suggestion = "<C-]>",
        accept_word = "<C-j>",
      },
    })
  end,
}

JetBrains IDEs: Install the Supermaven plugin from the JetBrains Marketplace. Configuration is handled through the plugin settings panel rather than a standalone config file.

Step 5: Preserving Your Coding Context

While model files cannot transfer, you can preserve your coding context through other means:

1. Maintain Consistent Editor Configuration

Keep your editor settings similar between platforms. If you used specific keybindings for Tabnine, configure the same bindings for Supermaven in your editor’s configuration.

2. Document Your Preferences

Write down your Tabnine settings before uninstalling. Key preferences to note include:

3. Replicate Import Patterns

If you worked with specific libraries or frameworks, ensure Supermaven has access to the same project context. Open your projects in your editor so Supermaven can analyze your codebase and begin building an understanding of your patterns.

4. Work in Representative Files First

Supermaven’s adaptation is usage-driven. On day one, work in your most frequently edited files rather than one-off scripts or configuration files. This gives Supermaven the most useful signal about your actual coding style and the libraries you use regularly.

Troubleshooting Common Issues

After switching from Tabnine to Supermaven, you might encounter some initial issues:

Suggestions Feel Generic

If Supermaven suggestions feel less personalized initially, give it time. The model adapts to your coding style within a few hours of active use. Ensure you are working on your actual projects rather than generic code samples. Suggestion quality typically reaches a comfortable level after two full working days on your normal projects.

Conflicting Keybindings

If both extensions remain installed, keybindings may conflict. Completely remove Tabnine before relying on Supermaven:

# Remove Tabnine extension (VS Code)
code --uninstall-extension=Tabnine.tabnine-vscode

# Verify removal
code --list-extensions | grep -i tabnine

For Neovim, remove the Tabnine plugin from your plugin manager configuration and run the appropriate cleanup command (:Lazy clean for lazy.nvim, :PlugClean for vim-plug).

Performance Concerns

Supermaven is designed for speed, but ensure your system meets minimum requirements. Close resource-heavy applications if you experience lag. If you notice higher CPU usage than expected, check that Tabnine’s background processes are fully terminated—stale Tabnine processes occasionally continue running after extension removal.

Suggestions Not Triggering

If Supermaven installs but does not produce completions, check that the extension is active for your file type. Open the Supermaven output panel in VS Code (View > Output, then select Supermaven from the dropdown) to see if the extension is connected to the inference service.

When to Start Fresh

Sometimes beginning with a clean slate works better than trying to replicate previous settings. Supermaven’s default configuration suits most developers well, and its adaptive learning quickly provides relevant suggestions.

Consider starting fresh if:

Best Practices for Transition

Follow these recommendations for the smoothest transition:

  1. Backup before uninstalling — Always create backups of your configuration before making any changes
  2. Gradual transition — Use both tools briefly in parallel (different projects) to compare suggestion quality
  3. Give it time — Allow Supermaven two to three days to adapt to your patterns before making a final judgment
  4. Adjust gradually — Tweak settings one at a time to understand their impact on suggestion behavior
  5. Update your team — If others share your editor configuration through a dotfiles repo, communicate the change so teammates can update their setups

Frequently Asked Questions

Can I keep Tabnine installed while I evaluate Supermaven?

Yes, but only run one at a time. Having both active creates keybinding conflicts and may affect editor performance. Disable Tabnine at the extension level rather than uninstalling it if you want the option to switch back quickly.

Will Supermaven learn from my private code?

Supermaven does offer a privacy mode where your code is not used to improve their base models. Check their privacy settings during onboarding to configure this according to your organization’s requirements.

How long does the adaptation period really take?

In practice, Supermaven suggestions become noticeably more relevant after roughly four to six hours of active coding on your real projects. The improvement is gradual rather than a sudden step change.