DEV Community: Jonatas Sas

Inline AI Suggestions in NeoVim: GitHub Copilot vs Windsurf (Codeium) — A Technical Comparative Analysis

Jonatas Sas — Tue, 06 May 2025 20:55:20 +0000

Before we dive in, it's worth noting a recent branding change: the assistant formerly known as Codeium is now called Windsurf. The rebranding aims to reposition the tool under a new identity, though the transition has caused some confusion in the community, particularly among terminal-centric users. For clarity, throughout this article, we will refer to the tool as Windsurf, its current official name.

Among terminal enthusiasts, NeoVim has established itself as a powerhouse of productivity. Combining lightness, extensibility, and full control over the development environment, it's become the go-to editor for developers who not only write code but carefully curate a streamlined workflow. In this context, the integration of artificial intelligence tools for real-time code suggestions—commonly referred to as inline suggestions — represents a significant and potentially transformative addition.

In recent years, two major players have emerged in this space: GitHub Copilot, developed in partnership with OpenAI and backed by the GitHub ecosystem, and Windsurf, a free and increasingly popular alternative. Both aim to enhance developer productivity by anticipating and completing code based on context. But how do they actually perform within NeoVim—a notoriously demanding environment when it comes to customization and efficiency?

This article offers a deep technical comparison focused specifically on how these tools behave in NeoVim. I will cover configuration, technical capabilities, plugin integration, LSP behavior, privacy, community adoption, and contextual awareness. The goal? To help you make an informed decision about which AI assistant to rely on in your daily workflow.

Setup and Installation

Copilot (with enhanced integration)

While the official copilot.vim plugin is still available, it's highly recommended to use the modern copilot.lua implementation paired with copilot-cmp. This setup provides better control, full nvim-cmp integration, and increased stability. Here's a recommended configuration using lazy.nvim:

{
  "zbirenbaum/copilot.lua",
  cmd = "Copilot",
  config = function()
    require("copilot").setup({})
  end,
},
{
  "zbirenbaum/copilot-cmp",
  dependencies = "zbirenbaum/copilot.lua",
  config = function()
    require("copilot_cmp").setup()
  end,
},

This setup disables visual panels and enables suggestions exclusively through nvim-cmp. Authentication is triggered via the :Copilot auth command, which opens your browser.

Why choose copilot.lua over copilot.vim?

Native integration with nvim-cmp
Fine-grained control over appearance and behavior
Better performance in asynchronous environments
Community-maintained extensions like copilot-lualine for status display

Windsurf

Windsurf’s installation process is equally simple and well-documented. Here is a basic configuration using lazy.nvim:

{
  "Exafunction/windsurf.nvim",
  dependencies = { "nvim-lua/plenary.nvim", "hrsh7th/nvim-cmp" },
  config = function()
    require("codeium").setup({})
  end,
},

Once installed, use :Codeium Auth to authenticate via the browser. The plugin integrates automatically with nvim-cmp and requires Node.js on your system to function properly.

Plugin Integration

Copilot

Copilot benefits from strong community support. With copilot-cmp, it integrates directly with nvim-cmp for inline completions. The copilot-lualine plugin allows users to monitor the plugin's status in the statusline.

Advanced users can extend functionality using telescope.nvim to inspect logs and command history, or integrate which-key.nvim for quick keymap discovery. Behavior can be further customized via commands and configuration hooks, especially when using copilot.lua.

Windsurf

Windsurf provides solid integration with essential tools like nvim-cmp, lspkind.nvim (for UI icons), and noice.nvim (for quiet UI feedback). However, it lacks certain advanced integrations, such as a dedicated plugin for displaying status (e.g., lualine or heirline) and tighter control interfaces.

As of now, Windsurf has no official plugins for telescope.nvim, nor does it expose much internal state for customization or automation. The plugin focuses on simplicity and automatic configuration, which is suitable for most users but might limit advanced workflows.

Community Adoption

GitHub Copilot is the current market leader in adoption, with over 1.8 million paid users as of late 2023. Its official plugin has more than 9,000 stars on GitHub, and its deep GitHub integration makes it an obvious choice for teams already invested in the Microsoft ecosystem.

Windsurf, on the other hand, is quickly gaining ground. Formerly known as Codeium, it surpassed 700,000 users in 2024 and is used by over a thousand companies—many of which take advantage of its on-premises deployment option. The windsurf.nvim plugin is still maturing, but it has already demonstrated solid technical stability and growth.

