Cline: install, providers, Plan and Act, rules, skills and MCP

What is Cline?

Cline is an open source AI coding agent that runs inside your editor or terminal and asks before it acts. Its overview says it "can read and write files, run terminal commands, use a browser, and help you build features through natural conversation. Every action requires your explicit approval." You choose the model: Cline's own billing, a subscription, your own API key or a local model.

The source is at github.com/cline/cline under the Apache 2.0 license. The same agent core now powers several apps:

• VS Code extension, which also installs in Cursor, Windsurf, VSCodium and Antigravity
• JetBrains plugin for IntelliJ IDEA, PyCharm, WebStorm and the rest
• CLI for interactive and headless terminal work
• Cline Desktop, an open source app for open weight models
• Kanban, a web-based task board that runs many agents in parallel with per-card worktrees
• SDK (@cline/sdk) for building your own agents

This guide follows the Cline docs as of 24 October 2026.

How do you install Cline?

In VS Code and its forks, open Extensions with Ctrl/Cmd+Shift+X, search "Cline" and click Install. Windsurf and VSCodium pull it from Open VSX, with the same steps. Cline then appears in the sidebar.

In JetBrains IDEs, go to Settings, Plugins, Marketplace, search "Cline", install and restart. Open it from View, Tool Windows, Cline.

In the terminal, the CLI needs Node.js 20 or newer (22 recommended):

npm install -g cline
cline auth          # pick a provider and model
cline               # interactive session
cline "your task"   # start with a task

The installation page also covers the desktop app (macOS, with Windows in beta) and npx kanban for the task board.

How do you choose a model provider in Cline?

After installing, open Cline settings (or /settings in the CLI) and pick an API provider. There are three broad paths:

As of October 2026, the ClinePass page lists it at $9.99 a month and says it "offers 2-5x the usage on popular open coding models compared to standard API rate." Usage is measured against a 5-hour rolling window, a weekly limit and a monthly limit. It is optional, and you can use other providers alongside it.

Bring-your-own-key covers the big providers plus OpenAI-compatible endpoints and, per the docs index, more than 30 others. For local models, Cline documents Ollama, LM Studio and Atomic Chat.

How do Plan and Act modes work?

Plan and Act are Cline's core workflow. The Plan and Act page describes them this way:

• Plan mode: Cline "can read your codebase, run searches, and discuss strategy, but cannot modify any files or execute commands."
• Act mode: Cline keeps the whole planning conversation and can now edit files and run commands.

A typical loop is to start in Plan, let Cline explore the relevant files, agree on an approach and edge cases, then switch to Act to implement. For quick fixes like a typo or a missing import, the docs suggest going straight to Act. For large, multi-session work there is a /deep-planning command that explores the codebase, identifies affected files and dependencies, writes a detailed implementation plan and asks clarifying questions before proceeding.

You can also give each mode its own model. In Cline settings, turn on Use different models for Plan and Act and pick one for each, for example a stronger reasoning model for planning and a faster one for implementation.

In the CLI, cline -p "design migration plan" starts in Plan mode, and running without -p starts in Act mode.

How do you write rules for Cline?

Rules are Markdown files Cline follows in every conversation: coding standards, project context, constraints like "don't touch /legacy." Cline reads them from several formats, per the rules page:

Workspace rules go in .clinerules/ or .cline/rules/ at your project root, one topic per file. Global rules go in ~/Documents/Cline/Rules on macOS and Linux (Documents\Cline\Rules on Windows), and Cline also checks ~/.cline/rules. When workspace and global rules conflict, workspace rules win.

Every rule has a toggle in the Rules panel (the scale icon left of the model selector), so you can switch a strict testing rule off while prototyping. The /newrule command has Cline write a rule with you.

To keep context lean, scope a rule to certain files with paths frontmatter:

---
paths:
  - "src/components/**"
  - "src/hooks/**"
---

# React Component Guidelines

- Use functional components with hooks
- Keep components focused on a single responsibility

The rule then loads only when files in your message, open tabs or Cline's edits match those globs. A rule with no frontmatter is always active, and paths: [] turns it off. If you already keep Cursor rules or an AGENTS.md, Cline picks those up without changes.

How do skills work in Cline?

Skills are on-demand instructions in the Agent Skills format. Unlike rules, which are always loaded, a skill stays dormant until a request matches its description. The skills page breaks the cost down: about 100 tokens per skill for the name and description at startup, the SKILL.md body (aim for under 5,000 tokens) when triggered, and bundled files only as needed.

---
name: aws-deploy
description: Deploy applications to AWS using CDK. Use when deploying, updating infrastructure, or managing AWS resources.
---

# AWS Deploy

1. Run the checks in scripts/preflight.sh
2. ...

Two requirements: name must exactly match the folder name, and description can be up to 1,024 characters. Cline finds skills here:

• Project: .cline/skills/ (recommended), .clinerules/skills/, .claude/skills/, and per the config page, .agents/skills/
• Global: ~/.cline/skills/ (C:\Users\USERNAME\.cline\skills\ on Windows), and ~/.agents/skills/

If a global and a project skill share a name, the global one wins. Skills are enabled when discovered and each has a toggle in the Skills tab. To force one, type / in chat and pick it, for example /aws-deploy.

How do you add MCP servers to Cline?

In the extension, click the MCP Servers icon at the top of the Cline panel, open the Configure tab and click Configure MCP Servers to edit the JSON. For a hosted server, use the Remote Servers tab: enter a name and URL and pick Streamable HTTP. In the CLI, run cline mcp for a wizard, or script it:

cline mcp add files --yes -- npx -y @modelcontextprotocol/server-filesystem .
cline mcp add docs https://example.com/mcp --transport http --header "Authorization: Bearer TOKEN" --yes

The CLI stores servers in ~/.cline/data/settings/cline_mcp_settings.json. A remote entry looks like this:

{
  "mcpServers": {
    "remote-server": {
      "type": "streamableHttp",
      "url": "https://example.com/mcp",
      "headers": { "Authorization": "Bearer your-token" },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Set "type": "streamableHttp" explicitly. The MCP page says leaving it out falls back to the legacy SSE transport. Keep autoApprove limited to tools you trust. The MCP servers roundup has a list of servers worth trying.

What else should you know before using Cline daily?

• Config folders. Global settings live in ~/.cline/ and apply to the extension, CLI and SDK alike. Project settings live in .cline/, which you can commit. cline config opens an interactive editor.
• Headless runs. The CLI switches to headless output with --json, when you pipe input in, or when you redirect output, so git diff | cline "review these changes" works in scripts.
• Deprecations. The deprecations page marks .clineignore as deprecating soon because it was never designed to prevent access to files (Cline can still reach them through shell commands), and Focus Chain as deprecated.
• Trust. The config page warns that hooks and plugins can execute code, so review them like any other executable before adding them.

How do you reuse your skills across Cline and other agents?

Cline reads .claude/skills/ and .agents/skills/, so skills you already wrote for Claude Code or other agents work without copying. OpenCode reads the same folders.

If you collect prompts and skills over time, Kipt stores them as Markdown in a private GitHub repo you own. You can import skills from a GitHub link, a folder or a .zip, search them with Cmd+K, and copy any folder into .cline/skills/. To start a new skill from a prompt you already use, try the free SKILL.md generator.