CodeCompanion vs Avante

[einarpersson]

Hi! I'm trying to decide between CodeCompanion and Avante.

How do these compare? Are they pretty much doing the same thing, and how do they differ? Eg. Philosophy?

Among things I value are

• extensibility and customization
• longevity (one lone contributor? How big community?)
• embracing existing and emerging standards (eg. MCP)
• Quality of software
• Welcoming / friendly community

And of course a nice UX/DX ;)

Any notable features / design differences as you know of?

---

Edit: of course ultimately I have to try both out myself but it would be interesting to get any comments anyway.

I suppose one thing that speaks for avante is the simple fact that it has a lot more stars here on Github. But I think CodeCompanion looks nice at first glance and the main dev seem active (and interacting with other devs in the ecosystem) it seems.

Some other differences I noted myself

• CodeCompanion seems to have much better docs
• The authors seems to employ different strategies for managing incoming issues (1 open for CC vs 203 open for Avante).

[caesar-ipl]

For me, as stated in the README.md of both plugins, the experience of codecompanion is like Zed AI, while avante is like Cursor. I think it depends on one taste, I try them both and decide to use codecompanion.

[pratyushmittal]

I started with Avante. But Avante has become too loaded, heavy and hard to use now. There is just no documentation. Everything is complex there.

I love CodeCompanion for its documentation and simplicity: https://codecompanion.olimorris.dev

The clarity in thinking and simplicity shows in everything that @olimorris does.

[pratyushmittal]

@alkeryn CodeCompanion definitely makes it much more easier and reduces errors.

Plus, I love the custom prompt library feature: https://codecompanion.olimorris.dev/configuration/prompt-library.html

It is very underrated and unpopular, but very powerful.

For example I have these:

local PROMPT_LIBRARY = {
  ['Improve Copy'] = {
    strategy = 'inline',
    description = 'Improves the copy of the page',
    -- opts = {
    --   mapping = '<LocalLeader>ch',
    -- },
    prompts = {
      {
        role = 'system',
        content = [[You are an experienced developer, designer and creator. Your build useful products that people love to use. Your task is to improve the copy of the content to bring more clarity and improve conversions.]],
      },
      {
        role = 'user',
        content = '#buffer\n\nPlease improve the copy of the page.',
      },
    },
  },
  ['Review the code'] = {
    strategy = 'inline',
    description = 'Review the code in buffer',
    -- opts = {
    --   mapping = '<LocalLeader>ch',
    -- },
    prompts = {
      {
        role = 'system',
        content = [[You are an experienced senior developer. You do code reviews.]],
      },
      {
        role = 'user',
        content = '#buffer\n\nPlease review the code in the file and make the fixes if any.',
      },
    },
  },
}

Now I select the code I am working on and ask it to review the selected code quickly. It often fixes many small things. We can create such simple prompts, save them and then access then in single key press. This is super useful.

@olimorris is a genius to have thought through all of these.

[TheLazyCat00]

I have a very bad experience with avante. It's buggy and it doesn't work with copilot. There was an open issue regarding the problems with copilot and avante and yetone (the maintainer) made a PR and blindly closed the issue even though his PR didn't resolve the problem. So after I tried making him re-open the issue again, I created a new issue regarding the same problem since he wouldn't respond (this issue is still a thing btw). Theres also UI bugs etc etc. Also important to note: Avante only allows you to edit buffers, so no conversations. Codecompanion on the other hand is way more flexible and I like it better because of its modular approach (with slash commands and @ "profiles").

[olimorris]

Sorry I never replied to this, I didn't think it was fair for myself to comment as I only know CodeCompanion and haven't tried Avante much beyond just some testing, maybe 9 months ago. I know chunks of CodeCompanion code, about a year ago, were used in their plugin and I had to ask to get credit in their README.

I should be more explicit about my vision for CodeCompanion. I see it as a tool which enables Neovim developers to write high performant code as efficiently as possible. That's why you'll often see me be quite bullish with user's requested enhancements. I'll always prioritise bug fixes first and productivity boosting enhancement after that. If it won't move the needle of productivity then I'm not interested. But...reliability, backed up with good test coverage is a non-negotiable for me and I've put as much effort into writing tests in the last few months as I have adding features - I'd badly performed against one of my own personal pillars 😆.

Regarding the future, I keep my roadmap in a notes file and the todo list of features is ridiculous. I have so many ideas, most of which come from this awesome community so I'm very excited about where we'll be in the next 6 months. Vision support next and then multi-model chats in the chat buffer. I like workspaces but I think a move to something akin to .cursorrules is where we should move to. Lot's to do and I'm going to boost the CONTRIBUTING.md guide after #1141 to ensure the community can more easily add features too.

[einarpersson]

thank you! I really want to emphasize that I highly value the welcoming and friendly tone. I hope to be able to contribute in some ways along the way.

[gitsang]

The following represents only my personal opinion. Some of my criticisms may stem from my own lack of ability, and my evaluations are based solely on my experiences. That said, I still use both plugins and have assigned them two very important shortcuts: aa for Avante and cc for CodeCompanion. I am very grateful to both plugin authors for their contributions to saving my life.

Features

Avante is very quick to add new features (I have to admit that in many cases, Avante's development speed far surpasses CodeCompanion's. For example, the auto-commit feature wasn't supported in CodeCompanion until v16.1.0 , whereas Avante had implemented it in a much earlier version. This might be one reason why Avante has more stars). However, this has made Avante bloated.

And some particularly frustrating issues often take a long time to be fixed.
For instance, when context exceeds a certain limit, Avante will freeze and become almost unusable (I don’t know if this bug has been fixed yet, and I can’t find the original issue, but at the time, this problem made me abandon Avante).

Additionally, I’d like to say that Avante is very cool but not particularly user-friendly. I’ve contributed code to both plugins (though I can hardly claim to know Lua). One of my contributions to Avante also involves Secrets logic, which is similar to what Oli mentioned—Avante's use of CodeCompanion's code. In my opinion, olimorris is much more cautious about new features than yetone. This might be a disadvantage for CodeCompanion, as it could take longer to solve problems, but I believe it will be beneficial in the long run.

Code

Speaking of code, as an amateur developer (I only started learning Lua a few months ago), I can clearly feel that modifying CodeCompanion is much easier than modifying Avante. When working on Avante, I often felt a sense of powerlessness—like Pull one hair and the whole body moves (a chain reaction). Every time I tried to fix one issue, I’d introduce another. Even using AI couldn’t help me solve it.

Philosophy

I think olimorris’s philosophy of bug fixes first is correct: “A complex, stable system must evolve from a simple, stable one.” This is also my belief. That’s why I have higher expectations for CodeCompanion.

Documentation

Documentation is another crucial factor. In terms of quick starts, Avante does have an advantage—just a few simple configurations, and you can expect magic to happen. But once you dive deeper, progress becomes difficult. CodeCompanion is also simple, but its well-organized documentation makes customization much easier. With the help of AI, I effortlessly customized a workflow for CodeCompanion: https://github.com/gitsang/lazyvim/tree/main/lua/plugins/codecompanion .

And Avante’s release notes always frustrate me: https://github.com/yetone/avante.nvim/releases . I can’t tell what was actually updated in each version from the release info. CodeCompanion does this much better: https://github.com/olimorris/codecompanion.nvim/releases . It even adds eye-catching icons for BREAKING CHANGES.

Installation

I’m not entirely sure what Avante does, but every time I update it, I have to re-download some artifacts. This means each plugin update takes longer, and when I modify Avante’s source code for testing, the repeated downloads become quite annoying. In contrast, CodeCompanion only requires pulling the code.