# Guia Definitivo: Cline

> Cline é o agente de codificação open-source mais popular do VS Code. Aprenda a instalar, configurar e dominar seus recursos avançados.

Source: https://agentify.ia.br/blog/cline/

Cline é o agente de codificação open-source mais popular para VS Code — e com razão. Com mais de 5 milhões de instalações e quase 60 mil stars no GitHub, ele transforma seu editor num ambiente de desenvolvimento autônomo onde a IA cria arquivos, executa comandos no terminal, navega na web e usa ferramentas externas via MCP. Tudo isso sem cobrar um centavo pela extensão — você paga apenas pelo uso da API do modelo que escolher.

## Overview

### O que é o Cline

Cline (anteriormente conhecido como “Claude Dev”) é uma extensão open-source para VS Code que funciona como um agente de codificação completo. Diferente de ferramentas de autocomplete como o Copilot tradicional, o Cline opera no modo agente: ele recebe uma tarefa, planeja a execução, e age sobre seu codebase com sua permissão a cada passo.

A extensão é mantida pela Cline Bot Inc. (anteriormente Maximum Compute Inc.), que levantou US$ 32 milhões em rodadas Seed e Series A para continuar desenvolvendo o projeto. Apesar do investimento, o core permanece 100% open-source sob licença Apache 2.0.

### Posicionamento no mercado

O Cline ocupa um espaço único: é a alternativa open-source e gratuita aos agentes proprietários como Cursor e GitHub Copilot Agent Mode. Enquanto o Cursor cobra US$ 20/mês e o Copilot exige assinatura, o Cline é gratuito — você traz sua própria API key e paga diretamente ao provedor de modelo.

Isso significa controle total: escolha qualquer modelo, de qualquer provedor, sem lock-in. Se amanhã surgir um modelo melhor e mais barato, você troca em segundos.

### Modelo de execução

- **Tipo**: Extensão para IDE (VS Code, Cursor, Windsurf, JetBrains, VSCodium, Antigravity)

- **Preço**: Gratuito (open-source) + custo de API do provedor escolhido

- **Licença**: Apache 2.0

- **Versão atual**: v3.35+ [VERIFICAR: versão exata no momento da publicação]

- **Instalações**: 5+ milhões (VS Marketplace + Open VSX)

- **GitHub Stars**: ~60k

### Diferencial principal

O grande trunfo do Cline é a combinação de **transparência + flexibilidade + zero lock-in**. Você vê cada decisão que o agente toma, escolhe qualquer modelo (cloud ou local), e nunca fica preso a uma plataforma ou pricing específico.

## Tutorial

### Instalação

A instalação é direta — se você já usa VS Code, são literalmente 3 cliques:

- Abra o VS Code

- Pressione `Ctrl+Shift+X` (Extensions)

- Busque “Cline”

- Clique em **Install**

```
# Alternativa: instalar via CLI do VS Code
code --install-extension saoudrizwan.claude-dev
```

Após instalar, o ícone do Cline aparece na barra lateral esquerda. Clique nele para abrir o painel.

#### Pré-requisitos

- VS Code 1.80+ (ou editor compatível)

- Node.js 18+ (para funcionalidades de terminal)

- Uma API key de pelo menos um provedor (Anthropic, OpenAI, Google, OpenRouter, etc.)

### Configuração de API Key

Ao abrir o Cline pela primeira vez, ele pede que você configure um provedor de modelo. Você tem várias opções:

**Opção 1: Cline API (mais simples)**

A própria Cline oferece uma API unificada — um endpoint, uma key, acesso a modelos da Anthropic, OpenAI, Google, DeepSeek, xAI e mais. Sem taxa de plataforma, você paga apenas a inferência.

**Opção 2: Provedor direto (BYOK)**

