what it actually isAn IDE assistant that respects your choices — and your model.
Continue.dev is a VS Code and JetBrains extension, not a fork of your editor. Its whole identity is no vendor lock-in: you point it at any LLM provider, including local models via Ollama or LM Studio, so on proprietary or air-gapped codebases your code never leaves the machine. It builds a semantic index so the model can reason across files, it has an Agent Mode for multi-file refactors, and it's free for solo developers, ~$10/dev for teams. For privacy-conscious engineers who want to own every detail of the setup, it's the strongest option there is. That is a real, earned compliment — and it tells you exactly who it's for: a developer, sitting in an IDE.
- Bring your own model — GPT, Claude, Gemini, or fully local Ollama / LM Studio.
- Open-source, no lock-in, runnable air-gapped for sensitive codebases.
- Agent Mode handles large multi-file refactors; semantic index gives cross-file context.
the 2025 pivot'Continuous AI' is the right instinct — Checks as version-controlled rules.
The most interesting thing Continue did in 2025 was stop being only an autocomplete and become a CI layer. Every pull request triggers AI agents that run predefined Checks — review rules written in Markdown, stored in the Git repo, version-controlled and repeatable. Their own framing nails the principle: 'CI/CD shifted blame from people to process; AI code quality needs the same shift — systematic checks, not individual vigilance.' We agree completely. That is the correct diagnosis of why vibe coding breaks in companies: nobody can rely on individual vigilance to catch what a model ships. The disagreement isn't about the idea. It's about how far the structure goes.
- Checks are Markdown rules in your repo — versioned, reviewable, repeatable.
- Agents run on every PR, not as a one-off prompt — review at scale.
- The thesis is right: governance should be process, not vigilance.
where the line isAssist reviews a pull request. Governance produces one you can trust.
Here's the gap. Continue's Checks run AI review on a PR a human (or its own agent) already opened — they advise, flag, comment. They are still review, sitting downstream of code that was generated freehand, and the gate is probabilistic: an AI judging AI. That's better than nothing, far better. But 'assist' assumes a developer is in the loop to read the diff, weigh the suggestion, and decide. Take the developer out — give the keyboard to a founder, a PM, a product owner — and an assistant has nobody to assist. The diff goes to someone who can't grade it. AI reviewing AI with no deterministic floor is exactly how the unreviewable sprawl accumulates, just faster.
- Checks advise on a PR; they don't constrain what the agent was allowed to write.
- AI-judges-AI is probabilistic — useful, but not a floor you can stake production on.
- Built for a developer in the loop; weakest precisely when there isn't one.
the method that closes itThe Digital Native Method: encode the rules once, gate before prod.
The fix isn't more assist — it's structure. In the Digital Native Method, a Product Owner describes the intention on the live product, a Tech Lead encodes the rules once (architecture, conventions, security, your company's standards), and agents boot inside those rules — they can't write outside them in the first place. Then deterministic gates — lint, types, tests, security, secrets scan — run before anything reaches production. Not an AI opining on a diff: a build that is green or it doesn't land. Everything ships through your own GitHub, on the AI plan you already pay for. Continue gives a developer a faster, well-reviewed loop. The Method gives a non-developer a loop where the structure is the reviewer, every single time.
- Tech Lead encodes standards once; every agent is born inside them.
- Deterministic gates (lint, types, tests, security) — not AI vibes — gate prod.
- Ships through your GitHub; you don't have to be the safety net.
method needs softwareAgentation is the software that makes the Method real.
A method on a slide changes nothing. Agentation is the product that runs it: you point at your live product, describe the outcome you want, and a per-project Lead Agent dispatches workers in isolated git worktrees. The CheckGate runs every deterministic check before work reaches review; a PrePushGate adds commit-convention, secrets and lock-file checks before any push or PR. You stay in outcome-space; the structure handles the code below your line of sight. Where Continue is an excellent tool you operate as an engineer, Agentation is the operating structure for people whose job is the product, not the implementation — and it's new, built for exactly this moment.
- A Lead Agent dispatches workers in isolated worktrees — no freehand sprawl.
- CheckGate + PrePushGate verify deterministically before review and before push.
- You describe results; the structure produces governed, reviewed, shippable code.
cocoricoAnd it's French: sovereign on the tools, if not the models.
Agentation is built by a French team, and that matters for where this is going. We're honest: nobody in Europe is sovereign on the frontier models — Claude and GPT are American. But the model is a fraction of the system; with raw models alone you don't ship much. The sovereignty that's actually winnable is on the orchestration — the software that wraps, governs and ships those models — and that's a huge part of the value. Agentation runs on EU infrastructure (Hetzner, Germany), data lives in the EU (Supabase), your code stays in your GitHub, and the whole thing is GDPR-aligned by design. Continue's air-gapped, BYO-model story is genuinely strong on privacy; the French angle here is the same instinct taken up a level — sovereignty over the structure that turns models into shipped software.
- Built by a French team; EU hosting (Hetzner) and EU data (Supabase).
- Sovereignty on the orchestration layer — the part you can actually own.
- Your code stays in your GitHub; GDPR-aligned by design.
FAQIs Continue.dev good? Should I use it?
If you're a developer who wants an open-source, no-lock-in assistant with bring-your-own-model (including fully local Ollama for air-gapped work), Continue.dev is the strongest option in that category — flexible, private, and free for solo use. The caveat is who it's for: it assists a developer in an IDE. It's not a structure for a non-developer to ship production software safely on their own.
What's the difference between Continue's PR Checks and Agentation's gates?
Continue's Checks are AI agents reviewing a pull request — probabilistic, advisory, and downstream of freehand-generated code. Agentation's gates are deterministic (lint, types, tests, security, secrets) and run before code reaches review and before any push: green or it doesn't land. One is AI judging AI; the other is a build that can't be argued with. Both come after a Tech Lead has encoded the rules agents must work inside.
Continue.dev was acquired by Cursor — does it still make sense?
In 2026 Continue was acquired by Cursor and the original repo went read-only with v2.0.0 as the final release from that team. The open-source code is still usable, but the independent roadmap is over — worth weighing if you were betting on the open, model-agnostic direction long-term. Agentation is independent and French, with EU hosting and your code in your own GitHub, so the orchestration layer isn't tied to one vendor's outcome.
Can a non-developer ship production software with Continue.dev?
Not really — and that's not a knock, it's just the design. Continue assists someone who can read a diff, judge a suggestion, and decide. Hand the keyboard to a founder, PM or product owner and an assistant has nobody to assist; the output still lands on someone who can't grade it. The Digital Native Method, run by Agentation, replaces that missing judgement with a Tech Lead's encoded rules and deterministic gates, so the structure is the reviewer.
Is Continue.dev private and GDPR-friendly?
On privacy, yes — its air-gapped, local-model option means code can stay entirely on your machine, which is a real strength for sensitive work. Agentation takes the same instinct to the orchestration level: EU infrastructure (Hetzner, Germany), EU data (Supabase), code in your own GitHub, GDPR-aligned by design. We're a French team and believe the winnable sovereignty is on the tools that govern the models, not the models themselves.