Modulo 1.7 - Criando Aliases e Scripts

📖 O que sao Aliases Shell

Um alias e simplesmente um atalho de texto para um comando mais longo. Em vez de digitar git status toda vez, voce pode criar gs e economizar tempo. Para o Claude Code, aliases transformam comandos complexos com muitas flags em atalhos de duas ou tres letras.

🎯 Conceito Principal

Aliases vivem no arquivo de configuracao do seu shell: ~/.bashrc para bash ou ~/.zshrc para zsh. Quando voce adiciona um alias e recarrega o arquivo, o atalho fica disponivel em todas as sessoes de terminal.

• Sintaxe basica: alias nome='comando' - o nome substitui o comando entre aspas simples
• Persistencia: Aliases definidos diretamente no terminal sao temporarios (morrem com a sessao). Para permanentes, adicione ao ~/.zshrc ou ~/.bashrc
• Recarregar: Apos editar o arquivo, rode source ~/.zshrc (ou source ~/.bashrc) para ativar as mudancas sem abrir novo terminal
• Listar aliases: Rode alias sem argumentos para ver todos os aliases ativos. Use alias nome para ver a definicao de um especifico

⌨️ Exemplo Basico

# Criar alias temporario (morre com o terminal)
$ alias gs='git status'
$ gs # equivale a "git status"

# Criar alias permanente (adicionar ao ~/.zshrc)
$ echo "alias gs='git status'" >> ~/.zshrc
$ source ~/.zshrc

# Ver todos os aliases
$ alias
# Remover um alias
$ unalias gs

💡 Dica Pratica

Use nomes curtos e mnemonicos. cc para claude, ccp para claude -p, ccr para claude --resume. Quanto mais curto e intuitivo, mais voce vai usar.

Antes de criar um alias, verifique se o nome nao conflita com um comando existente usando which nome ou type nome. Evite sobrescrever comandos do sistema.

🚀 Aliases Basicos para Claude Code

Com aliases bem definidos, voce transforma o Claude Code de uma ferramenta que exige digitacao em uma que responde a atalhos de duas letras. Vamos criar os aliases mais uteis para o dia a dia, cobrindo os modos mais comuns de uso.

🎯 Conceito Principal

Os aliases mais valiosos para o Claude Code cobrem tres categorias: iniciar sessoes (interativa, print, resume), operacoes rapidas (review, commit, test) e diagnostico (debug, analise de logs).

• cc: Alias para claude - abrir sessao interativa rapidamente
• ccp: Alias para claude -p - modo print/pipe para one-shots
• ccr: Alias para claude --resume - retomar sessao anterior
• ccv: Alias para claude --version - verificar versao rapidamente

⌨️ Kit Basico de Aliases

# === Claude Code Aliases (adicionar ao ~/.zshrc) ===

# Sessoes
alias cc='claude'
alias ccp='claude -p'
alias ccr='claude --resume'
alias ccv='claude --version'

# Operacoes rapidas
alias ccreview='claude -p "faca code review do git diff staged" < <(git diff --staged)'
alias cctest='claude -p "analise os resultados dos testes"'
alias ccexplain='claude -p "explique este projeto em 5 linhas"'

# Diagnostico
alias ccdebug='claude -p "diagnostique este erro e sugira correcao"'
alias cclog='claude -p "analise estes logs e identifique problemas"'

💡 Dica Pratica

O alias cc e tao natural que voce vai esquecer que nao e o nome real do comando. Use cc para sessoes interativas e ccp quando precisar de one-shots.

Dica avancada: para aliases que recebem pipe, o formato e comando | cclog. O alias cclog recebe o stdin do pipe automaticamente porque o claude -p "..." ja aceita stdin.

🔧 Aliases Compostos com Argumentos

Aliases simples nao aceitam argumentos. Para criar atalhos que recebem parametros dinamicos (como nomes de arquivo, prompts customizados ou opcoes), voce precisa de funcoes shell. Funcoes funcionam como aliases turbinados: aceitam argumentos, tem logica condicional e podem executar multiplos comandos.

🎯 Conceito Principal

No shell, funcoes sao definidas com nome() { ... } e acessam argumentos via $1, $2, etc. Coloque-as no ~/.zshrc junto com seus aliases para que fiquem disponiveis em todas as sessoes.

