Continue

Open-source AI coding assistant and PR quality gate, honestly reviewed. No marketing fluff, just what you get when you self-host it.

TL;DR

• What it is: Continue is an Apache-2.0 open-source project that started as a VS Code extension (think GitHub Copilot, but bring-your-own-model) and has since expanded into a CI-native PR checking tool — agents running as GitHub status checks on every pull request [1][website].
• Who it’s for: Developers and engineering teams who want Copilot-style coding assistance without model lock-in, or teams who want automated, opinionated quality gates on PRs that don’t rely on a proprietary reviewer [1][2][website].
• Cost savings: GitHub Copilot runs $19/month per developer. Cursor runs $20/month. Continue’s IDE extension self-hosted costs $0 — you bring your own API keys or run a local model via Ollama [1][2]. The PR checking cloud tier runs $3/million tokens, which for a small team reviewing PRs costs a fraction of a per-seat SaaS subscription.
• Key strength: Model flexibility and genuine privacy. Every major provider (OpenAI, Anthropic, Mistral) plus fully local inference via Ollama, all from the same extension. Your code doesn’t leave your network unless you explicitly point it at a cloud API [1][2].
• Key weakness: The product has pivoted significantly — the current marketing and README are almost entirely focused on CI/PR checking, while the IDE extension that built its 31,916 GitHub stars is now a secondary mention. The learning curve is real: 2–3 weeks to configure it the way you want [1]. Polished UI isn’t the priority.

---

What is Continue

Continue is two things at once, and it’s worth being clear about which one you’re evaluating.

The IDE extension (how most people found it): A VS Code plugin that works like GitHub Copilot — chat, inline suggestions, multi-file editing — but wired to any model you choose. OpenAI, Claude, Mistral, CodeLlama, or a locally running Ollama instance. The config lives in .continue/config.json in your repo, which means your team’s AI setup is version-controlled and reproducible [1][2]. As of the November 2025 reviews it had crossed 26,000 GitHub stars; it now sits at 31,916.

The CI checking tool (where the company is going): Checks are markdown files you commit to .continue/checks/ in your repo. On every pull request, Continue runs those checks as GitHub status checks and returns green/red with a suggested diff. The README example shows a security review agent that looks for hardcoded secrets, validates API endpoint input handling, and checks error response formatting [website][README]. This is the product the current homepage leads with: “Quality control for your software factory.”

The company — Continue Dev, Inc., Apache-licensed since 2023 — describes the CI product as “the opposite of generic AI review.” The pitch is that you define what the agent checks for, and it only catches what you told it to catch. No unsolicited opinions. That’s an honest positioning: it’s a linter that speaks natural language, not an autonomous code reviewer with opinions about your architecture.

---

Why people choose it

The articles we have are both from November 2025 and focus entirely on the IDE extension, not the CI checker — which is itself a signal that the CI product is newer territory.

Versus GitHub Copilot. Alex Carter’s three-week trial [1] makes the case plainly: Copilot locks you into Microsoft’s model choices and pricing. Continue works with the same models (GPT-4, Claude) but also lets you run Mistral or CodeLlama locally via Ollama for zero marginal cost. The auditable open-source code is the other differentiator he cites — you can read exactly what’s being sent where, which matters when the code being sent is proprietary.

Versus Cursor. Carter puts Continue and Cursor in the same “next-gen AI coding assistant” bucket and notes that Continue trades the polished UI for flexibility and privacy. Cursor’s “Agent Mode” is similar in capability to Continue’s, but Cursor is a closed-source, proprietary app at $20/month per developer [1]. Continue’s equivalent costs $0 if you self-host with your own API keys. The trade-off: Cursor is easier to get started with, and the experience feels more integrated. Continue requires configuration investment upfront.

For local inference, specifically. Manikandan Mariappan’s tutorial [2] is effectively a how-to for the privacy-maximalist use case: VS Code + Continue + Ollama, nothing leaves your machine. The minimum hardware requirement is 8GB RAM (16GB recommended), which is any modern laptop. The models he runs — Mistral, Llama 3, CodeLlama — are legitimately useful for code tasks at that RAM level. The hybrid approach he documents (local model for most tasks, cloud fallback for complex reasoning) is worth noting: you get the privacy of local inference most of the time, without giving up GPT-4 when you need it [2].

For team standardization. The CI checking product pitch addresses a different pain: code review quality degrades as teams scale because reviewers focus on different things. Codifying checks as markdown files in your repo gives you reproducible, enforceable standards that run on every PR — not dependent on whoever happens to review that day [website].

---

Features

IDE extension:

• Chat mode for contextual code guidance and Q&A [1]
• Plan mode — read-only sandbox for exploring refactors before touching files [1]
• Agent mode — autonomous multi-file operations (Carter’s example: converting React components across 80+ files in four days, compared to an estimated three weeks manually) [1]
• Model switching mid-session between providers and local models [2]
• Per-repo config via .continue/config.json and rules via .continue/rules/ directory [1][2]
• Multi-model support with instant switching (Llama 3, Mistral, CodeLlama, GPT-4, Claude) [2]
• Works with VS Code; a separate Windows installer is documented [website]