Traga sua própria key de qualquer provedor:

 Provedor Modelos populares Preço (input/output por MTok) Anthropic Claude Sonnet 4.6, Opus 4.6 $3/$15 (Sonnet), $5/$25 (Opus) OpenAI GPT-5, o3 Varia por modelo Google Gemini 2.5 Pro, Flash Competitivo OpenRouter 200+ modelos Markup mínimo sobre provedor AWS Bedrock Claude via AWS Pricing AWS GCP Vertex Gemini via GCP Pricing GCP DeepSeek DeepSeek V3 Muito acessível Groq Llama, Mixtral Ultra-rápido

**Opção 3: Modelos locais**

Para quem quer privacidade total ou custo zero de API:

```
# Via Ollama
ollama pull deepseek-coder-v2
# Configure no Cline: Provider → Ollama → localhost:11434
```

O Cline suporta Ollama, LM Studio, e qualquer endpoint compatível com OpenAI.

[IMAGEM: Screenshot mockup da tela de configuração de provedor do Cline]

### Primeiro Uso

Vamos ao “hello world” do Cline. Com a API configurada:

- Abra um projeto (ou crie uma pasta vazia)

- Clique no ícone do Cline na sidebar

- Digite sua primeira tarefa:

```
Crie um servidor Express com TypeScript que tenha um endpoint GET /health retornando { status: "ok" }
```

O Cline vai:

- Analisar o que precisa ser feito

- Propor a criação de arquivos (`package.json`, `tsconfig.json`, `src/index.ts`)

- Pedir sua aprovação para cada ação

- Executar `npm install` no terminal (com sua permissão)

- Mostrar o resultado final

Cada passo aparece no painel com um botão de **Approve** ou **Reject**. Você mantém controle total.

### Workflow: Plan Mode vs Act Mode

Aqui está o diferencial de workflow do Cline — o sistema dual **Plan & Act**:

#### Plan Mode

No Plan Mode, o Cline pode ler seu codebase, fazer buscas e discutir estratégia, mas **não pode modificar arquivos nem executar comandos**. É o modo de exploração segura.

Use para:

- Explorar codebases desconhecidos

- Discutir decisões de arquitetura

- Identificar edge cases antes de implementar

- Criar uma estratégia clara de implementação

#### Act Mode

Quando você tem um plano, mude para Act Mode. O Cline retém todo o contexto da sessão de planejamento e agora pode modificar arquivos, rodar comandos e executar a estratégia.

#### Workflow típico

```
1. Inicie em Plan Mode → descreva o que quer construir
2. Cline explora arquivos relevantes e entende o codebase
3. Discuta a abordagem, edge cases, trade-offs
4. Quando confiante no plano → mude para Act Mode (Tab)
5. Cline implementa baseado na sessão de planejamento
```

**Dica**: Pressione `Tab` para alternar entre Plan e Act. Pressione `Shift+Tab` para ativar auto-approve.

[IMAGEM: Diagrama do fluxo Plan → Act com os estados e transições]

### Auto-Approve: Controle Granular

O sistema de Auto-Approve permite que você defina exatamente quais ações o Cline pode executar sem pedir permissão:

 Ação Risco Recomendação Ler arquivos Baixo Auto-approve ✅ Escrever arquivos Médio Aprovar manualmente Executar comandos Alto Aprovar manualmente Usar browser Médio Caso a caso MCP tools Varia Configurar por tool

Para tarefas rotineiras onde você confia no agente, ative o auto-approve seletivamente. Para trabalho em produção ou código sensível, mantenha a aprovação manual.

### Uso Intermediário: Refatorando um Módulo Real

Vamos a um cenário mais realista. Imagine que você tem um módulo de autenticação legado e quer modernizá-lo:

```
[Plan Mode]
Analise o módulo src/auth/ e proponha uma refatoração para:
1. Separar a lógica de JWT da lógica de sessão
2. Adicionar refresh tokens
3. Manter backward compatibility com os endpoints existentes
```

O Cline vai:

- Ler todos os arquivos em `src/auth/`

- Mapear dependências e imports

- Propor uma estrutura refatorada

- Listar riscos e pontos de atenção

