---
title: "5 dicas para usar AI no seu dia a dia como Dev Senior"
description: "Cinco dicas praticas de como um senior usa AI no dia a dia - MCPs para contexto, escolha de modelos por tarefa, automacao de testes e docs, protecao de dados sensiveis e saber quando nao usar AI."
author: Bruno Germano
lang: pt-BR
canonical: https://egermano.com/artigos/2025-10-02-5-dicas-programar-com-ai-senior
date: "2025-10-02 10:00:00 -0300"
updated: "2026-01-14 12:00:00 +0000"
---

# 5 dicas para usar AI no seu dia a dia como Dev Senior

Uso AI diariamente no meu trabalho como desenvolvedor. Nao como hype ou experimento, mas como ferramenta de produtividade — igual uso o terminal, Git ou meu editor. Neste post, compartilho 5 praticas que adotei para extrair valor real de AI no dia a dia, sem perder qualidade ou controle do codigo.

O ponto-chave: AI e uma ferramenta, nao um substituto. Saber quando usar, qual modelo escolher e como dar contexto adequado separa quem perde tempo de quem ganha produtividade.

## 1. Use MCPs para dar contexto real ao modelo

A maior limitacao de AI e alucinacao — inventar codigo, APIs ou arquivos que nao existem. MCPs (Model Context Protocol) resolvem isso conectando o modelo diretamente ao seu ambiente.

O que muda na pratica:

- Modelo le seus arquivos reais em vez de adivinhar estrutura
- Acessa seu banco de dados para gerar queries corretas
- Consulta issues e PRs do GitHub para entender contexto
- Busca documentacao interna no Notion ou Confluence

MCPs que uso diariamente:

| MCP          | Uso                           |
| ------------ | ----------------------------- |
| Filesystem   | Ler/navegar codigo do projeto |
| GitHub       | Contexto de issues e PRs      |
| Postgres     | Gerar queries com schema real |
| Brave Search | Pesquisar docs e solucoes     |

Como configurar (exemplo para Claude Code):

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-filesystem", "/path/to/project"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-github"],
      "env": { "GITHUB_TOKEN": "seu-token" }
    }
  }
}
```

Dica: comece com filesystem apenas. Ja muda completamente a qualidade das respostas.

## 2. Escolha o modelo certo para cada tarefa

Nem toda tarefa precisa do modelo mais caro. Otimizo custo e velocidade escolhendo o modelo adequado:

| Tarefa                       | Modelo que uso                | Por que                           |
| ---------------------------- | ----------------------------- | --------------------------------- |
| Autocomplete enquanto digito | Codestral / modelo local      | Latencia baixa, custo zero        |
| Explicar codigo ou debug     | Claude Sonnet                 | Bom raciocinio, custo ok          |
| Refatoracao complexa         | Claude Sonnet                 | Equilibrio qualidade/custo        |
| Decisoes de arquitetura      | Claude Opus                   | Preciso do melhor raciocinio      |
| Gerar testes em massa        | GPT-4o-mini                   | Volume alto, qualidade suficiente |
| Tarefas simples/repeticoes   | Modelo mais barato disponivel | Nao precisa de "inteligencia"     |

Na pratica, 80% do meu uso e com Sonnet. Opus so para decisoes criticas onde erro custa caro.

Ferramentas que faciliam isso:

- **Claude Code / Cursor**: permite trocar modelo por tarefa
- **Continue.dev**: configuracao de modelos por tipo de acao
- **OpenRouter**: API unica para multiplos modelos

## 3. Automatize tarefas repetitivas

AI brilha em tarefas que sao tediosas mas seguem padroes. Identifico essas oportunidades e deixo AI fazer o trabalho pesado.

**Geracao de testes unitarios:**

Passo a funcao e o contexto, AI gera testes cobrindo casos principais e edge cases. O que levava 30 minutos vira 5 minutos (incluindo revisao).

```
"Gere testes unitarios para a funcao X.
Considere: casos de sucesso, erros de validacao, edge cases com valores nulos.
Use o padrao de testes existente em /tests como referencia."
```

**Atualizacao de documentacao:**

Depois de um PR grande, peco para AI sugerir updates no README ou docs de API baseado no diff.

```
"Analise as mudancas deste PR e sugira atualizacoes necessarias
para a documentacao em /docs. Mantenha o estilo existente."
```

**Migrations e refactors em massa:**

Renomear variaveis, atualizar imports, migrar de uma API para outra. AI aplica o padrao em dezenas de arquivos enquanto eu reviso.

```
"Refatore todos os arquivos em /src/components para usar
o novo hook useAuth em vez de useContext(AuthContext).
Mantenha o comportamento identico."
```

Regra: sempre reviso o output antes de commitar. AI acelera, mas a responsabilidade e minha.

## 4. Proteja dados sensiveis

Quando uso AI com codigo de trabalho, tomo cuidados com dados sensiveis:

**O que nunca envio:**

- Credenciais, tokens, secrets
- Dados de clientes (PII)
- Codigo proprietario critico sem autorizacao
- Informacoes de infraestrutura interna

**Como me protejo:**

- Uso modelos com politica clara de nao-treinamento (Claude, GPT-4 API)
- Prefiro modelos locais para codigo muito sensivel
- Removo dados reais antes de enviar exemplos
- Verifico politicas da empresa antes de usar ferramentas novas

Exemplo: se preciso debugar uma query com dados de cliente, substituo os valores reais por dados fake antes de colar no chat.

```sql
-- Antes (NAO enviar):
SELECT * FROM users WHERE email = 'cliente.real@empresa.com'

-- Depois (OK enviar):
SELECT * FROM users WHERE email = 'teste@exemplo.com'
```

## 5. Saiba quando NAO usar AI

AI nao e a resposta para tudo. Aprendi a reconhecer quando ela atrapalha mais do que ajuda:

**Evito AI quando:**

- Preciso aprender algo novo profundamente (AI da atalho, mas nao ensina)
- O problema exige conhecimento muito especifico do dominio
- Estou explorando solucoes e preciso pensar criativamente
- O codigo e critico e preciso entender cada linha
- A tarefa e tao simples que abrir o chat demora mais que fazer

**Prefiro AI quando:**

- Tarefa e repetitiva e segue padrao claro
- Preciso de boilerplate ou scaffold inicial
- Quero uma segunda opiniao rapida
- Estou debugando algo e quero hipoteses
- Preciso traduzir entre linguagens/frameworks

A tentacao e jogar tudo para AI. Mas tempo gasto revisando codigo ruim ou corrigindo alucinacoes as vezes e maior do que fazer do zero.

## Conclusao

Minhas 5 praticas para usar AI como senior:

1. **MCPs** - De contexto real ao modelo (filesystem, GitHub, DB)
2. **Modelo certo** - Escolha baseado na tarefa, nao no hype
3. **Automatize** - Testes, docs, refactors em massa
4. **Proteja dados** - Nunca envie secrets ou PII
5. **Saiba parar** - AI nao e resposta para tudo

A diferenca entre usar AI como junior e como senior: junior usa para tudo esperando magica; senior usa como ferramenta, sabendo exatamente quando ela agrega e quando atrapalha.

Comece por uma coisa: configure o MCP de filesystem no seu editor e veja como as respostas melhoram quando o modelo realmente "ve" seu projeto.