• $1, $2, $3...: Primeiro, segundo, terceiro argumento passado para a funcao
• $@: Todos os argumentos juntos. Util para passar prompts completos com espacos
• $#: Numero de argumentos. Use para validacao e mensagens de uso
• Aspas duplas: Sempre envolva variaveis em aspas duplas ("$1") para preservar espacos e caracteres especiais

⌨️ Funcoes com Argumentos

# Funcao: pedir ao Claude para analisar qualquer arquivo
ccfile() {
cat "$1" | claude -p "${2:-analise este arquivo}"
}
# Uso: ccfile src/app.py "encontre bugs neste arquivo"
# Uso: ccfile config.yaml (usa prompt padrao)

# Funcao: review de um arquivo especifico
ccrev() {
cat "$1" | claude -p "faca code review deste arquivo focando em: ${2:-qualidade geral, seguranca e performance}"
}
# Uso: ccrev src/auth.py "seguranca e SQL injection"

# Funcao: perguntar algo ao Claude com contexto do projeto
ccask() {
claude -p "$@"
}
# Uso: ccask "qual o padrao de design usado neste projeto?"

# Funcao: gerar testes para um arquivo
cctest() {
local arquivo="$1"
local saida="${arquivo%.py}_test.py"
cat "$arquivo" | claude -p "gere testes unitarios com pytest para este codigo" > "$saida"
echo "Testes gerados em: $saida"
}
# Uso: cctest src/utils.py → gera src/utils_test.py

💡 Dica Pratica

Use ${2:-valor_padrao} para dar valores padrao a argumentos opcionais. Isso torna suas funcoes mais flexiveis: funcionam com ou sem o argumento extra.

Nomeie funcoes com o prefixo cc para manter consistencia e facilitar a memoria. ccfile, ccrev, cctest, ccask - todos comecam com "cc" para que voce saiba que envolvem Claude Code.

📜 Scripts Bash com Claude

Quando a logica fica mais complexa do que uma funcao permite, e hora de criar scripts bash dedicados. Scripts sao arquivos .sh executaveis que combinam comandos shell com chamadas ao Claude Code, adicionando tratamento de erros, loops, condicoes e variaveis de ambiente.

🎯 Conceito Principal

Um script bash e um arquivo de texto com extensao .sh que comeca com o shebang #!/bin/bash e contem comandos executaveis. Com chmod +x script.sh, ele se torna um programa executavel.

• Shebang: Sempre comece com #!/bin/bash (ou #!/usr/bin/env bash para portabilidade) na primeira linha
• set -euo pipefail: Adicione na segunda linha para tratamento rigoroso de erros. -e para na primeira falha, -u trata variaveis indefinidas como erro, -o pipefail propaga erros em pipes
• Permissao: Use chmod +x script.sh para tornar executavel. Depois rode com ./script.sh ou coloque em ~/bin/ para acessar de qualquer lugar
• Organizacao: Guarde seus scripts em ~/bin/ ou ~/.local/bin/ e adicione ao PATH para executar de qualquer diretorio

⌨️ Script: Code Review Automatizado

#!/bin/bash
# cc-review.sh - Code review automatizado com Claude Code
set -euo pipefail

# Verificar se estamos num repo git
if ! git rev-parse --is-inside-work-tree &> /dev/null; then
echo "Erro: nao estamos num repositorio git"
exit 1
fi

# Capturar diff (staged ou unstaged)
DIFF=$(git diff --staged)
if [ -z "$DIFF" ]; then
DIFF=$(git diff)
fi

if [ -z "$DIFF" ]; then
echo "Nenhuma mudanca para revisar."
exit 0
fi

# Enviar para o Claude
echo "$DIFF" | claude -p "Faca code review detalhado. Aponte: bugs, seguranca, performance, legibilidade. Formato: Markdown com severidade (critico/alto/medio/baixo)." | tee review-$(date +%Y%m%d).md

echo "Review salvo em review-$(date +%Y%m%d).md"

💡 Dica Pratica

Sempre adicione set -euo pipefail nos seus scripts. Sem isso, erros silenciosos podem causar comportamento inesperado. Por exemplo, se claude -p falhar por falta de autenticacao, o script continuaria executando os proximos comandos com dados vazios.