Quando você aprovar o plano:

```
[Act Mode]
Execute a refatoração conforme o plano. Comece pela separação de concerns.
```

Ele implementa arquivo por arquivo, mostrando diffs e pedindo aprovação. Se algo der errado, use **Checkpoints** para voltar a qualquer estado anterior.

### Configuração Avançada:.clinerules

O `.clinerules` é o equivalente do Cline ao `.cursorrules` ou `CLAUDE.md` — são instruções persistentes que guiam o comportamento do agente no seu projeto.

Crie um arquivo `.clinerules/main.md` na raiz do projeto:

```
# Regras do Projeto

## Stack
- TypeScript strict mode
- React 19 com Server Components
- Tailwind CSS v4
- Prisma ORM

## Convenções
- Nomes de variáveis em camelCase
- Componentes em PascalCase
- Testes com Vitest, co-localizados com o código
- Commits seguem Conventional Commits

## Proibições
- Nunca use `any` em TypeScript
- Não instale dependências sem perguntar primeiro
- Não modifique arquivos em /config/ sem aprovação explícita
```

A partir da v3.13, o Cline oferece uma UI para gerenciar rules — você pode ativar/desativar regras com um clique, como módulos intercambiáveis.

## Deep Dive

### Arquitetura Interna

O Cline funciona como um loop agente clássico:

- **Recebe instrução** → interpreta a tarefa

- **Planeja** → decide quais ferramentas usar

- **Executa** → chama a ferramenta (com aprovação)

- **Observa** → analisa o resultado

- **Itera** → decide próximo passo ou finaliza

As ferramentas disponíveis incluem:

- **File Operations**: criar, ler, editar, buscar em arquivos

- **Terminal**: executar comandos shell

- **Browser**: navegar, clicar, extrair dados de páginas web

- **MCP Tools**: qualquer ferramenta exposta via Model Context Protocol

### MCP Servers: Estendendo o Cline

O Model Context Protocol (MCP) é onde o Cline realmente brilha. MCP permite que você conecte ferramentas externas ao agente — bancos de dados, APIs, serviços cloud — de forma padronizada.

O Cline tem um **MCP Marketplace** integrado onde você pode instalar servers com um clique:

```
// Exemplo: configuração de MCP server no settings
{
 "mcpServers": {
 "postgres": {
 "command": "npx",
 "args": ["-y", "@modelcontextprotocol/server-postgres"],
 "env": {
 "DATABASE_URL": "postgresql://..."
 }
 },
 "github": {
 "command": "npx",
 "args": ["-y", "@modelcontextprotocol/server-github"],
 "env": {
 "GITHUB_TOKEN": "ghp_..."
 }
 }
 }
}
```

Com MCP servers configurados, o Cline pode:

- Consultar seu banco de dados diretamente

- Criar issues e PRs no GitHub

- Interagir com APIs REST/GraphQL

- Acessar documentação atualizada

- Gerenciar infraestrutura cloud

[IMAGEM: Diagrama da arquitetura MCP mostrando Cline conectado a múltiplos servers]

### Multi-Modelo: Estratégia de Custos

Uma feature poderosa do Cline é usar **modelos diferentes para Plan e Act**:

 Estratégia Plan Mode Act Mode Custo relativo Máxima qualidade Claude Opus 4.6 Claude Sonnet 4.6 $$$ Custo otimizado Gemini 2.5 Flash DeepSeek V3 $ Velocidade Gemini 3 Flash Groq (Llama) $ Privacidade Ollama local Ollama local Grátis

Essa flexibilidade é impossível em ferramentas proprietárias. No Cursor, você usa o que eles oferecem. No Cline, você monta sua própria stack de modelos.

### Subagents e Agent Teams

Nas versões mais recentes, o Cline introduziu:

- **Subagents**: delegação de subtarefas para instâncias paralelas

- **Agent Teams**: múltiplos agentes coordenados via Kanban board

