IBM Bob: Como Ensinar uma IA a conhecer o Seu Projeto

Imagine contratar um desenvolvedor sênior que, a cada manhã, chega ao trabalho sem lembrar nada do projeto. Você precisaria re-explicar tudo — a tarefa, os seus padrões, a arquitetura. Esse é exatamente o comportamento padrão de qualquer IA: ela esquece tudo entre conversas.

Aqui, vou mostrar como o IBM Bob resolve esse problema de esquecimento com o AGENTS.md e o comando /init — e como o conceito se compara ao CLAUDE.md do Claude para quem já conhece essa ferramenta.

1) Por que IAs “Esquecem” Tudo?

Modelos de linguagem (LLMs) são stateless por design. Cada nova conversa começa com uma janela de contexto zerada. Não importa o quanto você trabalhou com a IA no dia anterior — ela não tem memória disso. Na prática, isso significa que toda vez que você abre uma nova conversa com o IBM Bob, você está começando do zero.

2) O AGENTS.md: O Ponto de Partida no IBM Bob

O AGENTS.md é um arquivo Markdown que fica na raiz do projeto. O Bob o carrega automaticamente no início de cada conversa, em todos os modos. É o único arquivo que você precisa ter para dar contexto à IA.

O que colocar nele?

  • Visão geral — o que o projeto faz em 2–3 frases
  • Stack tecnológico — linguagens, frameworks, bancos de dados
  • Estrutura de diretórios — onde ficam as principais pastas e o que cada uma contém
  • Convenções de código — nomenclatura, padrões arquiteturais, estilo
  • Fluxos de trabalho — como rodar localmente, testar, fazer deploy
  • Regras de negócio importantes — o que não está óbvio no código

Exemplo:

# Galaxium Travels — Contexto do Projeto

## Visão Geral
Plataforma de reservas de viagens espaciais. Backend em Node.js/TypeScript
com Express, frontend em React 18, banco PostgreSQL.

## Stack
- **Backend**: Node.js 20, TypeScript 5, Express 4, Prisma ORM
- **Frontend**: React 18, Vite, TailwindCSS
- **Banco**: PostgreSQL 16 (dev: Docker Compose)
- **Testes**: Vitest (unit), Playwright (e2e)

## Estrutura de Diretórios
src/
|-- api/          ? Rotas Express (um arquivo por recurso)
|-- services/     ? Lógica de negócio (sem acesso direto ao banco)
|-- repositories/ ? Acesso ao banco via Prisma
|-- models/       ? Tipos e interfaces TypeScript
|-- utils/        ? Helpers genéricos

## Convenções
- Nomes de arquivos: kebab-case (ex: booking-service.ts)
- Funções exportadas: camelCase; Classes: PascalCase
- Nunca usar `any` no TypeScript
- Commits: feat:, fix:, docs:, refactor: (Conventional Commits)

## Como Rodar
```bash
docker compose up -d   # sobe PostgreSQL
npm run dev            # inicia servidor em localhost:3000
npm test               # roda testes unitários
```

3) O Comando /init

A grande vantagem do IBM Bob é que você não precisa escrever o AGENTS.md do zero. O comando :

 /init 

escaneia automaticamente o projeto e gera um arquivo estruturado com as informações que o Bob consegue inferir.

O Bob irá:

  1. Ler os arquivos relevantes do projeto (package.json, estrutura de pastas, etc.)
  2. Gerar o AGENTS.md principal na raiz do projeto
  3. Criar a pasta .bob/ com arquivos de contexto específicos por modo
project-root/
|-- AGENTS.md                 <- Contexto principal (todos os modos)
|-- .bob/
    |-- rules-code/
    |   |-- AGENTS-code.md    <- Contexto em estrutura e padrões de código
    |-- rules-plan/
    |   |-- AGENTS-plan.md    <- Contexto focado em arquitetura
    |-- rules-ask/
        |-- AGENTS-ask.md     <- Contexto focado em explicações

Após rodar o /init, edite o AGENTS.md manualmente para adicionar contexto e deixar mais personalizado.

4) Hierarquia do AGENTS.md

O Bob suporta três níveis de contexto, carregados nesta ordem:

