Como instalar o Claude Code

O que é o Claude Code?

O Claude Code é o CLI oficial da Anthropic que traz o modelo Claude diretamente para o seu terminal. Com ele, você pode pedir para a IA analisar código, criar arquivos, executar comandos, corrigir bugs e muito mais — tudo sem sair do terminal.

Diferente de ferramentas como o GitHub Copilot (que funciona dentro do editor), o Claude Code opera como um agente autônomo: ele lê a estrutura do projeto, entende o contexto completo e pode executar sequências de tarefas complexas. Você pode pedir "crie um endpoint de autenticação com JWT" e ele criará os arquivos, editará as URLs, adicionará as dependências e rodará os testes — tudo automaticamente.

Nos tutoriais do canal, usamos o Claude Code para acelerar o desenvolvimento de projetos Django e automatizar tarefas de infraestrutura com Terraform.

Pré-requisitos

• Node.js 18 ou superior instalado
• npm ou npx disponível no terminal
• Conta na Anthropic (console.anthropic.com)
• Linux, macOS ou Windows com WSL 2
• Conexão com a internet (o Claude Code se comunica com a API da Anthropic)

Para usuários Windows, o WSL 2 é obrigatório. Para instalar o WSL 2, abra o PowerShell como administrador e execute:

wsl --install
# Reinicie o computador e configure o Ubuntu quando solicitado

Passo 1 — Instalar o Node.js via nvm

Recomendamos usar o nvm (Node Version Manager) para gerenciar versões do Node.js. Ele permite instalar múltiplas versões e trocar entre elas facilmente. Abra o terminal e execute:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

# Recarregue o terminal (ou abra um novo), depois:
source ~/.bashrc   # ou ~/.zshrc se usar zsh

# Instale e use o Node.js 22 (LTS atual)
nvm install 22
nvm use 22
nvm alias default 22   # define como versão padrão

# Verifique:
node --version   # deve exibir v22.x.x
npm --version    # deve exibir 10.x.x

Se preferir instalar o Node.js diretamente via apt (Ubuntu), use o repositório oficial da NodeSource:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs

Passo 2 — Instalar o Claude Code

Com o Node.js configurado, instale o Claude Code globalmente via npm:

npm install -g @anthropic-ai/claude-code

Verifique a instalação:

claude --version
# Exemplo de saída: 1.x.x (claude-code)

Para atualizar o Claude Code para a versão mais recente no futuro:

npm update -g @anthropic-ai/claude-code

Passo 3 — Autenticar com a Anthropic

Você precisa de uma chave de API da Anthropic. Acesse console.anthropic.com, vá em "API Keys" e crie uma nova chave. Guarde-a com segurança — ela só é exibida uma vez.

Configure a chave como variável de ambiente:

export ANTHROPIC_API_KEY="sk-ant-sua-chave-aqui"

# Para salvar permanentemente (escolha conforme seu shell):
echo 'export ANTHROPIC_API_KEY="sk-ant-sua-chave-aqui"' >> ~/.bashrc
source ~/.bashrc

# Se usar zsh:
echo 'export ANTHROPIC_API_KEY="sk-ant-sua-chave-aqui"' >> ~/.zshrc
source ~/.zshrc

Alternativamente, ao executar o Claude Code pela primeira vez sem a variável configurada, ele pedirá para você autenticar pelo navegador — basta seguir o fluxo OAuth:

claude
# O terminal exibirá uma URL para abrir no navegador
# Após autenticar, o token é salvo automaticamente em ~/.claude/

Passo 4 — Primeiro uso com um projeto Django

Navegue até a raiz do seu projeto Django e inicie o Claude Code. É fundamental iniciar dentro do diretório do projeto para que o Claude entenda a estrutura completa:

cd meu-projeto-django
claude

O Claude irá analisar o contexto do projeto (arquivos, dependências, estrutura) e você pode começar a dar instruções em português:

> Crie um model Django para um sistema de posts de blog com título, conteúdo, slug, autor (FK para User) e data de publicação

> Gere o serializer DRF e o ViewSet para esse model Post

> Adicione o endpoint ao urls.py e rode as migrações

O Claude Code criará os arquivos, editará os existentes e executará os comandos necessários, mostrando cada passo para sua aprovação.

Comandos e atalhos essenciais

• claude — inicia o modo interativo no diretório atual
• claude "sua pergunta" — modo one-shot sem sessão interativa
• claude -p "instrução" — modo print, imprime resultado sem interação (útil em scripts)
• claude --help — lista todas as opções disponíveis
• /clear — limpa o contexto da conversa atual (mantém o CLAUDE.md)
• /exit — sai do Claude Code
• /bash — abre um subshell para executar comandos manualmente
• /memory — exibe e edita as memórias salvas pelo Claude
• /model — troca o modelo em uso (ex: para claude-3-haiku para tarefas simples)
• Ctrl+C — interrompe a tarefa atual sem sair do Claude Code

Configurando o arquivo CLAUDE.md