- **Deep Planning**: comando `/deep-planning` para análise profunda antes de implementar

```
# Cline CLI com agent teams
cline kanban # Abre board de tarefas com múltiplos agentes
```

### Skills e Workflows

O Cline suporta **Skills** — conjuntos de instruções reutilizáveis que especializam o agente:

```
// .clinerules/skills/react-component.md
# Skill: Criar Componente React

Quando pedido para criar um componente React:
1. Use functional components com TypeScript
2. Extraia tipos para um arquivo .types.ts
3. Crie teste unitário co-localizado
4. Adicione Storybook story
5. Exporte via barrel file (index.ts)
```

E **Workflows** — sequências automatizadas de ações:

```
// .clinerules/workflows/new-feature.md
# Workflow: Nova Feature

1. Criar branch feature/{nome}
2. Implementar código
3. Rodar testes
4. Criar PR com descrição
```

### Hooks: Lógica Custom no Pipeline

Hooks permitem injetar scripts custom em pontos específicos do workflow do Cline:

- **Pre-write**: validar antes de escrever arquivo

- **Post-write**: formatar, lint após escrita

- **Pre-execute**: verificar comando antes de rodar

- **Post-execute**: processar output de comando

```
# .clinerules/hooks/post-write (executável)
#!/bin/bash
# Auto-format após cada escrita
npx prettier --write "$1"
```

### Checkpoints: Undo Inteligente

Cada ação do Cline cria um checkpoint automático. Se algo der errado, você pode voltar a qualquer ponto anterior — como um `git stash` granular por ação do agente.

Na v3.12+, checkpoints têm indicadores visuais na timeline, facilitando identificar exatamente onde reverter.

## Cline vs GitHub Copilot: Comparação Direta

Ambos rodam no VS Code, mas a filosofia é completamente diferente:

 Aspecto Cline GitHub Copilot Modelo Open-source, BYOK Proprietário, assinatura Preço Grátis + API (~$5-50/mês uso típico) $10-39/mês fixo Autocomplete Não (foco em agente) Sim (core feature) Modo agente Nativo, completo Agent Mode (recente) Modelos Qualquer (15+ provedores) GPT-4o, Claude (limitado) MCP Suporte completo + marketplace Suporte básico Transparência Código aberto, cada ação visível Caixa preta Aprovação Granular (por ação) Menos controle Offline/Local Sim (Ollama, LM Studio) Não Custom rules .clinerules (rico) .github/copilot-instructions.md Lock-in Zero GitHub ecosystem

### Quando escolher Cline

- Você quer controle total sobre custos e modelos

- Privacidade é prioridade (modelos locais)

- Precisa de MCP servers para integrações custom

- Prefere transparência e código aberto

- Quer usar o melhor modelo disponível, sempre

### Quando escolher Copilot

- Você quer autocomplete inline (Cline não faz isso)

- Sua empresa já paga GitHub Enterprise

- Prefere preço fixo previsível

- Não quer gerenciar API keys

- Integração nativa com GitHub (PRs, Issues) é prioridade

A verdade é que muitos desenvolvedores usam **ambos**: Copilot para autocomplete rápido e Cline para tarefas agênticas complexas. Eles não competem diretamente — complementam-se.

## Avaliação: Spider Chart

Notas de 1 a 10 baseadas em benchmarks públicos + avaliação prática.

 Eixo Nota Justificativa Código (qualidade) 8/10 Depende do modelo escolhido (Claude/GPT/Gemini) — flexibilidade é vantagem e limitação; com Claude Opus 4.6 atinge SWE-bench ~80%+ Contexto (compreensão) 7/10 VS Code workspace awareness e file search, mas sem indexação vetorial própria como Cursor; depende do context window do modelo Autonomia 7/10 Plan & Act modes, auto-approve granular, checkpoints — robusto mas menos autônomo que CLIs (Claude Code, Codex) por design Velocidade 7/10 Depende do provider/modelo escolhido; overhead do VS Code e loop de aprovação reduzem throughput vs ferramentas de terminal Custo-benefício 8/10 Open-source gratuito, paga só API — controle total de custo; com modelos baratos (DeepSeek, Gemini Flash) pode custar <$5/mês Especialização (skills) 8/10 .clinerules, custom instructions, skills, workflows, hooks — sistema maduro e extensível desde v3.13+ Multi-agente 7/10 Subagents nativos para pesquisa paralela + Cline Kanban para orquestração multi-agente via CLI; evolução significativa em 2026 Ecossistema 8/10 5M+ installs, MCP marketplace integrado, comunidade ativa (60k+ stars), Cline SDK open-source, suporte a 15+ provedores