NívelLocalizaçãoQuando usar
Global~/.bob/AGENTS.mdPreferências pessoais que valem para todos os projetos (estilo de escrita, idioma preferido, etc.)
ProjetoAGENTS.md na raizContexto do projeto — stack, convenções, arquitetura
SubdiretórioAGENTS.md em subpastasContexto específico de um módulo ou serviço (ex: devops/AGENTS.md)

Ordem de precedência: O contexto mais específico (subdiretório) complementa — mas não sobrescreve — o contexto mais geral (global). O Bob carrega todos os níveis relevantes para a conversa atual.

5) Comparação com o CLAUDE.md

Se você já usa o Claude Code da Anthropic, o conceito de arquivo de contexto é idêntico — só muda o nome. O equivalente do AGENTS.md no Claude é o CLAUDE.md.

Migrando do Claude para o Bob: Se você já tem um CLAUDE.md no projeto, renomeie para AGENTS.md. O conteúdo é compatível — ambos são Markdown puro descrevendo o projeto. Não é necessária nenhuma conversão de formato.

AspectoIBM BobClaude Code
Nome do arquivoAGENTS.mdCLAUDE.md
LocalizaçãoRaiz do projetoRaiz do projeto
FormatoMarkdown livreMarkdown livre
Geração automáticaSim — comando /initManual
Contexto por modo de trabalhoSim — AGENTS-code.md, AGENTS-plan.md…Arquivo único global
Hierarquia em subpastasSimSim
Escopo global (todos os projetos)~/.bob/AGENTS.md~/.claude/CLAUDE.md

Vantagem do Bob

/init gera o contexto automaticamente e cria arquivos separados por modo de trabalho — o modo Code recebe contexto focado em código, o modo Plan em arquitetura.

Equivalente no Claude

O CLAUDE.md é criado manualmente. Sem separação por modo nativo — tudo vai para um único arquivo, que você organiza como preferir.

6) Boas Práticas de Manutenção

  • Versione no Git — o AGENTS.md é um ativo do projeto tão importante quanto o código
  • Prefira listas e headers — estrutura facilita a leitura tanto pela IA quanto pela equipe
  • Documente o “porquê”, não só o “o quê” — decisões arquiteturais com justificativa são mais valiosas que apenas listar tecnologias

Comece devagar: Não espere ter um AGENTS.md perfeito. Um arquivo com 10 linhas já é infinitamente melhor do que nenhum contexto.

Leia também:

IBM Bob: Utilizando Contexto de Forma Inteligente

Outro recurso extremamente interessante é o uso de referências de contexto.

Em vez de copiar e colar grandes volumes de código ou informações de arquivos no chat, o Bob permite apontar diretamente para arquivos e diretórios.

Sintaxe de Menções de Contexto

@/caminho/arquivo.js
Inclui todo o conteúdo de um arquivo específico na conversa.

@/caminho/pasta
Inclui todos os arquivos contidos em um diretório.

@problems
Inclui os diagnósticos atuais exibidos no painel Problems do VS Code.

@terminal
Inclui a saída mais recente do terminal.


As menções são resolvidas no momento em que a mensagem é enviada, fornecendo ao Bob informações precisas e direcionadas, sem consumir contexto desnecessário com arquivos que não estão relacionados à tarefa em execução.

Isso permite que o agente carregue apenas as informações necessárias, reduzindo o consumo de contexto e aumentando a precisão das respostas.

Leia também:

IBM Bob: Quando a IA deve pedir Permissão?

Por padrão, o IBM Bob solicitará sua autorização antes de executar ações que possam causar alterações significativas, como gravar arquivos, executar comandos no Terminal ou rodar testes.

O IBM Bob também permite configurar níveis de autonomia através do recurso de Auto-Approval. As opções incluem:

ConfiguraçãoComportamentoQuando utilizar
Aprovação manualTodas as ações exigem confirmação explícita do usuárioBases de código sensíveis ou tarefas desconhecidas
Aprovação automática (Auto-approve)O Bob executa as ações sem interrupçõesDemonstrações controladas e ambientes confiáveis
Modo híbridoAprova automaticamente ações de baixo risco e solicita confirmação para ações mais críticasDesenvolvimento do dia a dia

A configuração de aprovação automática (auto-approval) determina se essas ações serão executadas automaticamente ou se serão interrompidas para sua revisão. O IBM Bob também permite configurar níveis de autonomia através do recurso Aprovação Manual

Modelo Híbrido

Algumas ações são aprovadas automaticamente e outras exigem confirmação.

