Learn Neovim - AI Code Completion Integration (GitHub Copilot / Codeium / Avante)

#Introduction

After automating editing with autopairs, surround, comment, and which-key in episode 20, in this episode we enter an era that can no longer be avoided in software engineering work: AI coding assistant integration directly inside the editor. We will cover three different approaches — GitHub Copilot (copilot.lua), Codeium (codeium.nvim), and Avante (avante.nvim), which mimics Cursor-style AI chat — complete with workflows, comparisons, and security practices.

Why is this topic crucial in the real world? As a DevOps or Software Engineer, you do not need AI to write code with obvious patterns — boilerplate Kubernetes manifests, monotonous CI/CD scripts, or repetitive test cases. That is where the power of an AI coding assistant lies: it removes predictive and repetitive typing work so you can focus on design decisions that cannot be predicted. But this power comes with responsibility: AI-generated code can contain subtle bugs, security weaknesses, or — worse — leak company secrets if you are not careful about what gets sent to the cloud.

In this episode we will build an integration that is both productive and safe. Let's start with the concept.

#Main Discussion

#The Concept: How Does an AI Coding Assistant Work?

Before choosing a plugin, understand its mechanism. All modern AI coding assistants work in two main modes:

1. Autocomplete (inline suggestion) — the model looks at the code context around the cursor (the current buffer, other open buffers, even related repos) then guesses the next line or block of code. Suggestions are shown as ghost text that can be accepted with a single key.
2. AI Chat (conversational) — you ask in natural language, and the AI gives answers that can be inserted directly into the buffer, or even change several files at once (like Edit mode in Cursor).

What differentiates Neovim from other editors is flexibility: you can choose which plugin to use, set your own keymaps, and adjust behavior without vendor lock-in. Let's look at all three.

#GitHub Copilot: copilot.lua + copilot-cmp