Mantenha seus scripts em um repo git dedicado (ex: ~/dotfiles/scripts/) para versionamento e sincronizacao entre maquinas.

🧩 Funcoes Shell Avancadas

Funcoes avancadas combinam logica condicional, loops, integracao com git e processamento de dados para criar workflows completos. Estas funcoes vao alem de simples atalhos: elas automatizam fluxos de trabalho inteiros com o Claude Code.

🎯 Conceito Principal

Funcoes avancadas usam recursos do shell como variaveis locais, substituicao de comando ($(...)), condicoes (if/elif/else), loops (for/while) e redirecionamento para criar fluxos sofisticados.

• Variaveis locais: Use local var=valor dentro de funcoes para evitar poluir o escopo global
• Substituicao de comando: resultado=$(comando) captura a saida de um comando em uma variavel
• Integracao com git: Funcoes que combinam git log, git diff e Claude para analises automatizadas do repositorio
• Validacao de entrada: Sempre verifique se os argumentos necessarios foram fornecidos antes de chamar o Claude

⌨️ Funcoes Avancadas

# Funcao: commit inteligente (gera mensagem com Claude)
cccommit() {
local diff=$(git diff --staged)
if [ -z "$diff" ]; then
echo "Nada no staging. Use 'git add' primeiro."
return 1
fi
local msg=$(echo "$diff" | claude -p "gere uma mensagem de commit concisa em ingles seguindo conventional commits. Apenas a mensagem, sem explicacao.")
echo "Mensagem sugerida: $msg"
read -p "Usar esta mensagem? [Y/n] " resposta
if [[ "$resposta" != "n" ]]; then
git commit -m "$msg"
fi
}

# Funcao: analise de qualidade do projeto
ccquality() {
local dir="${1:-.}"
echo "Analisando $dir..."
{
echo "=== Estrutura ==="
find "$dir" -type f -name "*.py" -o -name "*.js" -o -name "*.ts" | head -30
echo "=== TODOs ==="
grep -rn "TODO\|FIXME" "$dir" --include="*.py" --include="*.js" 2>/dev/null | head -20
echo "=== Git Stats ==="
git log --oneline -10 2>/dev/null
} | claude -p "Com base nesta visao geral, avalie a qualidade do projeto e sugira 5 melhorias prioritarias"
}

💡 Dica Pratica

A funcao cccommit e um game-changer. Nunca mais perca tempo pensando na mensagem de commit - o Claude analisa o diff e sugere uma mensagem precisa seguindo conventional commits. Voce so confirma e pronto.

Use return 1 (nao exit 1) dentro de funcoes. exit fecha o terminal inteiro; return sai apenas da funcao.

📂 Organizacao do .zshrc/.bashrc

Conforme voce adiciona mais aliases e funcoes, o arquivo de configuracao do shell pode ficar bagunçado e dificil de manter. Uma boa organizacao garante que voce encontre, edite e compartilhe seus atalhos facilmente. Vamos ver as melhores praticas para manter tudo limpo e modular.

🎯 Conceito Principal

A melhor pratica e modularizar seu arquivo de configuracao. Em vez de colocar tudo no ~/.zshrc, separe aliases e funcoes em arquivos dedicados e use source para carrega-los.

• Arquivo dedicado: Crie ~/.claude_aliases com todos os aliases e funcoes do Claude Code. No ~/.zshrc, adicione source ~/.claude_aliases
• Secoes com comentarios: Use blocos de comentarios para separar categorias: # === Git ===, # === Claude Code ===, # === Docker ===
• Dotfiles repo: Mantenha seus arquivos de configuracao num repositorio git (~/ dotfiles) para versionamento, backup e sincronizacao entre maquinas
• Condicao de existencia: Use [ -f ~/.claude_aliases ] && source ~/.claude_aliases para evitar erros se o arquivo nao existir

⌨️ Estrutura Recomendada

# ~/.zshrc (arquivo principal - limpo e organizado)

# === Configuracoes basicas ===
export EDITOR=vim
export PATH="$HOME/bin:$HOME/.local/bin:$PATH"

# === Carregar modulos ===
[ -f ~/.aliases ] && source ~/.aliases
[ -f ~/.claude_aliases ] && source ~/.claude_aliases
[ -f ~/.git_aliases ] && source ~/.git_aliases
[ -f ~/.functions ] && source ~/.functions