**Média geral: 7.5/10**

> **Metodologia**: Código baseia-se em SWE-bench Verified + Aider Polyglot (performance varia conforme modelo escolhido). Autonomia em Terminal-Bench + avaliação prática. Multi-agente atualizado para refletir Cline Kanban (mai/2026) e subagents nativos. Demais eixos são avaliação prática comparativa. Escala: 1-4 (fraco), 5-6 (adequado), 7-8 (bom), 9-10 (excelente/líder).

## Prós e Contras

### Prós

- **100% open-source** — código auditável, sem surpresas, comunidade ativa com 60k+ stars

- **Zero lock-in** — troque de modelo, provedor ou até de editor a qualquer hora

- **Flexibilidade de modelo** — use Claude, GPT, Gemini, DeepSeek, modelos locais, ou qualquer combinação

- **MCP ecosystem** — marketplace integrado com centenas de servers prontos para uso

- **Plan & Act** — separação inteligente entre pensar e fazer, reduz erros

- **Custo potencialmente menor** — sem assinatura fixa; com modelos baratos (DeepSeek, Gemini Flash), pode custar menos que $5/mês

- **Privacidade** — suporte a modelos locais para código sensível

- **Customização profunda** —.clinerules, skills, workflows, hooks

### Contras

- **Sem autocomplete inline** — não substitui Copilot para sugestões enquanto digita

- **Custo imprevisível** — sem teto de gastos (a menos que você configure limites no provedor); uma sessão pesada com Claude Opus pode custar $10+

- **Curva de aprendizado** — configurar API keys, escolher modelos, entender Plan/Act exige mais setup que ferramentas “plug and play”

- **Qualidade depende do modelo** — com modelos baratos/locais, a qualidade cai significativamente

- **Sem garantia enterprise nativa** — a versão enterprise existe mas é recente; Copilot tem anos de maturidade corporativa

- **Consumo de tokens** — o loop agente consome muitos tokens por tarefa; tarefas complexas podem usar 100k+ tokens facilmente

### Veredicto

**Cline é ideal para**: desenvolvedores intermediários a avançados que querem máximo controle, flexibilidade de modelo, e não se importam em gerenciar API keys. É perfeito para quem já usa VS Code e quer um agente poderoso sem trocar de editor.

**Cline NÃO é ideal para**: quem busca uma experiência “instala e usa” sem configuração, quem precisa de autocomplete inline como feature principal, ou equipes enterprise que exigem compliance e billing centralizado (embora a versão Enterprise esteja evoluindo).

**Recomendação prática**: Comece com a Cline API ou OpenRouter para simplificar o setup inicial. Use Claude Sonnet 4.6 como modelo padrão (melhor custo-benefício para coding). Configure `.clinerules` desde o primeiro dia. E considere rodar Cline + Copilot juntos — autocomplete do Copilot + agente do Cline é uma combinação poderosa.

---

Se você quer se aprofundar em como criar skills customizadas para especializar seu Cline em tarefas específicas do seu projeto, o [skilldev.pro](https://skilldev.pro) tem um catálogo crescente de skills prontas para uso — desde configurações de framework até workflows completos de CI/CD.

[IMAGEM: Screenshot mockup do Cline em ação com Plan Mode ativo e sidebar mostrando o plano]

-->