Sourcegraph Cody is a codebase-aware AI coding assistant that helps you read, write, and fix Swift in VS Code and JetBrains. It is strong on large-repo context but no longer offers a standalone free tier, and it never replaces Xcode for building and shipping iOS apps.
Sourcegraph Cody is an AI coding assistant built by Sourcegraph, the company best known for large-scale code search across enterprise repositories. Cody brings that search DNA to an editor sidebar.
It offers two everyday capabilities: inline autocomplete that suggests single and multi-line code as you type, and a chat panel where you ask questions about your code in natural language.
What sets Cody apart from a generic chatbot is context. It uses Sourcegraph's search to pull relevant files from your repository into the model's prompt, so answers reference your actual types, functions, and conventions rather than generic examples.
Cody runs inside editors you already use, including VS Code and JetBrains IDEs, with additional clients available over time. It supports several underlying large language models rather than locking you to one.
Cody works on Swift the same way it works on any language: it reads text, understands structure through context, and generates or explains code. For an iOS engineer, that means help with Swift, SwiftUI, UIKit, and the supporting files in your project.
The honest framing matters here. Cody is an assistant that lives beside your code, not a build system. You still compile, run the simulator, manage signing, and archive your app in Xcode.
Cody does not ship with a native Xcode extension the way it integrates with VS Code or JetBrains. Many iOS developers use it by opening their Swift package or app source in VS Code alongside Xcode, using Cody for reasoning and generation and Xcode for building and running.
Think of it as a smart pair-programmer for reading and writing Swift, while Xcode remains the tool that turns that Swift into a signed, shippable app.
Autocomplete is the feature you feel first. As you type a function body or a SwiftUI view, Cody proposes completions drawn from your file and surrounding code.
Chat is where the codebase context shines. You can ask 'where is the networking layer for the profile screen' or 'explain how this view model loads data' and Cody retrieves the relevant Swift files to answer.
Prompts and commands package common tasks, such as explaining a selection, generating unit tests, or writing a docstring, into repeatable actions you trigger from a menu.
Inline edit features let Cody propose changes you can apply into a file directly, rather than copy-pasting from a chat window. Together these cover the daily loop of understand, write, and refactor.
Cody's standout strength is repository-scale context. If you work in a large iOS monorepo or a multi-module Swift project, its search-backed retrieval helps it answer questions that a context-blind assistant would guess at.
Onboarding is a genuine use case. Drop a new engineer into an unfamiliar Swift codebase and Cody can summarize architecture, trace a feature across files, and point to where a symbol is defined.
Editor flexibility is another plus. Because it lives in VS Code and JetBrains, teams that split time between Swift and backend services in Kotlin, Go, or TypeScript get one assistant across languages.
Model choice adds resilience. Cody's ability to work with multiple LLMs means you are not stranded if one model underperforms on a particular Swift task.
The biggest limitation is structural: Cody does not build, sign, or submit iOS apps. Nothing it generates ships to the App Store without Xcode and an Apple Developer Program membership.
Cody also is not a native or low-code app builder. It writes Swift as text; it does not produce a visual, drag-and-drop UI or a compiled binary.
And unlike Flutter or React Native tooling, which output non-Swift cross-platform code, Cody stays inside your existing Swift files. That is good for authenticity, but it means Cody is only as useful as your editor setup.
There is no first-party Xcode integration, so the workflow involves keeping Xcode and a supported editor open together.
Finally, AI output needs review. Cody can produce Swift that compiles but misuses an API, mishandles concurrency, or ignores a project convention. Treat every suggestion as a draft to verify by building and testing.
Cody's plan structure changed meaningfully in 2025. Sourcegraph announced that the standalone Cody Free and Cody Pro plans, along with Cody in the Enterprise Starter plan, were being discontinued.
After that change, Cody is positioned primarily as an Enterprise product aimed at teams and larger organizations, sold on a per-user subscription.
Sourcegraph steered individual developers toward Amp, its newer agentic coding tool, as a separate offering. If you evaluated Cody in its earlier free form, revisit the current lineup before assuming a hobbyist tier still exists.
Because pricing and packaging move, confirm the latest details on Sourcegraph's official pricing and blog rather than relying on any figure quoted secondhand. Budget as a team, not as a solo trial.
Because Cody has no native Xcode client, the practical setup is two windows side by side. You open the same Swift files in a supported editor for Cody, and you keep Xcode as the place where code actually compiles and runs.
That split is less awkward than it sounds. Swift source is plain text on disk, so both tools read the same files, and changes you accept in the editor show up in Xcode after a save.
The discipline this requires is worth naming. Every non-trivial suggestion should round-trip through an Xcode build and a run on the simulator before you trust it.
For teams already standardized on VS Code or JetBrains for non-iOS work, this dual-tool rhythm tends to feel natural rather than forced.
Cody is a strong fit for iOS teams working inside large, shared Swift codebases who value context-aware answers and already live in VS Code or JetBrains. Its search-backed retrieval is a real differentiator for navigation and onboarding.
It is a weaker fit for solo indie developers who want a cheap or free assistant glued into Xcode. The 2025 plan changes removed the easy on-ramp that made Cody attractive to individuals, and the lack of native Xcode integration adds friction.
My recommendation: if you are on an engineering team with an enterprise Sourcegraph footprint, Cody is worth a serious pilot for Swift work. If you are a lone iOS developer, compare it against alternatives and Sourcegraph's own Amp before committing.
Either way, remember the boundary. Cody accelerates writing and understanding Swift; Xcode and the Apple Developer Program remain mandatory to build, sign, and ship the actual app.
No. Cody integrates with editors like VS Code and JetBrains, not Xcode. iOS developers typically open their Swift source in a supported editor for Cody while continuing to build, run, and archive in Xcode.
No. Cody writes and explains Swift as text. Compiling, code signing, and App Store submission still require Xcode and an active Apple Developer Program membership.
Sourcegraph discontinued the standalone Cody Free and Pro plans in 2025 and refocused Cody on Enterprise. Check Sourcegraph's official pricing page for the current lineup before assuming a free tier is available.
Yes. Cody is language-agnostic and works with Swift, SwiftUI, and UIKit code, using your repository context to make suggestions and answer questions relevant to your project.