# === Plugins e frameworks ===
# ... oh-my-zsh, starship, etc.

⌨️ Arquivo ~/.claude_aliases

# ~/.claude_aliases - Aliases e funcoes do Claude Code
# Atualizado: 2026-03-08

# === Sessoes ===
alias cc='claude'
alias ccp='claude -p'
alias ccr='claude --resume'

# === Funcoes de Analise ===
ccfile() { cat "$1" | claude -p "${2:-analise este arquivo}"; }
ccrev() { cat "$1" | claude -p "code review: ${2:-geral}"; }

# === Funcoes Git + Claude ===
cccommit() { ... }
ccquality() { ... }

# === Diagnostico ===
alias ccdebug='claude -p "diagnostique este erro"'

💡 Dica Pratica

Use um repositorio dotfiles no GitHub para versionar todos os seus arquivos de configuracao. Assim, quando configurar uma maquina nova, basta clonar o repo e rodar um script de setup para ter todos os seus aliases e funcoes prontos.

Compartilhe seus aliases uteis com colegas! Um arquivo .claude_aliases bem organizado pode acelerar a adocao do Claude Code por toda a equipe.

★

🏋️ Exercicio Pratico

Neste exercicio voce vai criar 5 aliases uteis no seu .zshrc ou .bashrc para o Claude Code, organizados num arquivo dedicado. Ao final, voce tera um kit de produtividade personalizado.

🏋️

Exercicio: Criar 5 Aliases Uteis para Claude Code

Tempo estimado: 15-20 minutos

Criar arquivo dedicado de aliases

Crie o arquivo ~/.claude_aliases:

$ touch ~/.claude_aliases
$ echo "# Claude Code Aliases - $(date +%Y-%m-%d)" > ~/.claude_aliases

Adicionar os 5 aliases essenciais

Abra o arquivo no editor e adicione:

$ cat >> ~/.claude_aliases << 'EOF'
alias cc='claude'
alias ccp='claude -p'
alias ccr='claude --resume'
ccfile() { cat "$1" | claude -p "${2:-analise este arquivo}"; }
cccommit() { git diff --staged | claude -p "gere mensagem de commit concisa em ingles, conventional commits, apenas a mensagem"; }
EOF

Integrar ao .zshrc/.bashrc

Adicione a linha de source ao seu arquivo de configuracao:

$ echo '[ -f ~/.claude_aliases ] && source ~/.claude_aliases' >> ~/.zshrc
$ source ~/.zshrc

Testar os aliases

Verifique que todos funcionam:

$ alias cc # deve mostrar cc='claude'
$ type ccfile # deve mostrar a funcao
$ ccfile ~/.zshrc "resuma em 3 linhas"

Adicionar seu proprio alias personalizado

Crie um alias que seja util para o SEU fluxo de trabalho especifico:

# Exemplo: alias para o framework que voce usa
$ echo 'alias ccnext="claude -p \"analise este projeto Next.js e sugira otimizacoes\""' >> ~/.claude_aliases
$ source ~/.claude_aliases

✅ Criterios de Sucesso

☐ Arquivo ~/.claude_aliases criado

☐ 5 aliases/funcoes definidos

☐ Source integrado ao .zshrc

☐ Todos testados e funcionando

📋 Resumo do Modulo

✓

Aliases sao atalhos de texto para comandos longos - Definidos no ~/.zshrc ou ~/.bashrc, persistem entre sessoes com source.

✓

cc, ccp, ccr sao os aliases essenciais - Sessao interativa, modo print e resume com atalhos de duas letras.

✓

Funcoes aceitam argumentos dinamicos - Use $1, $2, $@ para criar atalhos flexiveis como ccfile e ccrev.

✓

Scripts bash adicionam logica complexa - Tratamento de erros, condicoes, loops e integracao com git em arquivos .sh.

✓

Funcoes avancadas automatizam workflows completos - cccommit gera mensagens de commit, ccquality analisa projetos inteiros.

✓

Organizacao modular mantem tudo limpo - Arquivo dedicado ~/.claude_aliases com source condicional e dotfiles versionado.

Proximo Modulo:

1.8 - Modo Headless e Automacao CLI

← Modulo Anterior Voltar para Trilha Proximo Modulo →