Aprenda a usar o programador de IA mais poderoso do mundo. Prometemos: se você tem 12 anos e nunca tocou num terminal, você vai conseguir.
Imagina que você tem um amigo hacker gênio que sabe programar em todas as linguagens do mundo. Você fala em português normal para ele: "cria um site para mim" ou "conserta esse bug" — e ele escreve o código inteiro. Claude Code é esse amigo, mas no seu terminal.
Claude Code é uma ferramenta de linha de comando (CLI) criada pela Anthropic que coloca uma IA superinteligente direto no seu terminal. Você escreve o que quer em português, ela entende o seu projeto, lê os arquivos, escreve código, roda comandos e resolve problemas.
A diferença para o ChatGPT comum? Claude Code vê os seus arquivos reais, edita eles, roda comandos no seu computador e mantém contexto de projetos inteiros.
Você não copia e cola código. A IA abre os arquivos, lê, escreve, testa e corrige — tudo sozinha. Você só fala o que quer.
Antes de jogar um jogo, você instala ele. Aqui é igual — a gente instala duas coisas: o motor (Node.js) e o jogo em si (Claude Code).
node --version
npm --version
# Deve aparecer algo como: v22.0.0 e 10.x.x
npm install -g @anthropic-ai/claude-code
-g significa "global" — instala em todo o computador, não só numa pasta.claude
# Vai aparecer uma tela de login — siga as instruções na tela
✓ Logged in você está pronto! Se der erro, veja a seção de dicas abaixo.O terminal é tipo o cockpit de um avião. Parece complicado de cara, mas tem só uns 5 comandos que você usa 99% do tempo. A gente vai aprender esses 5 agora.
Antes de abrir o Claude Code, você precisa navegar até a pasta do seu projeto no terminal. O Claude Code vai ler tudo que estiver na pasta onde você o abrir.
Depois de ir para a pasta do seu projeto, abra o Claude Code com:
# 1. Navegue até a pasta do projeto
cd Downloads/meu-projeto
# 2. Abra o Claude Code
claude
# Vai aparecer o prompt interativo:
# > █ (cursor piscando esperando você digitar)
claude.Agora é só escrever em português o que você quer. Exemplos:
# Dentro do Claude Code, você digita:
> Explica o que esse projeto faz
> Cria um arquivo index.html com um site simples de portfólio
> Tem algum bug aparente nesse código?
> Adiciona um botão de "Voltar ao topo" no site
Slash commands são como cheats de jogo. Em vez de escrever uma instrução longa, você digita um atalho que começa com / e a IA executa uma ação especial instantaneamente.
Sempre que travar ou não souber o que fazer, digite /help. Ele mostra tudo que o Claude Code consegue fazer no momento.
Você também pode usar o ! (exclamação) para rodar qualquer comando do terminal sem sair do Claude Code:
! ls # lista arquivos da pasta
! npm install # instala dependências
! git status # vê o estado do Git
! node index.js # roda seu arquivo
Atalhos de teclado são como os combos do Street Fighter. Parece difícil aprender, mas depois que aprende, você não consegue trabalhar sem eles.
Modos de permissão — o que a IA pode fazer sozinha:
# Modo automático (aprova tudo — use com cuidado!)
claude --dangerously-skip-permissions
# Alternativa mais segura
claude --permission-mode auto
Imagine que você está dando uma missão para um super-herói. Se você fala "faz alguma coisa útil", ele fica perdido. Mas se você fala "vai ao endereço X, salva a pessoa Y, sem usar poderes Z" — ele executa perfeitamente. Quanto mais contexto você dá, melhor o resultado.
A fórmula de um bom prompt tem 4 partes:
# [CONTEXTO] + [AÇÃO] + [DETALHES] + [FORMATO]
# Exemplo fraco (não faça isso):
> cria um site
# Exemplo forte (faça isso):
> Estou criando um portfólio pessoal para um designer gráfico.
Cria um index.html com: header com nome e foto, seção de
projetos com 3 cards, e footer com links do Instagram e
LinkedIn. Usa cores escuras (fundo #0F0F0F) e tipografia
sans-serif moderna.
Palavras mágicas que melhoram qualquer prompt:
Imagina que você contratou um funcionário novo todo dia. Toda manhã você teria que explicar tudo de novo: "o projeto é isso, as regras são essas, não faça aquilo". O CLAUDE.md é o manual que você escreve uma vez — e o Claude lê automaticamente toda vez que é aberto no seu projeto.
O arquivo CLAUDE.md fica na raiz do seu projeto e é lido automaticamente toda vez que o Claude Code é iniciado naquela pasta. Você pode ter um global (para tudo) e um por projeto.
# Dentro do Claude Code, rode:
/init
# Ele analisa o projeto e cria um CLAUDE.md com o que encontrou.
# Depois você edita e personaliza.
Exemplo de um bom CLAUDE.md:
# Meu Projeto
## O que é isso
Site de portfólio pessoal em React + Vite.
URL de produção: meusite.com
## Stack
- Frontend: React 18 + TypeScript + Tailwind CSS
- Deploy: Vercel
- Banco: não tem
## Regras IMPORTANTES
- NUNCA altere as cores definidas em tailwind.config.js
- Sempre use TypeScript (nunca .js puro)
- Commits em português
- Não instale novas dependências sem me perguntar
## Como rodar
npm run dev → servidor local
npm run build → build de produção
npm run preview → preview do build
## Estrutura das pastas
src/components/ → componentes reutilizáveis
src/pages/ → páginas
src/hooks/ → custom hooks
public/ → imagens e assets estáticos
CLAUDE.md global em ~/.claude/CLAUDE.md com regras que valem para todos os seus projetos — tipo preferências pessoais, idioma, estilo de código.Essa é a seção mais prática. São prompts testados que funcionam muito bem. Copie, adapte com os seus dados e use.
# Verificar Node.js
node --version
# Instalar Claude Code
npm install -g @anthropic-ai/claude-code
# Verificar instalação
claude --version
# Iniciar (vai pedir login na primeira vez)
claude
# 1. Entra na pasta do projeto
cd Downloads/meu-projeto
# 2. Abre o Claude Code
claude
# 3. Dentro do Claude Code, usa esses comandos:
/help # vê o que pode fazer
/status # vê quanto de contexto usou
/clear # começa uma nova tarefa
/commit # salva as alterações no Git
# Atualiza para a versão mais recente
npm update -g @anthropic-ai/claude-code
# Confirma a versão atualizada
claude --version
Imagina que você está construindo um castelo. Você pode deixar a porta aberta e confiar em todo mundo — ou pode colocar grades, câmeras e um alarme. As automações são as câmeras. A segurança são as grades. Você faz isso uma vez e dorme tranquilo.
Git é o sistema de controle de versões — basicamente o histórico de tudo que foi feito no seu projeto. Cada "commit" é um ponto de salvamento que você pode voltar se algo quebrar.
# Configura quem você é (faz só uma vez)
git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"
git config --global init.defaultBranch main
# Entra na pasta e inicializa o Git
cd meu-projeto
git init
# Adiciona todos os arquivos ao controle
git add .
# Cria o primeiro ponto de salvamento
git commit -m "primeiro commit"
# Vê o que mudou
git status
# Adiciona tudo
git add .
# Salva com uma mensagem (descreva o que você fez)
git commit -m "adiciona página de contato"
# Envia para o GitHub (backup na nuvem)
git push
/commit que ele faz tudo isso sozinho — analisa as mudanças, cria a mensagem certa e commita.O arquivo .gitignore lista arquivos que o Git deve ignorar completamente — senhas, tokens, configurações locais, pastas pesadas como node_modules.
# Dependências (muito pesado para commitar)
node_modules/
.pnp
.pnp.js
# Variáveis de ambiente (SENHAS E TOKENS — nunca commitar!)
.env
.env.local
.env.production
.env*.local
# Builds gerados
dist/
build/
.next/
out/
# Sistema operacional
.DS_Store # Mac
Thumbs.db # Windows
desktop.ini # Windows
# Editor
.vscode/
.idea/
*.swp
# Logs
*.log
npm-debug.log*
Nunca escreva senhas, chaves de API ou tokens diretamente no código. Use um arquivo .env — ele fica só na sua máquina, nunca vai para o Git.
# Crie um arquivo chamado .env na raiz do projeto
# Formato: NOME_DA_VARIAVEL=valor (sem espaços)
ANTHROPIC_API_KEY=sk-ant-...
DATABASE_URL=postgresql://...
SECRET_TOKEN=minha-senha-secreta
PORT=3000
.env NUNCA vai para o GitHub. Adicione-o ao .gitignore imediatamente. Se você acidentalmente commitar senhas, troque-as na hora — alguém pode estar varrendo o GitHub em busca exatamente disso.Hooks são ações automáticas que o Claude Code executa em momentos específicos — antes de rodar um comando, depois de criar um arquivo, ao iniciar a sessão, etc. Você configura uma vez e eles rodam sempre.
# Windows:
C:\Users\SeuNome\.claude\settings.json
# Mac:
~/.claude/settings.json
# Abrir para editar:
# Windows: notepad %USERPROFILE%\.claude\settings.json
# Mac: open ~/.claude/settings.json
{
"hooks": {
// Roda git add automaticamente após cada edição de arquivo
"PostToolUse": [
{
"matcher": "Write|Edit",
"hooks": [
{
"type": "command",
"command": "git add -A && git status"
}
]
}
],
// Registra quando a sessão foi encerrada
"Stop": [
{
"hooks": [
{
"type": "command",
"command": "echo Sessao encerrada >> ~/.claude/sessoes.log"
}
]
}
]
}
}
GitHub é onde você guarda seus projetos online. Se seu computador quebrar, o projeto está salvo. E com o comando abaixo, tudo sincroniza automaticamente.
# 1. Cria o repositório em github.com (botão New)
# 2. Conecta a pasta local ao GitHub:
git remote add origin https://github.com/seu-usuario/repo.git
git branch -M main
git push -u origin main
# A partir daí, para subir atualizações:
git add .
git commit -m "descreva o que fez"
git push
npm update -g @anthropic-ai/claude-codegit commit -m "backup antes da refatoração"# Ver se .env foi commitado alguma vez
git log --all --full-history -- .env
# Buscar senhas nos commits (segurança)
git grep -i "password\|secret\|token\|api_key"
Se você tem um servidor ou VPS, o PM2 mantém seu app rodando mesmo se você fechar o terminal ou o servidor reiniciar.
# Instalar PM2
npm install -g pm2
# Iniciar uma aplicação
pm2 start server.js --name meu-app
# Ver apps rodando
pm2 list
# Ver logs em tempo real
pm2 logs meu-app
# Reiniciar / Parar
pm2 restart meu-app
pm2 stop meu-app
# Salvar estado (sobrevive ao reboot do servidor)
pm2 save
pm2 startup
Imagina ter o Claude direto no seu WhatsApp ou Telegram. Você manda uma mensagem de voz ou texto, ele responde, escreve código, explica coisa — tudo dentro do chat. É isso que você vai construir aqui.
O Telegram permite criar bots com uma API oficial e gratuita. É o caminho mais fácil.
/newbot
# Dá um nome para o bot: Ex: Meu Assistente Claude
# Dá um username (termina em bot): meuclaudebot
# Ele retorna seu TOKEN — guarde com cuidado!
# Ex: 7412345678:AAHxxxxxxxxxxxxxxxxxxxxxxx
cd Downloads
mkdir claude-telegram-bot
cd claude-telegram-bot
npm init -y
npm install node-telegram-bot-api @anthropic-ai/sdk dotenv
cd ~/Downloads
mkdir claude-telegram-bot && cd claude-telegram-bot
npm init -y
npm install node-telegram-bot-api @anthropic-ai/sdk dotenv
TELEGRAM_TOKEN=7412345678:AAHxxxxxxxxxxxxx
ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxxx
require('dotenv').config();
const TelegramBot = require('node-telegram-bot-api');
const Anthropic = require('@anthropic-ai/sdk');
const bot = new TelegramBot(process.env.TELEGRAM_TOKEN, { polling: true });
const claude = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
// Histórico de conversa por usuário
const historico = {};
bot.on('message', async (msg) => {
const chatId = msg.chat.id;
const texto = msg.text;
if (!texto) return;
if (texto === '/start') {
historico[chatId] = [];
return bot.sendMessage(chatId, 'Olá! Sou o Claude. Como posso ajudar?');
}
if (texto === '/clear') {
historico[chatId] = [];
return bot.sendMessage(chatId, 'Conversa reiniciada!');
}
if (!historico[chatId]) historico[chatId] = [];
historico[chatId].push({ role: 'user', content: texto });
try {
bot.sendChatAction(chatId, 'typing');
const resposta = await claude.messages.create({
model: 'claude-haiku-4-5-20251001',
max_tokens: 1024,
messages: historico[chatId],
});
const reply = resposta.content[0].text;
historico[chatId].push({ role: 'assistant', content: reply });
bot.sendMessage(chatId, reply);
} catch (err) {
bot.sendMessage(chatId, 'Erro: ' + err.message);
}
});
console.log('Bot rodando...');
node bot.js
# Bot rodando...
# Agora vá no Telegram e mande uma mensagem para seu bot!
/start. Funciona!WhatsApp não tem API oficial gratuita para bots pessoais. A solução mais simples e legal é via Twilio (gratuito para testes) ou via Evolution API (open source, para VPS).
mkdir claude-whatsapp-bot && cd claude-whatsapp-bot
npm init -y
npm install twilio @anthropic-ai/sdk express dotenv
TWILIO_ACCOUNT_SID=ACxxxxxxxxxxxxxxxxxxxxxxx
TWILIO_AUTH_TOKEN=xxxxxxxxxxxxxxxxxxxxxxxxx
TWILIO_WHATSAPP_FROM=whatsapp:+14155238886
ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxxx
PORT=3000
require('dotenv').config();
const express = require('express');
const twilio = require('twilio');
const Anthropic = require('@anthropic-ai/sdk');
const app = express();
app.use(express.urlencoded({ extended: true }));
const client = twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);
const claude = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const historico = {};
app.post('/webhook', async (req, res) => {
const from = req.body.From;
const texto = req.body.Body;
if (!historico[from]) historico[from] = [];
historico[from].push({ role: 'user', content: texto });
const resposta = await claude.messages.create({
model: 'claude-haiku-4-5-20251001',
max_tokens: 1024,
messages: historico[from],
});
const reply = resposta.content[0].text;
historico[from].push({ role: 'assistant', content: reply });
await client.messages.create({
from: process.env.TWILIO_WHATSAPP_FROM,
to: from,
body: reply,
});
res.sendStatus(200);
});
app.listen(process.env.PORT, () => console.log('Servidor na porta ' + process.env.PORT));
# Terminal 1 — roda o bot
node server.js
# Terminal 2 — expõe para internet (instale ngrok.com)
ngrok http 3000
# Ngrok vai te dar uma URL como:
# https://abc123.ngrok.io
# No painel Twilio → Sandbox → Webhook URL:
# cole: https://abc123.ngrok.io/webhook
pm2 start server.js --name whatsapp-bot) e aponte o webhook do Twilio para o IP/domínio da VPS. Aí fica online 24/7 sem precisar do ngrok.1. Seja específico. Quanto mais contexto, melhor o resultado.
2. Um passo de cada vez. Não peça 10 coisas numa mensagem só.
3. Peça o plano antes de executar. Fale "me mostra o que vai fazer antes" em ações arriscadas.
4. Use /clear quando terminar uma tarefa e começar outra.
5. Mantenha o CLAUDE.md atualizado. Quanto mais informação ele tiver sobre o projeto, mais inteligente será a ajuda.