A Note on the VSCode vs NeoVim Experience

It’s crucial to understand that both Copilot and Windsurf were originally designed with graphical editors in mind—primarily Visual Studio Code. This means that many of their native features, such as chat windows, PR integrations, and visual context navigation, were built assuming a rich UI.

GitHub Copilot, for instance, shines brightest in VSCode with features like Copilot Chat, multi-file awareness, and integration with GitHub repositories. Within NeoVim, however, the experience is more limited, relying on third-party plugins to provide similar capabilities.

Windsurf faces a similar scenario. While it does offer a dedicated NeoVim plugin—unlike Copilot, whose official Vim support is fairly limited—many advanced features remain exclusive to the VSCode extension. Still, its CLI-based client for terminal use is fast, reliable, and competitive.

This mismatch between environments creates a noticeable gap. Features that feel revolutionary in VSCode are often not yet fully available or stable in the NeoVim ecosystem, directly impacting the experience of users who prefer a keyboard-centric workflow.

That said, this note is not intended to suggest a change of editor. Rather, it highlights the need for broader vendor support and awareness regarding the growing demand from developers who choose terminal-based tools like NeoVim or Vim. Features that feel revolutionary in VSCode are often not yet fully available or stable in the NeoVim ecosystem, directly impacting the experience of users who prefer a keyboard-centric workflow.

Scoring Methodology and Final Verdict

Below, I present a comparative scoring of GitHub Copilot and Windsurf based on technical criteria, usage experience in NeoVim, and my own perception of their strengths and limitations. This evaluation is subjective but informed by real-world usage and priorities such as customization, stability, integration, and user control.

Criteria	Copilot	Windsurf
Setup and Installation	8	9
Suggestion Quality	7	8
Context Awareness	5	9
Plugin Ecosystem	9	7
Technical Stability	6	6
Customizability	6	9
Privacy Handling	5	9
Model Intelligence	9	8
NeoVim Support	6	8
Popularity and Adoption	10	7
Pricing	5	10

Total Score:

Copilot: 76 points
Windsurf: 90 points

References and Resources

To support further exploration and experimentation, I’ve compiled the following resources. These links include official documentation, plugin repositories, and project homepages, offering deeper insights into setup, customization, and ongoing development of both Copilot and Windsurf:

GitHub Copilot Official Site — Overview of Copilot’s capabilities, pricing, and integrations from GitHub.
Copilot.nim (Official Vim Plugin) — The official plugin maintained by GitHub for Vim and NeoVim.
Copilot.lua (Community Plugin) — A modern, extensible alternative to the official Copilot plugin.
Copilot-cmp — Enables Copilot suggestions to integrate with nvim-cmp.
Copilot-lualine — A lightweight plugin to show Copilot’s status in lualine.
Windsurf (Codeium) NeoVim Plugin — The official plugin for using Windsurf inside NeoVim.
Windsurf Website — General access to Windsurf’s features, documentation, and signup.
Codeium vs Copilot Performance Thread (Reddit) — Community-driven insights and real-world performance observations.
AI Code Completion Benchmarks (2023) — Research paper comparing latency and accuracy across several AI coding tools.

Conclusion

I intend to keep this scorecard updated over time, as both tools are living projects in constant evolution. Changes in performance, integration capabilities, and community contributions may significantly shift the balance in future versions.

Both Copilot and Windsurf bring considerable value to NeoVim users.

Windsurf stands out for its customizability, contextual precision, privacy controls, and free usage model, making it a compelling option for developers who want full control over their environment.

Copilot, meanwhile, remains a highly accessible choice for those already embedded in the GitHub ecosystem. Its performance, ease of use, and extensive community support make it a solid pick—especially if you're using VSCode as your primary editor.

Ultimately, the best choice depends on how you work, what you prioritize, and where you want your toolchain to take you.

If you use either of these tools in NeoVim, or have insights, configurations, or edge cases you'd like to share, I’d love to hear from you. Your input could help improve this comparison and guide future updates. And if you'd like to see a follow-up article with detailed configuration instructions and related plugin setups, just let me know! Your input could help improve this comparison and guide future updates.

