An honest, iOS-focused review of Continue — the open-source AI code assistant for VS Code and JetBrains. Features, strengths, real limitations, and who should use it for Swift work.
Continue is an open-source AI code assistant that plugs into your editor instead of replacing it. It ships as an extension for VS Code and JetBrains IDEs, and it connects to whatever models and providers you choose.
That last point is the heart of the tool. Continue is not locked to a single AI vendor, so you can wire it up to hosted frontier models, to cheaper commodity models, or to a model running entirely on your own machine.
Because the project is open source, the code lives on GitHub for anyone to read, fork, or contribute to. You are not paying Continue for a license — you bring your own model access and pay whichever provider you pick.
For iOS developers, the practical takeaway is simple. Continue is a flexible AI layer you add on top of a normal Swift workflow, and it hands you control over which model gets to read your code.
It helps to be clear-eyed about where Continue sits in an Apple toolchain. Continue is an editor extension, not an IDE, and it does not build, sign, or ship your app.
Many iOS engineers write Swift, edit configuration, and do package or scripting work in VS Code, then jump to Xcode for compiling, Interface Builder, simulators, provisioning, and App Store submission. Continue slots into that first half.
You can open a Swift file in VS Code, ask Continue to explain a tricky closure, generate a SwiftUI view, or draft unit tests, all without leaving the editor. When it is time to actually run the app on a device, you switch to Xcode.
So think of Continue as an AI assistant for the writing-and-reasoning part of Swift development. The Apple-specific machinery — builds, code signing, TestFlight, and release — stays firmly inside Xcode and the Apple Developer Program.
Continue centers on three capabilities that map neatly onto everyday coding. The first is autocomplete, which offers inline suggestions as you type, similar in spirit to other AI completion tools.
The second is chat. You can highlight a block of Swift, ask a question, and get an explanation or a rewrite in a side panel, with your selected code as context.
The third is agent-style functionality, where the assistant can take on larger, multi-step tasks across your project rather than a single snippet. This is useful for refactors that touch several files.
Because each of these can be pointed at a different model, you get real flexibility. You might use a fast local model for autocomplete and a stronger hosted model for chat and agent work, tuning cost and latency to the job in front of you.
The standout strength is model choice. Being able to swap providers — including local models — means you are not hostage to one company's pricing, availability, or data policy.
That matters for teams with privacy or compliance requirements. Running a local model through Continue keeps proprietary Swift code on your own hardware, which is hard to achieve with closed cloud-only assistants.
Open source is the second strength. You can inspect exactly what the extension does, self-host the pieces you care about, and avoid vendor lock-in on the tooling layer itself.
Third, Continue is language-agnostic in a way that suits Apple developers who live across stacks. It handles Swift alongside the Objective-C, JavaScript, Python, shell, and YAML that show up in real iOS repos, build scripts, and CI configuration.
The most important limitation is the one every AI assistant shares: it does not build, sign, or submit your app. Continue writes and reasons about code, but shipping to the App Store still requires Xcode and an Apple Developer Program membership.
There is no substitute here. No AI extension, linter, or terminal replaces Xcode for compiling against the iOS SDK, managing provisioning profiles, or archiving a release build.
Quality also depends heavily on the model you connect. A small local model will feel very different from a large hosted one, so your experience is only as good as your chosen backend and how you configure context.
Finally, Continue is not a native Xcode plugin. If your team works primarily inside Xcode, an assistant that lives in VS Code or JetBrains means context switching, and you should weigh that friction honestly.
Continue itself is free and open source. There is no per-seat license fee to use the extension, and the source is publicly available.
Your real cost is the model provider you connect. If you use a hosted API, you pay that vendor by usage or subscription according to their terms; if you run a local model, your cost is the hardware and electricity, not a per-token bill.
This decoupling is genuinely useful for budgeting. A solo developer can start on free or local models at essentially zero marginal cost, while a team can standardize on a paid API for stronger results.
Because pricing lives with the model providers and can change, always confirm current numbers on the provider's official pricing page rather than trusting a blog snapshot. Continue's own site and docs explain the setup, but the bill comes from whichever model you choose.
Getting started with Continue is not instantaneous, and it is fair to set expectations. Because you supply the model, first-time setup involves picking a provider and entering configuration rather than clicking a single install button.
That one-time cost buys you the flexibility the tool is known for. Once a provider is wired up, day-to-day use feels much like any other AI assistant: type for completions, open a panel for chat.
The learning curve is mostly about the configuration model. Understanding that autocomplete, chat, and agent roles can each point at a different model is the main concept to internalize.
Developers already comfortable with editing a config file or following provider docs will find it manageable. If you prefer a zero-configuration experience, be aware that Continue trades some of that simplicity for control.
Continue is a strong choice for iOS developers who already spend meaningful time in VS Code or a JetBrains IDE and want an AI assistant they can control. If model flexibility, privacy, and open source matter to you, it is close to ideal.
It is especially compelling for anyone who needs to keep code local. The ability to run a private model through the same interface as a hosted one is a real differentiator.
It is a weaker fit if you live entirely inside Xcode and never touch an external editor, since Continue does not run there. In that case the context switch may outweigh the benefits.
Overall verdict: for Swift developers comfortable pairing an external editor with Xcode, Continue is a capable, transparent, and cost-controllable AI assistant well worth trying. Just remember it augments your workflow — Xcode and the Apple Developer Program still ship the app.
Yes. Continue is language-agnostic and works with Swift files in VS Code or JetBrains IDEs. It helps you write, explain, and refactor Swift, but you still use Xcode to build, sign, and submit the app.
The Continue extension is free and open source. You pay only the model provider you connect it to, and if you run a local model there may be no per-use cost at all beyond your own hardware.
No. Continue is an AI code assistant for editing and reasoning about code. Compiling against the iOS SDK, code signing, provisioning, TestFlight, and App Store submission all still require Xcode and an Apple Developer Program account.
Yes. Continue supports local models, so you can keep your Swift code on your own machine. Whether data stays local depends on the specific provider or model you configure.
No. Continue is an extension for VS Code and JetBrains IDEs, not an Xcode plugin. iOS developers typically write code with Continue in one of those editors and switch to Xcode for building and shipping.