Cody

Overview

Cody is the AI coding assistant from Sourcegraph, built on the premise that the most useful AI answers are the ones grounded in your actual codebase rather than in a model’s training data. It plugs into VS Code and JetBrains IDEs and answers questions, writes code, and explains implementation by reading your repositories directly. You can find it at https://sourcegraph.com/cody.

In our evaluation, Cody’s edge is whole-repo context. Sourcegraph’s code intelligence means Cody can cite the exact file and function a behavior lives in, which turns “where does this happen?” from a grep expedition into a one-line answer. That makes it especially strong on large monorepos where simpler copilots guess blindly. It is also model-agnostic — you can run it on multiple LLM providers — which appeals to teams that want to swap models without changing tools. The cost of that power is a heavier setup than a simple plugin, and the best value shows up when it is paired with the Sourcegraph backend.

Key Features

• Codebase-aware chat — Cody answers with citations into your repo, pointing to the real locations of functions and types. In our evaluation this grounding is what separates it from chat assistants that answer from general knowledge.
• Autocomplete across files — It suggests completions informed by the wider project, not just the open file, which reduces the boilerplate you write by hand. We found it noticeably more context-rich than a plain inline copilot on large codebases.
• Multi-provider LLM support — Run Cody on several leading models and switch per task, so you are never locked to one vendor’s strengths and weaknesses. Our evaluation suggests treating model choice as a per-job decision.
• VS Code and JetBrains plugins — Native extensions keep the experience inside the IDE you already use, with chat, commands, and completions wired into the editor. The dimension that matters is zero new environment to learn.
• Sourcegraph-backed indexing — When connected to Sourcegraph, Cody gains deep cross-repo understanding that free-standing assistants lack. This is where we saw the biggest leap in answer quality on monorepos.

Pricing

Pricing is subject to change. Check the official website for current plans and regional discounts. Free tiers often have usage limits — evaluate whether those limits match your expected volume before committing.

The Free tier is usable for individuals, but the meaningful difference appears at Pro, where limits rise and model choice widens. In our evaluation the Enterprise plan — with the Sourcegraph backend — is where Cody becomes a different product, because the whole-repo indexing is what justifies the “codebase-aware” claim. Teams should weigh the heavier setup against the value of answers that cite real code locations across many repositories.

How It Compares

vs. GitHub Copilot: Copilot is inline and invisible; Cody is context-deep and citation-driven. On the specific dimension of large-monorepo grounding, Cody wins because it reads the repo through Sourcegraph; Copilot wins on typing friction. Our evaluation: Cody for “where and why,” Copilot for “what next line.”

vs. Cursor: Cursor’s agent edits across files autonomously, while Cody is stronger at answering and citing within a big codebase. The dimension that matters is autonomy vs. grounding: Cursor acts, Cody explains and writes with citations. We reach for Cody when we need to understand before we change.

vs. Codeium: Both autocomplete broadly, but Cody’s Sourcegraph grounding gives it an edge on enormous codebases, whereas Codeium is lighter and freer to install. Our evaluation favors Cody for monorepos and Codeium for quick, editor-agnostic completion.

Getting Started

• Connect Cody to your most important repository first, so the context it indexes is the code you actually work in.
• Ask it to point to the exact file and function when you have a “where does this live?” question — citations are Cody’s real advantage over a general chat.
• Start with explanation and search tasks before delegating edits, building trust on lower-risk reads.
• Pick a model per task; in our evaluation reasoning-heavy questions benefit from a stronger model while completions can use a faster one.
• Use the VS Code or JetBrains plugin so the chat stays in your editor rather than a separate window.
• If you are on a large org, evaluate the Sourcegraph-backed Enterprise plan before judging Cody — the free tier understates it.
• Keep diffs reviewed and commits clean, because cited-but-wrong suggestions still need a human eye.

Hands-on Verdict

Cody is the assistant we use when answers must be grounded in a large codebase — it reads your repos and cites where the code lives, which skips the grep rabbit hole. In our evaluation it is more code-aware than GitHub Copilot on context and tighter than Codeium for big monorepos, while remaining lighter than a full agent for understanding work. For chat-style edits that span files, Cursor still leads.

The honest caveat is setup weight and the Sourcegraph dependency for peak value. Our verdict: engineers on large or multi-repo codebases get the most from Cody, especially when they ask for citations rather than vague help. Treat it as a research and writing partner wired to your code, and pair it with an agent like Aider or Windsurf when you need autonomous multi-file changes.