How to Migrate from Claude Code to Cline

Transitioning from a command line agent like Claude Code to a VS Code extension like Cline presents a distinct challenge because credentials, system contexts, and session state are managed in separate environments. Shell profiles do not automatically inherit settings when migrating to a graphical editor sidebar. Migrating from Claude Code to Cline is the transition of local AI rules, model parameters, and MCP configuration files from Anthropic's command-line interface to Cline's VS Code extension.

Claude Code runs as a terminal-first agent directly inside your local shell session. It inherits standard environment variables, credentials, and project pathways that are active in your current terminal pane. Cline, on the other hand, operates as a desktop application extension in the VS Code sidebar. This architectural difference means you cannot simply copy files and expect everything to run. You must translate how the agents read your project's rules, how they connect to the Model Context Protocol (MCP), and how they load credentials.

Migrating your workflow to Cline offers a visual approach to agentic development. You gain interactive file diffing, clear execution feedback, and a unified panel to manage your tools. However, to maintain productivity, you need to migrate your settings manually. This guide outlines the exact file paths, configuration JSON schemas, and rule conversion steps required to transition your setup successfully.

The first step in migration is locating where each tool stores its settings. Claude Code and Cline do not share settings folders. If you have customized your Claude Code configuration, you must locate the JSON files manually and port their keys to Cline's designated directory structure.

Claude Code manages its global settings in your user home directory. It uses a single hidden configuration file:

• macOS and Linux: ~/.claude.json
• Windows: %USERPROFILE%.claude.json

Claude Code also supports project-level settings. If you have defined local rules or tools for a specific codebase, they are stored in a file named .mcp.json at the root of your project directory.

Cline does not read settings from settings.json. Instead, it relies on a standalone configuration file named cline_mcp_settings.json. On Cline 4.x, the IDE extension, the command-line interface, and the SDK all read one shared file:

• macOS and Linux: ~/.cline/data/settings/cline_mcp_settings.json
• Windows: %USERPROFILE%.cline\data\settings\cline_mcp_settings.json

Older Cline builds stored this file inside the VS Code extension global storage directory, under globalStorage/saoudrizwan.claude-dev/settings/. That location is now legacy. Cline reads it once on first launch, migrates the contents to the shared path above, and no longer writes there. If you need a non-default location, set the CLINE_MCP_SETTINGS_PATH environment variable in your shell.

Both agents use the Model Context Protocol to execute local and remote tools, but their JSON configuration schemas differ. To migrate your MCP servers successfully, you must translate the transport parameters and server keys from your Claude Code JSON structure to the Cline format. For remote MCP server details and product setup, consult the Fast.io agent storage overview.

For local stdio transport servers, the configuration remains identical. Both tools use the command and args keys to execute local scripts. However, for remote servers, the schemas diverge:

• Claude Code uses http as the canonical transport type, with streamable-http accepted as an alias, or sse for legacy servers.
• Cline uses streamableHttp (camelCase) or sse as the transport type.

Below is the JSON schema comparison for a remote MCP server connection.

Claude Code configuration example:

{
  "mcpServers": {
    "fastio-remote": {
      "type": "http",
      "url": "https://mcp.fast.io/mcp/key",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Cline configuration example:

{
  "mcpServers": {
    "fastio-remote": {
      "type": "streamableHttp",
      "url": "https://mcp.fast.io/mcp/key",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

If you omit the type key in Cline's settings, Cline falls back to the legacy sse transport for backward compatibility, which expects a persistent stream handshake and fails against a Streamable HTTP endpoint. Always define streamableHttp explicitly for remote cloud resources.

Project-specific instructions prevent agents from making repetitive mistakes. When migrating, you must translate the rules files that guide agent behavior in your repository.

In Claude Code, project rules are documented in a file named CLAUDE.md at the root of the repository. Claude Code can also read modular files within the .claude/rules/ folder to load instructions dynamically based on file patterns.

In Cline, workspace rules live at the root of the project. The primary format is a .clinerules/ directory holding individual .md or .txt files, which Cline combines into one rule set. A single bare .clinerules file still works for small rule sets.

The primary difference between CLAUDE.md and .clinerules involves formatting and scoping:

• CLAUDE.md is a general markdown file that outlines build commands, test patterns, and code styles. Claude Code reads the entire file at startup.
• .clinerules files support YAML frontmatter. This allows you to restrict specific rules to particular glob patterns, preventing the agent's system prompt from becoming congested with irrelevant guidelines.

To migrate, move the contents of your CLAUDE.md into a .clinerules/ directory as one or more .md files. Splitting a long rules file into modular topic files lets you scope each one with YAML frontmatter. Cline's only supported conditional is paths, and it takes an array of glob patterns:

---
paths:
  - "src/components/**/*.tsx"
---
### React Component Rules
* Use functional components with hooks.
* Export components as named exports.

Using this modular approach helps Cline parse your instructions quickly, saving context window space and improving generation accuracy.

Persist Cline and Claude Code configurations across sessions

Synchronize your agent settings, rules, and files using a central workspace. Start a 14-day free trial on our Starter, Business, or Growth plans.

Start 14-Day Trial

A frequent migration issue is that Cline fails to run scripts or authenticate with APIs because it lacks access to local credentials. This happens because of how the two interfaces execute.

When you run Claude Code, it runs in your active terminal, giving it immediate access to your shell profile environment variables and keys. In contrast, VS Code launches as a desktop process, meaning Cline does not inherit shell exports automatically unless you open VS Code directly from your terminal using the code command.

To resolve this for API keys:

• Standard LLM keys: Set your Anthropic, OpenAI, or Gemini keys directly in Cline's extension configuration panel.
• Local stdio MCP credentials: Define variables inside the env object of your cline_mcp_settings.json.
• Remote MCP credentials: Move authentication tokens to the headers block of your server settings.

By declaring your environment parameters explicitly inside the configuration files, you guarantee that Cline can run tasks without relying on terminal state.

Once you migrate your local settings to Cline, managing workspaces across multiple machines or teammates requires transitioning from local storage to a persistent cloud layer. Connecting your agent to Fast.io workspaces provides the intelligent workspace infrastructure needed to coordinate these agent workflows.

Instead of keeping Cline's output isolated inside a local VS Code directory, you can connect your agent to a Fast.io workspace. Fast.io runs on cloud infrastructure partners, including Google Cloud Platform and Cloudflare, that are certified to industry-leading security standards. We protect your data with encryption in transit and at rest, granular permissions, access controls, and an append-only audit log.

When you connect Cline to the Fast.io MCP server, the agent gains access to:

• Shared workspaces with per-file version history: Prevent multiple agents from overwriting each other's work by tracking every change.
• Ownership transfer: An agent can build a workspace structure, import documentation via cloud import from Google Drive, OneDrive, Box, or Dropbox, and transfer ownership to a human reviewer.
• Metadata Views: Turn raw documents into a live, queryable database by pointing the agent to Metadata Views to extract structured data.
• Intelligence Mode: Index your workspace files automatically for semantic search, giving your agent direct RAG access with citations.
• Webhooks: Set up reactive systems to trigger secondary local operations when the agent writes to the cloud workspace.

Connecting your agents to a unified workspace ensures that whether you use Claude Code or Cline, your team has a single source of truth. Every organization starts with a 14-day free trial, which requires a credit card. Paid subscriptions start with the Starter plan at $29/mo, the Business plan at $99/mo, and the Growth plan at $299/mo, ensuring you have the persistent workspace required to scale your team's workflows. You can review the details on our pricing page and sign up.