CI/PR checking tool:

• Checks defined as markdown files committed to .continue/checks/ [README]
• Runs as native GitHub status checks on every pull request [website][README]
• Returns suggested diffs, not just pass/fail comments [README]
• CLI (cn) installable via curl, PowerShell, or npm (requires Node.js 20+) [README]
• Integrations mentioned on the pricing page: Slack, Sentry, Snyk, Linear [website/pricing]

What’s notably absent in current documentation:

• The README has minimal detail on the IDE extension, redirecting to a subdirectory [README]
• REST API is listed as a canonical feature in the product profile but isn’t documented in any article or the current README

---

Pricing: SaaS vs self-hosted math

Continue Cloud:

• Starter: $3/million tokens (input + output combined, pay as you go). Includes agents, integrations, frontier model access via credits [pricing].
• Team: $20/seat/month, includes $10 in credits per seat. Adds shared private agents, team management, Gmail/GitHub SSO [pricing].
• Company: Custom pricing. Adds SAML/OIDC SSO, bring-your-own-API-keys (BYOK), SLAs [pricing].

Self-hosted (IDE extension + CLI):

• Software: $0 (Apache 2.0)
• Model cost: whatever your API provider charges, or $0 for local Ollama inference [1][2]
• Infrastructure: a laptop or any machine that can run Ollama

Competitor pricing for comparison:

• GitHub Copilot Individual: $19/month [1]
• Cursor Pro: $20/month [1]
• Cursor Team: $16/seat/month

Concrete math for a 10-person engineering team:

Running Continue IDE extension self-hosted with Ollama for most tasks and Claude API keys for complex reasoning: roughly $20–50/month total in API costs depending on usage, zero seat fees. GitHub Copilot Business for the same team: $190/month. Cursor Team: $160/month.

The Continue Cloud Team tier at $20/seat would run $200/month for 10 developers — but $100 of that is included as credits, so net cash cost is closer to $100/month plus whatever API overage you incur.

For the CI checking specifically: at $3/million tokens, a team doing 50 PRs/day with checks that consume ~10,000 tokens each comes to about $1.50/day or roughly $45/month. Data not available on how this compares to running the CLI entirely self-hosted against your own API keys, but the BYOK option on the Company tier suggests that path exists.

---

Deployment reality check

IDE extension path (the mature one): Install from the VS Code marketplace, create .continue/config.json, point it at a model. For Ollama local inference: install Ollama separately, pull a model (e.g. ollama pull mistral), point Continue at http://localhost:11434 [2]. Total time for a developer who has done this before: 30 minutes. First-timers following Mariappan’s tutorial [2]: about two hours including troubleshooting.

Hardware requirement for local models: 8GB RAM minimum, 16GB recommended [2]. This is the threshold where models become usably fast. Below that, expect response latency that makes the tool more frustrating than useful.

The 2–3 week learning curve Carter mentions [1] isn’t about installation — it’s about configuring the tool to your workflow. The rules system, the model routing, deciding which tasks go local versus cloud — this takes iteration. The UI is functional but deliberately minimal compared to Cursor’s more opinionated experience.

