What does your code editor actually send home while you type? That question sounds paranoid until you remember that most developers now run an AI-assisted editor that talks to a remote model on nearly every keystroke. Two editors dominate that conversation: Microsoft’s VS Code and Cursor, a VS Code fork built around AI-first workflows. Both ship telemetry. Both offer privacy controls. Neither offers what most people assume they offer, which is a network audit that proves where your code went.
This article separates the two data channels that get endlessly confused, explains what Privacy Mode does and does not do, and shows where the real limits begin. It also covers why “just turn telemetry off” is the most common mistake in this whole debate.
Two channels, not one
The single biggest error in coverage of editor privacy is treating telemetry and AI traffic as the same thing. They are not.
Telemetry is the editor’s own diagnostic reporting. VS Code controls it through the `telemetry.telemetryLevel` setting, which accepts values of `all`, `error`, `crash`, and `off`. Microsoft documents the categories it collects: usage data, errors, and crash reports. The documentation states that standard telemetry events do not include source code, file contents, or file names. That is a policy statement from the vendor, not an auditable guarantee you can verify on your own machine without tooling.
AI traffic is something else entirely. When you ask for a completion, a chat answer, or an inline edit, the prompt and the surrounding context have to travel to a model to generate a response. That request is the product working as designed. No privacy setting makes an AI editor useful while sending nothing.
Here is the distinction in plain terms:
| Channel | What triggers it | Can it be turned off? | Does it carry code context? |
|---|---|---|---|
| Telemetry | Editor usage, errors, crashes | Yes, via `telemetry.telemetryLevel` | Documented as no |
| AI requests | Every completion, chat, or edit | Only by not using the feature | Yes, by necessity |
| Marketplace queries | Extension search and updates | Partially | No |
| Settings sync | Account sign-in | Yes | Settings, not files |
Turning telemetry off silences the first row. It does nothing to the second. Anyone who flips one switch and assumes the editor went quiet has solved a fraction of the problem.
What VS Code actually sends