Na minha visão, essa costuma ser a melhor opção para a maioria dos projetos corporativos.

Por exemplo:

? Permitir leitura e escrita de arquivos automaticamente.

? Solicitar aprovação antes da execução de comandos no terminal.

Dessa forma é possível equilibrar produtividade e segurança.

Leia também:

IBM Bob: Como Otimizar Código Python e Obter Ganhos Reais de Performance

Nem sempre o melhor código é possível ser escrito. Escrever código que funciona bem — rápido, limpo e fácil de manter — dentro do prazo de um projeto, normalmente não é uma realidade.

Neste artigo vou mostrar, na prática, como utilizei o IBM Bob para analisar um script Python intencionalmente ineficiente e transformá-lo em uma versão muito mais performática, utilizando um caso simples, mas extremamente comum: conversão de arquivos CSV para JSON.

O Cenário

O objetivo do projeto era relativamente simples:

  • Ler um arquivo CSV contendo informações de pessoas.
  • Normalizar os dados.
  • Gerar um arquivo JSON de saída.

A lógica de negócio é bastante simples. O diferencial está na implementação.

Para este experimento foram criadas duas versões:

  • main-low.py – implementação propositalmente ineficiente.
  • main-high.py – versão otimizada com auxílio do IBM Bob.

Todo o código-fonte, exemplos e arquivos utilizados neste artigo estão disponíveis no GitHub: https://github.com/ebasso/ibm-bob-labs/tree/main/blog-posts/python-csv2json-optimization-20260708

Resultados Obtidos

Ambos os scripts foram executados no mesmo ambiente e utilizando exatamente o mesmo conjunto de dados.

Na tabela a seguir segue o comparativo antes e depois.

AspectoVersão OriginalVersão Otimizada
Tempo de execução41,8 ms0,93 ms
NormalizaçãoMúltiplos laçosOperações nativas
Leitura CSVProcessamento intermediárioLeitura direta
Serialização JSONOperações redundantesProcessamento único
Escrita de arquivoCaracteres individuaisEscrita otimizada
Pausas artificiaisSimNão
Tamanho do código~110 linhas~50 linhas

O Prompt para o IBM Bob

Com o script em mãos, basta colar o código no IBM Bob e usar o seguinte prompt:

Você é um engenheiro Python sênior especialista em performance. 
Analise o script abaixo (main-low.py) e gere uma versão otimizada chamada main-high.py. 
Requisitos para a versão otimizada: 
1) Manter exatamente a mesma interface de linha de comando: python3 main-high.py entrada.csv saida.json 
2) Manter o mesmo formato de saída JSON (array de objetos com chaves e valores em letras minúsculas, sem espaços extras). 
3) colocar o tempo de inicio e fim e o tempo de execuçã no arquivo main-high.py.
4) criar um prompt para que eu faça o rebuild dessa primeira pasta mas com alta performance. 

Durante a análise, o Bob conseguiu:

  • Identificar gargalos de performance.
  • Detectar concatenações ineficientes de strings.
  • Encontrar operações desnecessárias de serialização JSON.
  • Simplificar a leitura e escrita de arquivos.
  • Aplicar estruturas mais idiomáticas da linguagem Python.
  • Tornar o código mais legível e mais fácil de manter.

O interessante é que o Bob não apenas gerou uma nova versão do programa, mas também justificou tecnicamente cada alteração realizada.

Se o seu custo de Cloud já está ultrapassando US$ 10.000 ou mais de US$ 100.000 por mês, vale a pena experimentar esse tipo de análise assistida pelo IBM Bob.

Revisar scripts legados, aplicações com problemas de performance e identificar oportunidades de modernização para arquiteturas serverless pode revelar gargalos e desperdícios que passam despercebidos no dia a dia, permitindo reduzir consumo de CPU, memória e tempo de execução, com impacto direto nos custos operacionais da infraestrutura.

Leia também:

IBM Bob: Entendendo os Modos de Operação e Como Utilizá-los da Forma Correta

Neste artigo, vamos explorar os principais modos disponíveis no IBM Bob e entender quando utilizar cada um deles para obter os melhores resultados.

Os Modos do IBM Bob

A interface Agentic Sidebar do IBM Bob oferece três modos principais:

