---
title: "3 ferramentas para desenvolver com AI que não são modelos nem agentes"
description: "Conheça três ferramentas para desenvolvimento com AI que não são modelos ou agentes: GitKraken para revisar mudanças, Docker para criar ambientes reproduzíveis e Bruno para validar APIs."
author: Bruno Germano
lang: pt-BR
canonical: https://egermano.com/artigos/2026-07-21-3-ferramentas-desenvolvimento-com-ai
date: "2026-07-21 10:00:00 -0300"
updated: "2026-07-21 10:00:00 -0300"
---

# 3 ferramentas para desenvolver com AI que não são modelos nem agentes

Quando alguém fala em **ferramentas para desenvolvimento com AI**, a lista quase sempre começa com modelos, chats e agentes. Só que gerar código mais rápido resolve apenas uma parte do trabalho. Você ainda precisa entender o que mudou, executar o projeto sem transformar sua máquina em um laboratório de dependências e verificar se o resultado realmente funciona.

É aí que entram três ferramentas que não substituem seu modelo nem escrevem o projeto por você: **GitKraken, Docker e Bruno**. Juntas, elas criam um fluxo simples: revisar, executar e validar.

## AI acelera a escrita, não garante o resultado

Com AI, é fácil sair de uma ideia para dezenas de arquivos em poucos minutos. Também é fácil aceitar uma alteração grande sem perceber que ela removeu uma validação, instalou uma dependência desnecessária ou mudou um contrato da API.

O problema não é exclusivo de quem está começando. A escala muda, mas a responsabilidade continua:

- **Iniciantes** precisam enxergar o que aconteceu para aprender e conseguir desfazer erros.
- **Vibe coders** se beneficiam de pontos claros de revisão e recuperação para experimentar com mais confiança.
- **Engenheiros experientes** precisam reduzir o custo de revisão e manter o fluxo reproduzível para o time.

Por isso, mais importante do que adicionar outra AI ao processo é fortalecer o ciclo de feedback ao redor dela.

| Etapa | Pergunta | Ferramenta |
| --- | --- | --- |
| Revisar | O que realmente mudou? | GitKraken |
| Executar | Este projeto roda em um ambiente previsível? | Docker |
| Validar | A API responde como deveria? | Bruno |

## 1. GitKraken: enxergue antes de aceitar

Git não é apenas um lugar para guardar código. No desenvolvimento com AI, ele é seu mecanismo de controle.