O CLAUDE.md é um arquivo especial que o Claude Code lê automaticamente ao iniciar em um diretório. Ele funciona como um briefing permanente do projeto — contexto, padrões de código, comandos frequentes, restrições e qualquer informação que o Claude deve sempre considerar.

Crie o arquivo na raiz do projeto:

# CLAUDE.md

## Contexto do Projeto
API Django REST Framework para gerenciamento de conteúdo.
Backend em Django 5.x + DRF + PostgreSQL.
Frontend separado em Next.js (não está neste repositório).

## Stack
- Python 3.12
- Django 5.1
- Django REST Framework 3.15
- django-allauth + dj-rest-auth para autenticação
- PostgreSQL 16
- Redis para cache e Celery

## Padrões de Código
- Sempre usar type hints em funções Python
- Models sempre com __str__ implementado
- Serializers sempre com validation explícita
- Nunca usar * em imports
- Testes com pytest (não unittest)

## Comandos Úteis
- Rodar servidor: python manage.py runserver
- Rodar testes: pytest
- Criar migrações: python manage.py makemigrations
- Aplicar migrações: python manage.py migrate
- Shell Django: python manage.py shell_plus (django-extensions)

## Estrutura de Apps
- users/ — autenticação e perfis
- content/ — posts e categorias
- api/ — configurações da API (throttling, versionamento)

## Restrições
- Nunca deletar migrações existentes
- Sempre criar migrações em transações (atomic=True)
- Variáveis de ambiente via django-environ, nunca hardcoded

Com esse arquivo, toda nova sessão do Claude Code começará com o contexto completo do projeto, sem precisar repetir as mesmas informações.

Modo --print e integração com Git

O modo --print (ou -p) é muito útil para integrar o Claude Code em workflows automatizados. Você pode usá-lo em hooks do Git, scripts de CI ou qualquer automação:

# Revisar código antes de commit (hook pre-commit)
#!/bin/bash
# .git/hooks/pre-commit

STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep '.py#x27;)

if [ -n "$STAGED_FILES" ]; then
    echo "Revisando código com Claude..."
    claude -p "Revise os seguintes arquivos Python e aponte apenas problemas críticos de segurança ou bugs: $STAGED_FILES"
fi

# Gerar mensagem de commit automaticamente
git diff --cached | claude -p "Gere uma mensagem de commit concisa em inglês para este diff"

# Documentar uma função específica
claude -p "Adicione docstrings em português ao arquivo views.py do app blog"

# Gerar relatório de dependências desatualizadas
pip list --outdated | claude -p "Quais dessas dependências são críticas atualizar e por quê?"

Workflows recomendados para Django + DRF

Ao trabalhar em um projeto Django com o Claude Code, estes workflows têm se mostrado mais produtivos:

Workflow 1 — Criar um novo recurso completo (feature end-to-end):

> Crie o recurso completo de "Categorias" para o blog:
  1. Model Category com nome, slug e descrição
  2. Serializer com validação de slug único
  3. ViewSet com permissão IsAdminUser para escrita, leitura pública
  4. Adicione o router em api/urls.py
  5. Crie a migração
  6. Registre no admin com list_display e search_fields
  7. Escreva testes com pytest para os endpoints

Workflow 2 — Debug e correção de bugs:

> O endpoint POST /api/posts/ está retornando 400 com a mensagem
  "slug already exists" mesmo quando o slug é novo.
  Analise o PostSerializer e o model Post e corrija o problema.

Workflow 3 — Refatoração segura:

> Refatore as views do app "content" para usar ViewSets ao invés de APIViews,
  mantendo todos os endpoints funcionando da mesma forma.
  Rode os testes após cada mudança para garantir que nada quebrou.

Usando MCPs para expandir capacidades

Os MCPs (Model Context Protocol servers) permitem que o Claude Code interaja com sistemas externos. Para projetos Django, os MCPs mais úteis são:

• MCP PostgreSQL: consulta diretamente o banco de dados durante o desenvolvimento
• MCP Filesystem: acesso expandido ao sistema de arquivos
• MCP GitHub: cria PRs, comenta em issues e gerencia repositórios
• MCP Sentry: analisa erros em produção diretamente no terminal

Para configurar um MCP, edite o arquivo ~/.claude/config.json:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost/mydb"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_seu_token"
      }
    }
  }
}

Dicas avançadas para Django

• Inicie sempre dentro da raiz do projeto Django para o Claude entender a estrutura completa
• Use o CLAUDE.md para documentar padrões — isso evita inconsistências entre sessões
• Peça para criar models, serializers, views e URLs em conjunto (o Claude mantém consistência)
• Use o Claude para gerar factories do factory_boy para os testes
• Peça revisões de código antes de fazer commit — o Claude identifica problemas de segurança
• Para tarefas longas, use /clear entre features para evitar contexto confuso
• Peça para o Claude rodar python manage.py check após grandes mudanças
• Use o modo interativo para exploração e -p para automações repetíveis

Perguntas Frequentes