Thank you for reading! I hope this article offered clarity and practical value for your workflow. As both tools are living projects in constant evolution. Changes in performance, integration capabilities, and community contributions may significantly shift the balance in future versions.

Note: This article reflects my personal and technical analysis based on actual usage of both tools in NeoVim. The preferences, perceptions, and scores expressed are mine alone and are not intended to define universal standards. Every developer should evaluate these tools based on their own context and needs.

Why You Should Migrate to NeoVim

Jonatas Sas — Fri, 25 Apr 2025 22:50:49 +0000

Background

I've been programming since 2004, and my journey began right inside the banking sector. Back then, my days were filled with Perl scripts — using Interwoven Templates — and plenty of JavaScript to bring life to web frontends. It was a different world: heavy systems, strict environments, tools that demanded real discipline.

During that time, I worked with VI and other classic tools that forced you to know exactly what you were doing. There were no "autocompletes" or "friendly interfaces" to save you. It was raw, and in some ways, it built the foundation I stand on today.

As time passed, PHP entered my life and became a strong focus. I dabbled with other languages when needed, but PHP remained central. I explored IDEs, one after another — Eclipse, NetBeans — until I found my home for a long time: PhpStorm. Without exaggeration, PhpStorm boosted my work, sharpened my delivery, and opened a new chapter for me as a developer.

If you're still on VSCode today, let me offer some honest advice: consider trying NeoVim or PhpStorm. Both can change the way you feel about building software.

The Turning Point: Speed and Workflow

Managing several projects simultaneously started exposing cracks in my workflow. Even the mighty PhpStorm, with all its power, couldn't fully hide the latency creeping in when things got too heavy.

At different moments, I tried moving to Vim and later NeoVim. I failed a few times. And if you try, you might fail too — at least at first. That's okay.

You need at least a month — a real, honest month — to migrate properly:

Your speed will drop.
You will doubt yourself.
You'll want to give up.

But migration isn't some mystical leap. It's a strategy. It's an act of patience and adaptation.

Some practical advice to ease the path:

Start by using Vim keybindings inside your IDE (e.g., IdeaVim in JetBrains).
Get comfortable progressively, not all at once.
Explore NeoVim's configuration files and slowly make them your own.
Embrace Lua — the quiet power behind NeoVim's modern capabilities (and a proud Brazilian export from PUC-RJ!).

Why Choose NeoVim?

Because it demands something precious: understanding.

You have to learn how your environment is structured:

How each tool plugs into the bigger picture.
How workflows aren't accidents — they're systems you consciously create.

When you step away from relying on the mouse and move into a world of pure keyboard-driven navigation, something strange happens: you start thinking differently. Your code becomes an extension of your hands, and your focus deepens. It’s not faster just for the sake of speed. It’s faster because it’s closer to you.

Maximizing Focus and Brain Efficiency

Context-switching kills focus. Every time you switch apps — jumping from an IDE to Postman, to FileZilla, to the terminal — your brain spends energy adapting to new visual contexts.

In a terminal-driven environment like NeoVim, everything stays cohesive. You run your Git commands. You write your code. You test APIs. You manage servers. All within the same ecosystem.

That continuity matters. It’s not just saving milliseconds. It’s preserving your flow state, protecting that rare moment when you’re fully immersed.

Programming, at its best, feels like water flowing through your mind. NeoVim helps preserve that.

The Hidden Cost of Traditional IDEs

Traditional IDEs, for all their polish, slowly start shaping you in their image. You stop thinking about how you want to work. You just accept how they want you to work.

Abstraction is helpful at first. But for a developer who wants to master the craft, too much abstraction becomes a cage.

NeoVim breaks that. It gives you back control. It reminds you that your environment should serve you — not the other way around.

Final Reflection

NeoVim isn’t about being cool. It isn’t about showing off speed.

It’s about ownership.

It’s about building an environment that molds itself to you. One where your hands, your thoughts, your habits — all flow together into something that feels honest and natural.

Once you taste that freedom, it's very hard to accept anything less.

How to Start Your NeoVim Journey

Start simple. Start humbly.

Use something like kickstart.nvim — a minimalist, thoughtful configuration that gives you a strong foundation without overwhelming you.

Don't rush to install 200 plugins. Don't chase someone's shiny dotfiles.

Instead:

Learn each configuration block.
Understand why each tool is there.
Build your NeoVim the way you'd build your own house: one brick at a time.