ModoObjetivo
Plan ModePlanejamento, arquitetura, design técnico e decomposição do problema sem alterar código
Agent ModeImplementação, correção, refatoração e modificação de código
Ask ModeAnálise, explicações e entendimento do código sem realizar alterações

A partir da versão 2.0, os antigos modos Code e Advanced foram consolidados em um único modo chamado Agent Mode, simplificando a experiência para os desenvolvedores. O Ask Mode é uma adição mais recente e continua recebendo melhorias constantes.

Plan Mode: Pensar Antes de Construir

Se existe um modo que considero fundamental para equipes corporativas, é o Plan Mode.

Muitas vezes o erro não está na implementação, mas sim na falta de um planejamento adequado antes de escrever a primeira linha de código.

No Plan Mode, o IBM Bob possui acesso apenas para leitura do projeto. Ele não altera arquivos e não executa comandos. Sua função é analisar o contexto da aplicação e construir um plano detalhado de implementação.

Esse modo é especialmente útil quando:

  • Uma funcionalidade impacta diversos componentes.
  • Será necessário alterar várias camadas da aplicação.
  • Existe a necessidade de definir arquitetura.
  • É preciso estimar esforço antes da implementação.
  • O desenvolvedor deseja validar o escopo antes de iniciar o trabalho.

Ao receber uma solicitação, o Bob analisa os arquivos relevantes e produz normalmente dois documentos:

Plano de Implementação

Descreve detalhadamente:

  • O que será desenvolvido.
  • Como será implementado.
  • Quais componentes serão afetados.
  • Como os testes deverão ser realizados.
  • Regras de negócio envolvidas.

Plano de Arquitetura

Apresenta uma visão mais ampla:

  • Fluxo de dados.
  • Componentes envolvidos.
  • Integrações.
  • Decisões arquiteturais.
  • Impactos no sistema.

Esses documentos tornam-se a especificação oficial que será utilizada posteriormente durante a implementação.

A Revisão Continua Sendo Responsabilidade do Desenvolvedor

Esse talvez seja o conceito mais importante ao trabalhar com qualquer ferramenta baseada em LLM.

O plano gerado pelo IBM Bob não deve ser encarado como uma sugestão informal.

Ele representa exatamente aquilo que será construído posteriormente.

Se um requisito importante estiver ausente ou incorreto no plano aprovado, existe uma alta probabilidade de que a implementação também apresente o mesmo problema.

Por isso, o processo ideal é:

  1. Gerar o plano.
  2. Ler cuidadosamente.
  3. Ajustar o que for necessário.
  4. Somente depois aprovar a implementação.

A IA acelera o desenvolvimento, mas a responsabilidade técnica continua sendo humana.

Esse conceito de Human-in-the-Loop é um dos pilares para o uso seguro e eficiente de agentes de IA em ambientes corporativos. 

Agent Mode: Hora de Colocar a Mão no Código

Depois que o plano foi revisado e aprovado, entra em cena o Agent Mode.

Nesse modo, o Bob possui permissão para:

  • Criar arquivos.
  • Alterar código existente.
  • Refatorar componentes.
  • Executar comandos.
  • Rodar testes.
  • Implementar funcionalidades completas.

É aqui que ocorre a materialização daquilo que foi definido durante a fase de planejamento.

Uma recomendação interessante da própria metodologia do Bob é iniciar uma nova conversa antes de começar a implementação.

Isso traz benefícios como:

  • Contexto mais limpo.
  • Maior foco na execução.
  • Melhor uso da janela de contexto.
  • Menor risco de misturar discussões de arquitetura com instruções de implementação.

Na prática, o fluxo sugerido é:

Plan ? Revisão ? Nova Conversa ? Agent

Esse processo cria uma separação clara entre planejamento e execução, algo muito próximo das boas práticas tradicionais de engenharia de software.

Ask Mode: Aprendendo e Investigando

Ask Mode é foi criado para situações em que você deseja obter conhecimento sobre alguma tecnologia, ou o código sem realizar mudanças.

Nesse modo, o IBM Bob atua como um Especialista Consultor.

Ele pode ajudar a:

  • Entender regras de negócio.
  • Explicar algoritmos.
  • Analisar problemas.
  • Avaliar possíveis melhorias.
  • Responder perguntas técnicas.
  • Interpretar trechos complexos de código.

É um recurso extremamente útil para onboarding de novos desenvolvedores ou para compreender sistemas legados desconhecidos.