GitHub Copilot is the most mature and widely integrated AI assistant. For Neovim, there are two paths: copilot.vim (GitHub's official Vimscript plugin) and copilot.lua (a feature-richer Lua re-implementation). We will use copilot.lua because it is easier to customize:

return {
  {
    "zbirenbaum/copilot.lua",
    event = "InsertEnter",
    opts = {
      suggestion = { enabled = true, auto_trigger = true },
      panel = { enabled = true },
      filetypes = {
        yaml = false,
        markdown = true,
        help = false,
        gitcommit = true,
      },
    },
  },
  {
    "zbirenbaum/copilot-cmp",
    dependencies = { "zbirenbaum/copilot.lua" },
    config = function()
      require("copilot_cmp").setup()
    end,
  },
}

After that, add keymaps for accepting, rejecting, and navigating suggestions:

local keys = function()
  local cmp = require("cmp")
  local copilot_suggestion = require("copilot.suggestion")
 
  return {
    { "<C-l>", function() copilot_suggestion.accept() end,
      desc = "Accept Copilot suggestion" },
    { "<C-j>", function()
        if cmp.visible() then cmp.select_next_item() end
        copilot_suggestion.next()
      end, desc = "Next Copilot suggestion" },
    { "<C-k>", function()
        copilot_suggestion.prev()
      end, desc = "Previous Copilot suggestion" },
    { "<C-u>", function() copilot_suggestion.dismiss() end,
      desc = "Dismiss Copilot suggestion" },
  }
end

#Using Copilot: Suggestions, Navigation, and Rejection

Once integrated, the workflow is:

1. A suggestion appears automatically when you stop typing (auto_trigger = true). Ghost text appears in a dim color next to the cursor.
2. Ctrl+l accepts the full suggestion.
3. Ctrl+j / Ctrl+k moves to the next/previous alternative suggestion.
4. Ctrl+u cancels the suggestion.

Try writing a clear comment or function name in Go, then watch the suggestion appear. A real example:

// fungsi untuk mengembalikan jumlah elemen dalam slice
func countElements(slice []int) int {
    return len(slice)
}

When you write the comment above, Copilot understands the intent and suggests the return len(slice) implementation. This is an example of pattern-matching that makes it very addictive — and that is exactly where the danger lies: never accept a suggestion without thinking. Every suggestion must be verified like code you wrote yourself.

#The Free Alternative: codeium.nvim

If you do not have a GitHub Copilot subscription (or want an alternative not tied to the GitHub ecosystem), Codeium offers a similar experience with a free account. The codeium.nvim plugin is pure Lua:

return {
  {
    "Exafunction/codeium.nvim",
    dependencies = {
      "nvim-lua/plenary.nvim",
      "hrsh7th/nvim-cmp",
    },
    event = "InsertEnter",
    opts = {
      enable_chat = true,
    },
    config = function(_, opts)
      require("codeium").setup(opts)
      require("cmp").setup({
        sources = { { name = "codeium" } },
      })
    end,
  },
  {
    "monkoose/nvlime",
    event = "VeryLazy",
  },
}

#Cursor-Style AI Chat: avante.nvim

After autocomplete, the next level is inline AI chat that can see buffer context and edit files directly — the experience popularized by Cursor. avante.nvim brings this experience to Neovim. It uses the nvim-treesitter plugin (episode 14), nvim-cmp (episode 16), and plenary:

return {
  {
    "yetone/avante.nvim",
    event = "VeryLazy",
    version = "*",
    build = "make",
    dependencies = {
      "nvim-treesitter/nvim-treesitter",
      "hrsh7th/nvim-cmp",
      "nvim-lua/plenary.nvim",
      "nvim-telescope/telescope.nvim",
      "nvim-treesitter/playground",
      "MunifTanjim/nui.nvim",
      "stevearc/dressing.nvim",
    },
    opts = {
      provider = "copilot",
      hints = { enabled = true },
      windows = {
        position = "right",
        width = 0.5,
      },
      file_selector = { provider = "telescope" },
    },
  },
}

Avante supports several model providers: openai, claude, copilot, gemini, and ollama (for local models). The example above uses copilot as the provider so you do not need to set up an extra API key — as long as you are logged into Copilot.

The workflow looks like this:

1. Select a few lines of code in visual mode, press Ctrl+i to start an inline prompt next to the selection.
2. Type an instruction, e.g. "refactor this function to return an error as the second return value".
3. Avante shows a diff of the proposed changes. You can accept, reject, or iterate until the result is right.

vim.keymap.set("n", "<leader>aa", function()
  vim.cmd("AvanteAsk")
end, { desc = "Avante: Ask" })
 
vim.keymap.set("n", "<leader>ae", function()
  vim.cmd("AvanteEdit")
end, { desc = "Avante: Edit selected" })
 
vim.keymap.set("v", "<leader>ae", function()
  vim.cmd("AvanteEdit")
end, { desc = "Avante: Edit selection" })
 
vim.keymap.set("n", "<leader>at", function()
  vim.cmd("AvanteToggle")
end, { desc = "Avante: Toggle chat" })

#The Complete AI Workflow in Neovim

Let's string it together into a daily workflow:

#Tool Comparison

#AI Best Practices & Security in Codebases

This is the part most often overlooked, and the most important for a professional engineer:

#Common Pitfalls

#Closing

In episode 21 we integrated three AI coding assistant approaches into Neovim: GitHub Copilot for autocomplete with complete suggestion navigation keymaps, Codeium as the freemium alternative, and Avante for Cursor-style AI chat with direct editing capabilities. We also discussed a healthy AI workflow — from accepting suggestions, reviewing with git diff, to writing tests — along with non-negotiable security practices: never paste secrets into AI, and always review AI-generated code before committing.

Remember your position in the chain: AI is the co-pilot, not the pilot. The ship is still steered by you.

Now that the editor can write code quickly with AI assistance, we need the opposite ability: finding and fixing bugs correctly. In episode 22, we will cover Debugging with DAP (Debug Adapter Protocol) using nvim-dap and nvim-dap-ui — turning Neovim into an interactive debugger on par with GUI IDEs. Stay motivated!