And for deeper dives:

The more you walk the path, the more natural it becomes. Trust the process.

Coming Soon

I'm putting together a new article that will explore how to set up an efficient PHP development environment inside NeoVim. It'll cover everything from getting the PHP Language Server running to smart autocompletion, running tests, and even debugging right from your terminal — all without ever needing to leave the comfort of your editor.

If you're working with PHP and have ever dreamed of a more streamlined, enjoyable setup, keep an eye out. This one's for you.

Recommended Channels

Looking to keep learning? Here are a few creators who know what they're doing:

TJ DeVries — NeoVim core developer, excellent technical depth.
ThePrimeagen — Practical advice, high-energy content, and real talk about real workflows.

There are many others too. Find the ones who make you want to open your terminal and start coding.

Appreciation

I want to extend a heartfelt thank you to everyone who contributes to the Vim and NeoVim ecosystems — from developers to documenters, testers to maintainers, advocates to quiet supporters. You are the proof that open source is more than just code; it is vision, persistence, and community. Without your dedication and passion, tools like these would not be possible, and the journey of many developers, including mine, would have been very different.

Final Thought

We don't code for likes. We don't tweak our editors to impress anyone.

We build because it makes us better. Because it sharpens our craft.

Let's keep building — with focus, with respect, and with the freedom to be exactly who we are as developers.

Simplify Many-to-Many Relationships in Yii2 with yii2-m2m-behavior

Jonatas Sas — Tue, 22 Apr 2025 14:22:05 +0000

Managing many-to-many relationships in Yii2 just got a lot easier.

The yii2-m2m-behavior package allows you to assign related models directly using virtual attributes like:

$item->tagIds = [1, 2, 3];

Under the hood, the behavior handles all the syncing through the junction table — no need to manually call link() or unlink().

This means less boilerplate, fewer mistakes, and cleaner code when dealing with junction tables.

🧩 What does it solve?

Automatically links/unlinks models in many-to-many relations
Supports virtual attributes (e.g., tagIds, categoryIds)
Allows saving extra columns in the junction table (e.g., timestamps, flags)
Keeps everything in sync on insert, update, and delete
Uses native Yii2 APIs (link(), unlink(), populateRelation())

📌 Example

class Item extends ActiveRecord
{
    public function behaviors()
    {
        return [
            'tags' => [
                'class' => LinkManyToManyBehavior::class,
                'relation' => 'tags',
                'referenceAttribute' => 'tagIds',
            ],
        ];
    }

    public function getTags()
    {
        return $this->hasMany(Tag::class, ['id' => 'tag_id'])
            ->viaTable('item_tag', ['item_id' => 'id']);
    }
}

Then, just do:

$item->tagIds = [1, 2, 3];
$item->save();

And the junction table will be updated automatically.

Controller + View Example

// Controller
public function actionCreate()
{
    $model = new Item();

    if ($model->load(Yii::$app->request->post()) && $model->save()) {
        return $this->redirect(['view', 'id' => $model->id]);
    }

    return $this->render('create', [
        'model' => $model,
        'availableTags' => ArrayHelper::map(Tag::find()->all(), 'id', 'name'),
    ]);
}

<!-- View (create.php) -->
<?= $form->field($model, 'tagIds')->checkboxList($availableTags) ?>

✅ Quality & Coverage

This package was built with robustness in mind:

100% code coverage with PHPUnit
CI-enforced coverage gate
Every edge case tested, including misconfigured relations and corrupted states
Focused on DX: helpful exception messages and fail-fast behavior

🔍 What’s in version 2.1.0

Version 2.1.0 brings deeper introspection and new tools:

Automatic synchronization even when relations are populated with with() or populateRelation()
isReferenceRelationDirty() method to detect mismatch between relation and reference attribute
computeRelationHash() for internal tracking of changes
Better internal consistency and refactors

⚙️ Requirements

PHP 8.1 to 8.4
Yii2 ~2.0.0

🧭 What’s next?

We’re working on:

Validators for virtual attributes (e.g. tagIds)
Better internal caching and lazy loading
Custom events for hooks before/after sync
Debug tools for inspecting link/unlink actions

🚀 Try it now

composer require jonatas-sas/yii2-m2m-behavior

📚 Full documentation and examples on GitHub

Feedback and contributions are very welcome!