O [GitKraken Desktop](https://www.gitkraken.com/git-client?ref=egermano.com) transforma branches, commits e alterações em uma interface visual. Você consegue abrir o diff de um arquivo, comparar dois commits, selecionar o que entra no próximo commit e acompanhar onde cada branch começou. A ferramenta também oferece visualizações inline, por blocos e lado a lado.

![GitKraken Desktop exibindo o diff de um arquivo e a lista de alterações de um commit](../../assets/images/3-ferramentas-desenvolvimento-com-ai/gitkraken.webp)

_GitKraken Desktop com a visualização de diff. Fonte: documentação oficial do GitKraken._

O GitKraken possui recursos próprios ligados a AI, mas esse não é o ponto aqui. O valor mais importante para este fluxo está nas funções tradicionais de Git: **visualizar, selecionar, comparar e recuperar mudanças**.

Não é a primeira vez que recomendo o GitKraken por aqui ou em conteúdos de outras redes. Uso e gosto da ferramenta desde as primeiras versões, e foi justamente essa admiração que me levou ao programa de embaixadores. Em outras palavras, não passei a usar porque virei embaixador: virei embaixador porque já considerava a ferramenta genial. De quebra, ainda passei a fazer parte de uma comunidade incrível de embaixadores ao redor do mundo.

### Como ele ajuda quem está começando

Comandos como `rebase`, `reset` e `cherry-pick` podem parecer abstratos quando você só vê o terminal. O grafo transforma o histórico em algo concreto.

Você começa a perceber que:

- uma branch é um ponteiro para uma linha de trabalho;
- um commit deve representar uma mudança coerente;
- arquivos modificados não precisam entrar todos no mesmo commit;
- voltar atrás não significa apagar o projeto inteiro.

Essa visão reduz o medo de Git sem esconder os conceitos. Use a interface, mas procure entender qual operação ela executa.

### Como ele ajuda vibe coders

Se você pediu "crie autenticação" e recebeu mudanças em 24 arquivos, vale abrir o diff e revisar o conjunto antes de aceitar tudo e seguir para o deploy.

Procure especialmente por:

- arquivos de ambiente com tokens ou segredos;
- dependências adicionadas ao projeto;
- migrations e mudanças no banco;
- validações removidas;
- arquivos sem relação com o pedido;
- código comentado ou duplicado.

O diff é o momento em que código gerado deixa de ser uma resposta da AI e passa a ser uma mudança sob sua responsabilidade.

### Como ele ajuda engenheiros experientes

Para quem já domina Git no terminal, a vantagem não é capacidade, é compressão visual. Comparar commits, inspecionar uma branch longa ou separar alterações em commits menores pode exigir menos contexto mental no grafo.

Um hábito simples é revisar o WIP antes de executar testes:

1. Separe alterações de comportamento das mudanças cosméticas.
2. Descarte arquivos que a AI tocou sem necessidade.
3. Crie commits pequenos, cada um com uma intenção.
4. Só então rode a validação completa.

Se algo quebrar, você terá pontos de retorno claros em vez de um commit chamado `AI changes` com metade do projeto dentro.

Quer visualizar melhor as mudanças geradas pela AI? [Experimente o GitKraken pelo meu link de indicação](https://gitkraken.cello.so/reVlGevUA45?ref=egermano.com). Além de conhecer a ferramenta que uso e recomendo, você também apoia meu trabalho como embaixador. Comece revisando o diff do seu próximo projeto antes de fazer o commit.

## 2. Docker: torne o ambiente reproduzível

Código gerado pode assumir uma versão diferente do Node.js, depender de um banco que você não instalou ou pedir serviços que conflitam com o que já está rodando na sua máquina.

O [Docker](https://www.docker.com/?ref=egermano.com) ajuda a colocar esses componentes em contêineres: processos isolados com seus próprios arquivos e dependências. Com Docker Compose, você descreve aplicação, banco, filas, redes e volumes em um arquivo YAML e inicia a pilha com um comando.

![Docker Desktop exibindo a lista e o estado dos contêineres locais](../../assets/images/3-ferramentas-desenvolvimento-com-ai/docker.webp)

_Docker Desktop com o painel de contêineres. Fonte: site oficial do Docker._

```bash
docker compose up --build
```

Isso não significa que todo código desconhecido se torna seguro. Contêiner é uma camada de isolamento, não uma autorização para executar qualquer coisa sem revisar. Ainda leia o `Dockerfile`, o arquivo de Compose, os volumes montados e as portas expostas.

### Como ele ajuda quem está começando

Docker evita o clássico "na minha máquina funciona" e ajuda você a entender quais peças formam uma aplicação.

Em vez de instalar três versões de banco e configurar tudo manualmente, você pode subir um PostgreSQL temporário:

```bash
docker run --name app-postgres \
  -e POSTGRES_PASSWORD=desenvolvimento \
  -p 5432:5432 \
  -d postgres:17
```

O comando não elimina a necessidade de aprender banco ou infraestrutura. Ele apenas cria um ponto de partida descartável e repetível.

### Como ele ajuda vibe coders

Projetos gerados em conversas diferentes costumam chegar com versões e instruções inconsistentes. Um `compose.yaml` bem definido transforma "acho que precisa de um banco" em uma especificação executável.

Antes de pedir outra correção à AI, confirme o básico:

```bash
docker compose config
docker compose up --build
docker compose ps
docker compose logs
```

Esses comandos respondem quatro perguntas: a configuração é válida, a imagem constrói, os serviços estão de pé e o que falhou durante a execução?

### Como ele ajuda engenheiros experientes

Para um time, o benefício está na consistência entre desenvolvimento, testes e CI. O mesmo conjunto de serviços pode acompanhar o repositório e reduzir instruções manuais no onboarding.

AI também fica mais útil quando o ambiente tem comandos previsíveis. Em vez de explicar toda a configuração no prompt, você pode apontar para o Compose e pedir uma ação específica: "suba os serviços, rode os testes no contêiner da API e analise apenas as falhas".

## 3. Bruno: transforme respostas de API em testes

Uma tela carregar não prova que sua aplicação está correta. Uma API pode retornar `200` com dados incompletos, expor campos internos ou aceitar entradas inválidas.

O [Bruno](https://www.usebruno.com/?ref=egermano.com) é um cliente de APIs offline-first e amigável ao Git. As coleções são armazenadas como arquivos de texto, então podem ficar no mesmo repositório, passar por code review e acompanhar as mudanças da aplicação.

Antes de continuar, preciso reconhecer uma decisão técnica impecável: o nome é lindo. Uma opinião completamente imparcial, claro. Piada à parte, é o tipo de projeto que eu vejo com admiração e penso: eu gostaria de ter criado algo assim ou, pelo menos, participado da construção.

![Bruno exibindo uma requisição GET e a resposta JSON da API do GitHub](../../assets/images/3-ferramentas-desenvolvimento-com-ai/bruno.webp)

_Bruno com uma requisição e sua resposta JSON. Fonte: documentação oficial do Bruno._

Você pode começar enviando uma requisição manual e depois adicionar uma asserção:

```javascript
test("retorna o usuário autenticado", function () {
  expect(res.getStatus()).to.equal(200);
  expect(res.getBody()).to.have.property("id");
  expect(res.getBody()).to.have.property("email");
});
```

Com o Bruno CLI, a mesma coleção pode rodar no terminal ou no pipeline de CI.

```bash
bru run --env Local
```

### Como ele ajuda quem está começando

O Bruno deixa visível a conversa entre frontend e backend: URL, método, headers, corpo enviado, status e resposta.

Em vez de dizer "o login não funciona", você consegue investigar:

- a requisição usa `POST`?
- o JSON tem os campos corretos?
- o token está no header?
- a API retorna `401`, `404` ou `500`?
- o formato da resposta corresponde ao que a tela espera?

Essa precisão melhora tanto seu aprendizado quanto o prompt que você envia para a AI.

### Como ele ajuda vibe coders

AI é muito boa em produzir uma rota que parece correta. Bruno ajuda a verificar o contrato sem depender da aparência da interface.

Crie uma pequena coleção com os caminhos críticos:

1. cadastro;
2. login;
3. consulta de perfil;
4. atualização de dados;
5. tentativa sem autenticação.

Depois de cada alteração grande, rode a coleção. Você troca "parece funcionar" por evidência repetível.

### Como ele ajuda engenheiros experientes

Como as coleções são arquivos versionáveis, mudanças de endpoint podem ser revisadas junto com o código. Testes podem validar status, headers, corpo e até JSON Schema.

Isso cria um contrato vivo e reduz a distância entre exploração manual e automação. Uma requisição usada durante o debug pode virar teste e depois entrar no CI, sem precisar recomeçar em outra ferramenta.

## Um fluxo prático usando as três ferramentas

Imagine que você pediu para uma AI adicionar recuperação de senha.

### 1. Revise no GitKraken

Confira arquivos alterados, novas dependências, migrations e variáveis de ambiente. Separe a mudança em commits menores, por exemplo: banco, endpoint, interface e testes.

### 2. Execute com Docker

Reconstrua o ambiente e suba aplicação, banco e serviço de e-mail local. Verifique logs e confirme que uma instalação limpa funciona, não apenas sua máquina já configurada.

### 3. Valide com Bruno

Teste o caminho feliz e os erros: e-mail inexistente, token expirado, senha inválida e tentativa de reutilizar o mesmo token. Salve as requisições junto do projeto.

### 4. Volte para a AI com evidências

Se houver um problema, não envie "não funcionou". Envie o commit relevante, o comando executado e a resposta que violou o contrato esperado. Contexto objetivo tende a produzir correções melhores e mais baratas.

## Qual instalar primeiro?

Não instale tudo apenas para montar uma coleção de ícones na sua máquina. Comece pelo seu gargalo:

- **Você não sabe o que a AI alterou?** Comece pelo GitKraken.
- **O projeto só funciona depois de uma sequência misteriosa de instalações?** Comece pelo Docker.
- **A interface abre, mas os dados estão errados?** Comece pelo Bruno.

Depois, conecte as três etapas. O objetivo não é criar um processo pesado. É construir uma rede de proteção proporcional à velocidade com que você gera mudanças.

## A melhor ferramenta de AI pode não ter AI

Modelos e agentes aceleram a produção. GitKraken, Docker e Bruno aumentam sua capacidade de **entender, reproduzir e provar** o que foi produzido.

Para iniciantes, isso gera aprendizado. Para vibe coders, gera controle. Para engenheiros experientes, gera um fluxo de revisão mais eficiente e confiável.

Se você quer aprofundar esse processo, leia também [5 dicas para usar AI no seu dia a dia como Dev Senior](https://www.egermano.com/artigos/2025-10-02-5-dicas-programar-com-ai-senior) e [3 formas de reduzir custos de IA sem piorar as respostas](https://www.egermano.com/artigos/2026-07-12-3-formas-de-reduzir-custos-de-ia-sem-piorar-as-respostas).

Escolha hoje a etapa mais frágil do seu fluxo — revisar, executar ou validar — e teste uma dessas ferramentas no próximo projeto. Depois, me conte qual delas evitou o primeiro problema.

## Recursos

- [Guia inicial do GitKraken Desktop](https://help.gitkraken.com/gitkraken-desktop/guide/?ref=egermano.com)
- [Diff, histórico e blame no GitKraken Desktop](https://help.gitkraken.com/gitkraken-desktop/diff/?ref=egermano.com)
- [O que é um contêiner](https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-a-container/?ref=egermano.com)
- [Documentação do Docker Compose](https://docs.docker.com/compose/?ref=egermano.com)
- [Introdução ao Bruno](https://docs.usebruno.com/introduction/what-is-bruno?ref=egermano.com)
- [Testes no Bruno](https://docs.usebruno.com/testing/introduction?ref=egermano.com)
- [Bruno CLI](https://docs.usebruno.com/bru-cli/overview?ref=egermano.com)