Imagine receber uma aplicação com milhares de linhas de código desenvolvidas há anos.

Em vez de analisar tudo manualmente, é possível solicitar ao Bob explicações sobre:

  • Fluxos principais.
  • Dependências.
  • Arquitetura.
  • Padrões utilizados.
  • Possíveis gargalos.

Sem alterar absolutamente nada no ambiente.

Conclusão

O que mais me chamou atenção no IBM Bob é a disciplina de engenharia embutida na ferramenta, ao invés de focar apenas na geração rápida de código.

Os modos PlanAgent e Ask representam muito mais do que simples opções de menu. O Bob incentiva um processo mais estruturado: Entender, Planejar, Revisar, Implementar, Validar.

Se você está começando a explorar o IBM Bob, minha recomendação é:

Nunca pule o Plan Mode.

Leia também:

Uma Série Prática sobre o IBM Bob

Em poucas palavras, a proposta do IBM Bob é oferecer um ambiente capaz de apoiar todo o ciclo de vida do desenvolvimento de software, desde a análise de requisitos até a implementação, testes, documentação, deploy, troubleshooting, melhorias de performance e modernização de aplicações legadas.

Em outras palavras, trata-se de uma plataforma baseada em agentes de IA criada para atuar de forma integrada em todas as etapas da engenharia de software.

O que mais chamou minha atenção?

Ao utilizar o IBM Bob, alguns pontos se destacaram rapidamente:

  • A capacidade de planejar, analisar, implementar e validar alterações de forma estruturada.
  • O desempenho impressionante em atividades de troubleshooting, conseguindo analisar centenas de arquivos de log e milhares de linhas em poucos minutos.
  • Bob IDE, que é baseado em um fork do VS Code. Isso reduz significativamente a curva de aprendizado, já que a maioria dos desenvolvedores já possui familiaridade com o ambiente.
  • Bob Shell, uma ferramenta muito interessante para quem gosta de trabalhar diretamente pela linha de comando.
  • Bobalytics, dashboard que permite acompanhar e gerenciar o consumo de recursos de IA, incluindo utilização de tokens (ou “bobcoins”), custos e métricas de produtividade.

Outro diferencial interessante é que o Bob não se limita à geração de código. A plataforma busca compreender o contexto completo da aplicação e auxiliar em atividades normalmente complexas, como análise de arquiteturas legadas, geração de documentação, refatoração, otimização de sistemas e atualização tecnológica.

Mas um ponto que pretendo explorar bastante nesta série é o potencial do IBM Bob para otimização de código e melhoria de performance.

Muitas organizações concentram seus esforços na modernização tecnológica, mas frequentemente deixam passar oportunidades significativas de redução de custos $$$$, através da otimização de aplicações desenvolvidas em Java, Python, Typescript ….

Esta é apenas a primeira parte

Este artigo marca o início de uma nova série dedicada ao IBM Bob.

Nos próximos posts pretendo explorar temas como:

  • Instalação e configuração inicial.
  • Integração com VS Code.
  • Modos de operação do Bob.
  • Casos práticos de geração de código.
  • Troubleshooting assistido por IA.
  • Refatoração e otimização de aplicações.
  • Técnicas para melhoria de performance.
  • Uso do Bob para análise de logs e identificação de gargalos.
  • Comparação com outras ferramentas de IA para desenvolvedores.
  • Dicas e boas práticas para obter melhores resultados.

A ideia é realizar uma análise prática, compartilhando experiências, exemplos e aprendizados ao longo da jornada.

Se você trabalha com desenvolvimento corporativo, modernização de aplicações ou simplesmente gosta de acompanhar as novidades do universo IBM, acompanhe o blog.

Em breve publicarei os próximos capítulos desta série sobre o IBM Bob. Até o próximo post! 

Leia também:

Topology of IBM Sterling B2B Integrator inside RedHat OpenShift Cluster

I usually leave the technical parts for my wiki, but this time I had to add this topology here on the blog. Running Sterling B2B Integrator in a container involves a series of pods, services, and network configurations, which can make management a bit tricky. To organize my understanding of the whole structure, I decided to create a diagram to help visualize the interactions.

Below the diagram:

The diagram I created includes all the components, as well as the critical connections that make everything work in harmony. This proved essential for understanding the topology in a clear and intuitive way.


Leia também: