When Supermaven runs alongside GitHub Copilot or another AI completion tool, you can get duplicated, flickering, or missing inline suggestions. Here is how to diagnose the conflict and choose a clean setup.
You have both Supermaven and another AI completion tool, most often GitHub Copilot, installed in VS Code. Now inline suggestions behave strangely.
You might see suggestions flicker, get suggestions from the wrong tool, notice one tool never appears, or experience laggy behavior that erases Supermaven's usual speed advantage.
The root cause is that inline completions in VS Code are a shared surface. Two providers competing for the same slot leads to unpredictable results.
The fix is not clever configuration to run both perfectly at once. It is deciding which tool owns inline completion and setting things up accordingly.
Once you accept that only one provider should own the inline surface, the rest of this guide is just how to enforce that choice cleanly.
VS Code renders inline suggestions from providers one at a time in a given spot. When multiple AI extensions want to fill that spot, the editor has to pick, and the outcome can be inconsistent.
Because Supermaven's whole appeal is low latency, a competing provider that responds slower can make the combined experience feel worse than either alone.
You may also see behavior where accepting a suggestion is ambiguous, because it is unclear which tool produced the text you are looking at.
Understanding this helps you stop trying to make both coexist invisibly and instead make a deliberate choice.
The two tools are not aware of each other. Neither is misbehaving on its own; the friction is purely that they are contending for one shared piece of editor real estate.
Check your installed extensions and their status indicators. Verify that both Supermaven and the other AI tool are actually enabled and signed in.
If both show active, you have confirmed the conflict scenario rather than a single-tool failure.
Note which one currently seems to be winning the inline slot. That tells you which provider VS Code is favoring right now.
With that established, you can make an informed decision instead of toggling settings randomly.
It also helps to note whether the conflict is global or limited to Swift files. If one tool is configured per-language, the symptom may appear only in certain file types, which is a useful clue.
Decide which tool you want producing inline completions as you type. This is the key decision, and it is easiest to evaluate one at a time.
Many developers who value latency choose Supermaven for inline completion. Others prefer Copilot's chat and broader ecosystem for other tasks.
You do not have to uninstall the loser. You can keep the other tool installed but stop it from competing for inline suggestions.
Make the choice explicit rather than leaving two providers fighting silently in the background.
A fair way to decide is to run each solo for a few days on the same Swift work. Judging them side by side while both are active is unreliable, precisely because the conflict distorts both.
If you choose Supermaven as primary, disable the other tool's inline completions. For Copilot, you can turn off its inline suggestions globally or per language via settings, or disable the Copilot extension entirely.
Copilot supports enabling or disabling completions for specific languages, so you could, for instance, let Supermaven own Swift while another tool handles a different language.
After changing settings, reload the VS Code window so the change fully applies.
Then test in a Swift file: you should now see clean, single-source suggestions from your chosen provider.
If you prefer Copilot as primary instead, the same logic applies in reverse — disable Supermaven's inline suggestions and let Copilot own the surface. The principle is one provider per file type, not which brand wins.
Open a Swift file and type a predictable line. Confirm that suggestions appear from exactly one tool and that they render smoothly without flicker.
Check that Supermaven's low latency is back. If the experience still feels laggy, the other provider may still be participating; recheck its inline settings.
Accept a suggestion and confirm the accepted text matches what you saw previewed. Ambiguity here usually means both providers are still active.
When suggestions are single-source and snappy, the conflict is resolved.
Test in a couple of different files too, not just one. A per-language setting can leave the conflict resolved in Swift but still present in JavaScript or Python, which you want to know before you move on.
You can keep a second AI tool for non-inline features. For example, use Supermaven for inline completion and another tool primarily for chat, while its inline suggestions stay off.
Alternatively, split by language if your work spans several. Assign inline completion per language so only one tool is ever active in a given file type.
Document your choice for your team if you share settings, so nobody is surprised by a reintroduced conflict when they sync configuration.
A deliberate division of labor is more reliable than hoping two inline providers behave together.
If your team shares a committed workspace settings file, put the inline-provider decision there so every clone starts in the same, conflict-free state.
That also spares new teammates the exact debugging session you just went through. A committed setting is documentation that actually enforces itself.
Revisit the arrangement whenever someone adds a new AI extension, since a fresh provider can quietly reintroduce the same contention on the inline surface.
If conflicts persist after disabling the other provider's inline suggestions, fully disable the competing extension and reload as a clean test.
Check the Output panel for both extensions to spot errors, and make sure both extensions and VS Code are updated, since compatibility fixes ship regularly.
As a last resort, run a minimal setup: only Supermaven enabled, other AI extensions disabled, to confirm the baseline works, then reintroduce tools one at a time.
This binary-search approach quickly isolates which extension and which setting is responsible.
If even the minimal setup misbehaves, the problem is not a conflict at all — return to the general completion troubleshooting steps, because something in activation, settings, or connectivity is the real cause.
Neither tool changes how you ship an iOS app. Whichever AI completer you pick, building, signing, and submitting still happen in Xcode with an Apple Developer Program membership.
So optimize this conflict for your authoring comfort, not for your release pipeline, which is unaffected either way.
Pick a primary inline provider, disable the competition on the inline surface, and verify you get single-source, low-latency suggestions.
With the conflict resolved, you get the fast Swift authoring experience you installed Supermaven for in the first place.
And because the release path is untouched by this choice, you can revisit it freely later — swap primary providers, or re-split by language — without any risk to how your app is built and submitted.
You can have both installed, but they compete for VS Code's inline suggestion surface. For clean behavior, let only one provide inline completions and use the other for chat or a different language.
Disable Copilot's inline suggestions globally or per language in settings, or disable the Copilot extension entirely, then reload VS Code.
Two AI extensions are both trying to fill the inline slot. Pick one primary inline provider and turn the other's inline suggestions off to fix the flicker.
Yes. Copilot supports per-language enablement, so you can, for example, let Supermaven own Swift while another tool handles other languages, avoiding overlap.
No. Both are only authoring aids. Building, signing, and submitting your iOS app always happen in Xcode with an Apple Developer Program account, regardless of your completion tool.