VS Code is the reference implementation here, and its telemetry is comparatively well documented. The setting is granular, the categories are published, and the default is on rather than off.
The practical problem is that telemetry is only one of several network features with independent switches. Extension marketplace queries, settings sync, and the built-in AI and natural language search features each have their own controls. Disabling telemetry does not disable all outbound traffic. A developer who sets `telemetry.telemetryLevel` to `off` and stops there still has an editor that phones the marketplace for extension metadata, still syncs settings if signed in, and still sends prompts if any AI feature is active.
The second practical problem is verification. Neither VS Code nor Cursor ships a user-facing audit log that shows every outbound request. If you want to know what leaves your machine, you need external tooling: an OS-level firewall, a proxy that intercepts traffic, or packet capture. That is not a knock on either product so much as a structural fact about how desktop applications report on themselves. The tool that watches the network is almost never the tool being watched.
For readers comparing broader security tradeoffs in the same spirit, the same “what it protects versus where the limits begin” framing applies to WireGuard versus OpenVPN, where the encryption is strong but the trust model around the endpoints is where things get interesting.
What Cursor’s Privacy Mode does
Cursor inherits VS Code’s telemetry machinery because it is built on the VS Code codebase. On top of that, it adds its own AI backend traffic and its own privacy controls.
Privacy Mode is the headline control. As documented, it prevents code snippets from being stored by Cursor’s servers and from being used for training. That is a meaningful commitment, and for teams worried about their code ending up in a training corpus, it addresses the concern directly.
What it does not do is stop requests from being sent. Prompts and context still travel to a model provider to generate the completion. The mode governs storage and training, not transmission. This is the central fact of the entire topic, and it is the one most often glossed over. Privacy Mode is a server-side data-retention and training policy. It is not a network-level block, and it cannot be, because a request that never leaves your machine cannot produce a useful answer.
A second wrinkle: naming and scope have changed across Cursor versions more than once. Any claim about what the setting covers in 2027 has to be checked against the then-current documentation, not against descriptions written in 2024 or 2025. Privacy settings that get restructured are a normal part of a fast-moving product, but they make stale blog posts actively misleading.
The third party in the chain
If Cursor routes a request to an external model provider, that provider’s retention policy applies independently of Cursor’s Privacy Mode. This is the link people forget. Your data passes through at least two sets of hands, and the first party’s promise does not bind the second.
The practical implication is that “we don’t train on your code” is a statement about one organization. It says nothing about what a downstream API provider logs, how long it keeps it, or where it stores it. Enterprise and team plans typically add admin-level controls such as enforced privacy settings and audit logs, which is part of why they cost more. Consumer plans generally do not offer the same guarantees. If your organization has data-retention obligations, the plan tier matters as much as the toggle.
This layered-trust problem shows up everywhere in security tooling. The same logic appears in passkeys versus passwords, where the cryptographic design is strong but recovery flows and account recovery remain the soft spot. It also drives decisions in 1Password versus Keeper versus NordPass, where the vault encryption is rarely the weak link; the surrounding account and sync architecture is.
Why a real network audit is harder than it sounds
Suppose you want to stop trusting documentation and see the traffic yourself. What does that take?
- Choose an interception point. An OS-level firewall gives you connection metadata: destination, port, volume. A proxy gives you request contents, but only for traffic that respects the proxy.
- Install a TLS-intercepting proxy and trust its certificate. This is where most people quit, because certificate pinning and non-standard clients break the chain.
- Capture a baseline session with no AI features active, then repeat with completions enabled. The delta is your AI traffic.
- Repeat after each settings change. A single audit is a snapshot, and snapshots go stale with the next release.
The honest summary is that a rigorous audit is a project, not an afternoon. It also produces results that expire. Independent network audits of editor traffic are rare for exactly this reason, which leaves vendor documentation as the only primary source for what gets collected. That is an uncomfortable position for anyone making compliance claims.
Where the limits begin
Pull the threads together and the boundaries become clear.
Limit one: transmission is not optional. Any AI feature that works must send context somewhere. Privacy Mode changes what happens after arrival, not whether arrival happens.
Limit two: telemetry off is not network off. Marketplace queries, settings sync, and AI features have separate switches. Disabling one channel leaves the others running.
Limit three: vendor documentation is the ceiling of your evidence. Without independent auditing, you are trusting a policy statement. Policies are enforceable promises, not physics.
Limit four: downstream providers are outside the first party’s control. A retention promise from the editor vendor does not automatically extend to every model API in the routing path.
Limit five: settings drift. Controls get renamed, restructured, and re-scoped. Any 2027 claim needs checking against 2027 documentation. This is not cynicism; it is just how fast these products move.
Regulatory frameworks raise the stakes without resolving the ambiguity. The GDPR has applied since 25 May 2018 and sets expectations around data minimisation and lawful basis. The EU AI Act entered into force on 1 August 2024, with obligations phasing in over the following years. Both push toward transparency about what is collected and why, but neither hands you a packet capture. Compliance is a process of documented diligence, not a checkbox.
What actually works in practice
Given all that, what should a careful developer or team actually do?
Start by mapping the channels before changing anything. List every network feature the editor has: telemetry, marketplace, sync, AI completion, AI chat, inline edit, and any indexing or embedding feature. Then decide per channel, not per product. A blanket “privacy on” toggle feels decisive and often misses a channel nobody thought about.
Set telemetry explicitly rather than relying on defaults. In VS Code, `telemetry.telemetryLevel` set to `off` is the documented way to silence the diagnostic channel. Do it in user settings and in workspace settings if your organization manages configurations centrally.
Treat Privacy Mode as a retention control, not a transmission control. Read the current documentation for the version you are running, and re-read it after major updates. If your team handles regulated data, confirm what the enterprise tier adds in terms of enforced settings and audit logs, because those are the controls that survive an individual developer’s misconfiguration.
Finally, accept the residual risk and document it. A short internal note saying “we audited these channels on this date with this tooling, and these channels remain” is worth more than a vague assurance that privacy mode is enabled. When the settings change in the next release, you will know exactly what to re-check.
The broader pattern holds across the security tool stack. Tailscale versus WireGuard shows how a managed layer can simplify operations while relocating trust to a coordination service. Tailscale versus Twingate versus NetBird makes the same point about control planes. And on the identity side, Microsoft Entra ID versus Okta versus Auth0 shows that the policy engine is only as strong as the configuration behind it.
For AI coding tools specifically, the comparison that matters most may not be Cursor versus VS Code at all. It is how each assistant handles context and output quality, which is where Cursor versus GitHub Copilot and a three-way Amp versus Claude Code versus Cursor evaluation become relevant. Privacy choices and tool quality are separate axes, and conflating them leads to bad decisions in both directions.
Conclusion
Cursor and VS Code are not hiding some dramatic secret. VS Code’s telemetry is documented, granular, and off-switchable. Cursor’s Privacy Mode makes a real commitment about storage and training. The trouble is the gap between what those controls say and what people hear. “Privacy Mode on” sounds like silence. It is not. It is a promise about what happens to data after it arrives, and the arrival itself is the product.
The right mental model is a set of channels, each with its own switch and its own trust chain. Map them, set them deliberately, verify what you can, and document what you cannot. Then check again after the next release, because in 2027 the settings you configured last year may not mean what they meant when you set them. That habit of re-verification is worth more than any single toggle.
Frequently asked questions
Does Cursor’s Privacy Mode stop my code from being sent to a server?
No. Privacy Mode governs what happens after your request arrives, specifically server-side storage and training use. The prompt and context still travel to a model provider to generate the completion. A request that never leaves your machine cannot produce a useful answer, so transmission is inherent to how the feature works.
Is VS Code telemetry sending my source code?
Microsoft’s documentation states that standard telemetry events do not include source code, file contents, or file names, and describes the categories as usage data, errors, and crash reports. That is a vendor policy statement rather than an independently audited guarantee. If you need proof rather than documentation, you need external interception tooling.
If I turn off telemetry, is my editor fully offline?
Not necessarily. Extension marketplace queries, settings sync, and AI features each have their own settings and their own network behavior. Disabling `telemetry.telemetryLevel` silences the diagnostic channel only. A full offline posture requires auditing every network feature individually, which is why channel-by-channel mapping beats a single toggle.
Why can’t I just run a network audit inside the editor?
Neither VS Code nor Cursor ships a user-facing audit log that lists every outbound request. Auditing requires external tools such as an OS-level firewall, a TLS-intercepting proxy, or packet capture. Those tools produce snapshots that go stale with each release, which is why independent audits of editor traffic are rare and short-lived.
Does Privacy Mode cover third-party model providers?
Not automatically. If the editor routes requests to an external model API, that provider’s retention policy applies independently of the editor vendor’s Privacy Mode. The first party’s promise does not bind the second party. Teams with retention obligations should confirm the full routing path and each provider’s terms rather than assuming a single setting covers everything.
Are enterprise plans more private than consumer plans?
Generally yes, in a specific sense. Enterprise and team tiers typically add admin-level controls such as enforced privacy settings and audit logs, which consumer plans usually lack. Those controls matter because they survive an individual developer’s misconfiguration. The underlying transmission behavior does not change, but the governance around it does.