CI checking path (the newer one): Install the cn CLI, write your first .continue/checks/*.md file, wire up the GitHub Action. The README’s install is a single curl command. The check format is YAML frontmatter + markdown prose — genuinely readable by non-engineers. What’s not yet clear from public documentation: how you handle authentication, secret management, and rate limiting in CI at scale. The product feels early in its surface area here.

What can go wrong:

• Local model quality degrades fast below 8GB RAM [2]. If team members have underpowered laptops, the local-first strategy breaks.
• The .continue/config.json in-repo pattern is good for reproducibility but means model API keys need to be handled carefully — don’t commit them, use environment variables or secret managers.
• The product has visibly pivoted its positioning mid-flight. The IDE extension documentation is thinner than you’d expect for a tool this popular, because the company’s attention has shifted [README][website]. Existing users have institutional knowledge; new users have less to work from.

---

Pros and Cons

Pros

• Apache 2.0 license. Not “source available,” not Fair-code, not commercial restrictions. MIT/Apache-level permissiveness means you can fork it, embed it, modify it without calling a lawyer [README].
• Genuine model flexibility. Every major cloud provider plus local Ollama inference from the same tool. This is rare — most AI coding tools lock you to one provider [1][2].
• Privacy-maximalist path exists. With Ollama locally, your code never leaves your machine. For enterprises with IP concerns, this changes the security conversation entirely [1][2].
• Agent mode is genuinely capable. Carter’s four-day vs. three-week anecdote for an 80+ file refactor [1] is specific enough to be credible, and matches what the mode description promises.
• Config as code. Team AI setup in a committed JSON file means reproducibility and auditability [1][2].
• CI checking is a differentiated idea. Standards-as-markdown that run as GitHub status checks is a concrete, useful product concept with no direct open-source equivalent.
• 31,916 GitHub stars, Apache 2.0, active development. Not an abandoned project.

Cons

• Product identity is in flux. The tool that built its reputation as a Copilot alternative is now being repositioned around PR checking. The IDE extension documentation is thin relative to the tool’s maturity [README][website]. If you’re evaluating this today, clarify which product you’re actually buying.
• 2–3 week setup investment. Carter explicitly flags this [1]. The flexibility that makes it powerful also means there’s no one right way to configure it, and you’ll iterate.
• UI is not the priority. Compared to Cursor’s polished experience, Continue’s extension is functional and developer-first [1]. If your team’s AI adoption depends on a low-friction first experience, this matters.
• CI checking is early. The README is minimal. The integration documentation for scaling checks across a large team isn’t public yet. Buying into the CI product today means some pioneering.
• Local models require hardware. The 8GB RAM floor is a real constraint. Teams with mixed laptop specs will have inconsistent experiences [2].
• No dedicated community review corpus. The only third-party reviews available for this article are from November 2025 and focus on the IDE extension. The CI checking product has no independent reviews to draw from — which itself is a data point about how new it is.

---

Who should use this / who shouldn’t

Use Continue if:

• You want Copilot-level IDE assistance without Copilot’s per-seat pricing or model lock-in.
• Your team has IP sensitivity and wants code to stay on-premises — the Ollama path covers this completely [1][2].
• You’re a developer comfortable configuring tools in JSON and spending a few weeks dialing in the workflow [1].
• You want to enforce engineering standards on PRs as code-reviewable markdown files, not as ad-hoc comments from whoever is reviewing that day.
• You’re an engineering team of 5–50 that already manages API keys and wants to consolidate AI tooling cost under one Apache-licensed tool.

Skip it (use GitHub Copilot instead) if:

• Your team needs zero-config onboarding. Copilot is ready in minutes; Continue requires real setup investment [1].
• You want Microsoft’s enterprise SLA, SSO integration, and the comfort of a vendor with an explicit support contract.
• Most of your developers use JetBrains IDEs — Continue’s primary surface is VS Code.

Skip it (use Cursor instead) if:

• You prioritize UI polish and an opinionated, integrated experience over model flexibility [1].
• You don’t need privacy guarantees and are happy to pay $20/month per developer for a better out-of-the-box experience.

Skip it (build on raw API instead) if:

• You want the CI checking concept but need more control than a hosted product provides. The cn CLI is open source — you can run it entirely self-hosted against your own API keys without touching Continue Cloud at all [README].

---

Alternatives worth considering

• GitHub Copilot — the incumbent IDE assistant. Tightest GitHub integration, best general polish, $19/month per user, closed source, no model choice.
• Cursor — the current darling of AI coding tools. Opinionated, fast, full IDE (not just an extension), $20/month, proprietary.
• Codeium / Windsurf — free tier is generous, proprietary, enterprise offering.
• Aider — terminal-based AI coding assistant, Apache 2.0, model-agnostic. More powerful for engineers comfortable in the terminal; no IDE plugin.
• Cody (Sourcegraph) — enterprise AI coding assistant, can self-host, understands large codebases via code search index. More relevant for orgs with big monorepos.
• CodeRabbit — for the CI/PR checking use case specifically. Mature, proprietary, AI-native PR review with more surface area than Continue’s current CI product. $15/seat/month.
• Reviewpad — another code review automation tool, integrates with GitHub, more established in the standards-enforcement-on-PRs space.

For a non-technical founder the realistic shortlist for the IDE use case is Continue vs GitHub Copilot vs Cursor. The Continue path saves $19–20/month per developer and adds privacy — at the cost of configuration work upfront.

---

Bottom line

Continue is doing two things simultaneously: defending its position as the model-agnostic Copilot alternative for privacy-conscious developers, and staking out a new position as the CI-native quality gate that lives in your repo as markdown. The first product is proven — 31,916 stars, active usage, a documented path from install to working local inference in under two hours [1][2]. The second is early, with thin documentation and no independent reviews yet.

The Apache 2.0 license is the thread that holds both together. You can self-host the CLI, bring your own API keys, commit your checks as code, and owe the vendor nothing. That’s a rare combination in a space where the default is per-seat SaaS that can raise prices whenever it wants. The trade-off is real: less polish, more configuration, a product that’s mid-pivot and still finding its documentation. For developers who value model flexibility and data control over UI convenience, the math is clear. For teams that want something working in an afternoon without configuration, Copilot or Cursor is the honest answer.

---

Sources

1. Alex Carter, Medium — “Continue.dev: The AI Coding Assistant That Actually Respects Your Choices” (November 13, 2025). https://medium.com/@info.booststash/continue-dev-the-ai-coding-assistant-that-actually-respects-your-choices-1960b08e296a

2. Manikandan Mariappan, dev.to — “How to Use AI Models Locally in VS Code with the Continue Plugin (with Multi-Model Switching Support)” (November 11, 2025). https://dev.to/manikandan/how-to-use-ai-models-locally-in-vs-code-with-the-continue-plugin-with-multi-model-switching-3na0

Primary sources:

• GitHub repository and README: https://github.com/continuedev/continue (31,916 stars, Apache 2.0 license)
• Official website: https://continue.dev
• Pricing page: https://continue.dev/pricing