☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta IBM Bob. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta IBM Bob. Mostrar todas as mensagens

sábado, 10 de outubro de 2026

🕵️ IBM BOB E O MISTÉRIO DO COBOL ESQUECIDO: AUGUSTE DUPIN INVESTIGA O CÓDIGO QUE SOBREVIVEU A CINCO DÉCADAS!

 

Bellacosa Mainframe e o IBM Bob auxiliando a investigar codigo legado

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🕵️ IBM BOB E O MISTÉRIO DO COBOL ESQUECIDO: AUGUSTE DUPIN INVESTIGA O CÓDIGO QUE SOBREVIVEU A CINCO DÉCADAS!

Quando uma inteligência artificial começa a investigar programas COBOL escritos há cinquenta anos, o maior mistério não é descobrir como o código funciona, mas compreender por que ele foi escrito daquela maneira. Sob a tutela de Auguste Dupin, o lendário detetive criado por Edgar Allan Poe, vamos investigar o IBM Bob, os agentes de IA, a arqueologia dos sistemas legados e os segredos escondidos em milhares de linhas de COBOL que continuam movimentando o mundo.

Bellacosa Mainframe — Arqueologia da Computação, COBOL, IBM Z, Inteligência Artificial e os Mistérios da Engenharia de Software

Uma investigação para programadores iniciantes, veteranos de mainframe e todos aqueles que acreditam que cada linha de código antigo tem uma história para contar.



🎬 Prólogo — Paris, 1841: o primeiro detetive encontra um mainframe

Paris, 1841.

Numa rua silenciosa, iluminada pela luz vacilante dos lampiões a gás, um homem examina cuidadosamente um conjunto de documentos.

Seu nome é C. Auguste Dupin.

Ele não é policial, não pertence a uma agência governamental e tampouco utiliza as técnicas tradicionais dos investigadores.

Dupin possui algo muito mais perigoso: a capacidade de observar detalhes que todos os outros ignoram.

Naquela noite, entretanto, o detetive recebe um visitante absolutamente improvável.

Um engenheiro de sistemas vindo do ano de 2026.

O visitante coloca sobre a mesa um enorme volume de papel.

São listagens de um programa COBOL escrito em 1978.

— Monsieur Dupin, temos um problema.

— Um assassinato?

— Pior. Um programa de cálculo financeiro que ninguém compreende completamente.

Dupin ergue uma sobrancelha.

— E ele continua funcionando?

— Perfeitamente. Processa milhares de operações diariamente. Entretanto, precisamos alterar uma regra de negócio e ninguém sabe explicar algumas das condições existentes.

O detetive examina uma das folhas.

IF WS-TIPO-CLIENTE = 'A'
   AND WS-ANO-CONTRATO < 1987
      PERFORM CALCULO-ESPECIAL
END-IF.

— Interessante — murmura Dupin.

— O quê?

— A pergunta não é por que essa condição existe. A pergunta é quais acontecimentos tornaram sua existência necessária.

O engenheiro sorri.

— É justamente por isso que precisamos de sua ajuda.

— E como pretende investigar milhares de programas?

— Temos um novo assistente chamado IBM Bob.

Dupin permanece em silêncio por alguns segundos.

— Então teremos dois investigadores. Um artificial e outro humano. Excelente. Veremos qual deles sabe distinguir uma evidência de uma suposição.

E assim começa uma investigação que atravessará quase dois séculos, dos contos de Edgar Allan Poe aos modernos agentes de inteligência artificial para IBM Z.



🕵️ Capítulo I — Quem foi Auguste Dupin, o avô de Sherlock Holmes?

Antes de conhecer o IBM Bob, precisamos compreender nosso professor.

C. Auguste Dupin é um personagem fictício criado pelo escritor americano Edgar Allan Poe, apresentado em 1841 no conto The Murders in the Rue Morgue, conhecido em português como Os Assassinatos da Rua Morgue.

Dupin é considerado um dos grandes precursores do detetive moderno na literatura.

Sua especialidade é aquilo que Poe chamava de raciocínio analítico.

Ele não depende apenas da coleta de pistas.

Dupin observa, compara, questiona, elimina hipóteses e reconstrói acontecimentos.

A característica mais interessante de seu método é perceber aquilo que as pessoas deixam de perceber justamente porque parece óbvio.

Dupin protagoniza três histórias fundamentais:

  1. Os Assassinatos da Rua Morgue (1841): um mistério aparentemente impossível, solucionado por meio da análise das evidências.

  2. O Mistério de Marie Rogêt (1842–1843): uma investigação construída a partir de relatos e informações disponíveis publicamente.

  3. A Carta Roubada (1844): uma lição extraordinária sobre observação, perspectiva e conclusões precipitadas.

Sua influência seria percebida posteriormente em personagens como Sherlock Holmes e Hercule Poirot.

Mas o que um detetive do século XIX tem a ensinar a um programador COBOL?

Praticamente tudo sobre investigação.

Um depurador identifica onde um erro se manifesta. Um verdadeiro investigador procura descobrir por que ele existe.

É essa diferença que torna Dupin nosso tutor ideal.

☕ Curiosidade Bellacosa

Em A Carta Roubada, a polícia procura obsessivamente um documento usando métodos minuciosos de busca física.

Dupin percebe que o problema não está na falta de esforço, mas na maneira como os investigadores imaginam que o criminoso pensa.

Nos sistemas de informação acontece algo semelhante.

Podemos procurar durante horas uma instrução incorreta, quando o verdadeiro problema está numa premissa de negócio que ninguém questionou.



🖥️ Capítulo II — O cadáver que continuava processando transações

Dupin recebe o primeiro relatório do engenheiro.

O banco fictício Banque de la Seine começou suas operações informatizadas na década de 1970.

Seu sistema evoluiu de computadores da família IBM System/370 para gerações posteriores de mainframes.

Os equipamentos foram substituídos, os sistemas operacionais evoluíram e novas interfaces foram acrescentadas.

Mas parte das regras empresariais sobreviveu.

Em 2026, a aplicação reúne, hipoteticamente:

  • 2.800 programas COBOL;

  • 1.400 copybooks;

  • 350 procedimentos JCL;

  • 180 transações CICS;

  • centenas de tabelas Db2;

  • arquivos VSAM;

  • programas utilitários escritos em Assembler;

  • interfaces com sistemas modernos.

Esses números são fictícios e servem exclusivamente para ilustrar a investigação.

O problema é simples de descrever.

Uma nova regra exige modificar o cálculo de juros dos contratos modernos.

Entretanto, o programa responsável também atende contratos históricos.

Dupin examina a documentação.

— Quantos desenvolvedores conhecem essa aplicação?

— Três.

— E quantos estavam presentes quando ela foi originalmente criada?

— Nenhum.

— Então temos testemunhas que conhecem a cena atual, mas nenhuma que tenha presenciado o acontecimento original.

O detetive olha novamente para a listagem.

— Não estamos diante de um cadáver, monsieur. Estamos diante de uma cidade construída sobre as ruínas de várias outras.

Essa é uma excelente descrição de um sistema legado.

A aplicação atual não representa somente o projeto original.

Ela incorpora décadas de decisões, correções, melhorias, adaptações legais e integrações.

Remover uma instrução aparentemente inútil pode equivaler a retirar uma pedra de sustentação de um edifício antigo.



🤖 Capítulo III — IBM Bob entra na investigação

O engenheiro apresenta o segundo investigador.

IBM Bob é uma plataforma da IBM orientada ao desenvolvimento de software com agentes de inteligência artificial.

Em 2026, a IBM apresentou capacidades especializadas para sistemas mainframe por meio do IBM Bob Premium Package for Z.

O pacote foi concebido para auxiliar profissionais em atividades como compreensão de aplicações, documentação, análise de dependências, planejamento de mudanças, geração de código e modernização.

É importante compreender uma distinção fundamental.

O Bob não deve ser imaginado simplesmente como um chatbot que lê um programa COBOL e responde perguntas.

Sua proposta envolve modelos de inteligência artificial combinados com conhecimentos especializados, ferramentas, fluxos de trabalho e componentes de análise de aplicações.

Entre os recursos associados ao pacote está o Z Understand, utilizado para produzir informações estruturadas sobre aplicações e seus relacionamentos.

Dupin parece interessado.

— A máquina conhece o significado de todos os programas?

— Não exatamente.

— Excelente. Uma máquina que acredita saber tudo seria um investigador bastante perigoso.

O detetive acaba de identificar o primeiro princípio de uma boa investigação com IA.

Conhecimento provável não é conhecimento comprovado.

Uma inteligência artificial pode interpretar o nome de uma variável.

Uma ferramenta de análise estática pode determinar certas relações efetivamente presentes no código.

Um especialista de negócio pode confirmar o significado empresarial de uma regra.

São três níveis diferentes de conhecimento.

Confundi-los é uma excelente maneira de produzir um desastre.


🔍 Capítulo IV — A primeira pista: uma variável chamada TX-MR

A investigação começa com um pequeno programa.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CALCJURO.

       DATA DIVISION.
       WORKING-STORAGE SECTION.

       01 WS-VALOR PIC 9(9)V99 COMP-3.
       01 WS-TX-MR PIC 9V9(6) COMP-3.
       01 WS-DIAS PIC 9(4) COMP.
       01 WS-JUROS PIC 9(9)V99 COMP-3.

       PROCEDURE DIVISION.

           COMPUTE WS-JUROS ROUNDED =
               WS-VALOR * WS-TX-MR *
               WS-DIAS / 30
           END-COMPUTE

           GOBACK.

O código foi simplificado para fins didáticos. É um fragmento de cálculo, e não um programa bancário completo.

Dupin observa a variável WS-TX-MR.

— Qual é seu significado?

— Acreditamos que represente uma taxa mensal.

— Acreditam?

— Sim.

— Então isso ainda não é uma evidência.

Esse pequeno diálogo resume uma das dificuldades mais importantes da modernização.

O nome de uma variável pode sugerir determinado significado sem comprová-lo.

TX-MR poderia representar taxa de mora, taxa mensal de referência ou outro conceito específico da aplicação.

Para descobrir, precisamos investigar:

Primeiro: onde a variável recebe valores?

Segundo: quais programas ou arquivos fornecem esses valores?

Terceiro: onde ela participa de cálculos?

Quarto: quais resultados são afetados?

Quinto: existe documentação ou uma pessoa capaz de confirmar sua finalidade?

É aqui que a análise estruturada de código se torna valiosa.

Em vez de solicitar a um modelo que adivinhe o significado da variável, podemos utilizar informações sobre definições, referências, chamadas e fluxos de dados.

Dupin aprova.

— Finalmente estamos deixando de interrogar nossas próprias imaginações e começando a examinar os fatos.

Dica para iniciantes

Ao encontrar uma variável desconhecida num programa COBOL, nunca conclua seu significado apenas pelo nome.

Procure instruções como MOVE, COMPUTE, ADD, SUBTRACT, MULTIPLY, DIVIDE e condições que utilizem o campo.

Verifique também se ele pertence a um copybook compartilhado.

Esse procedimento simples pode revelar relações que não aparecem na primeira leitura.


🧩 Capítulo V — Z Architect e Z Code: os dois assistentes de Dupin

A IBM organiza parte das capacidades especializadas do Bob para IBM Z em modos de trabalho diferentes.

Dois deles são particularmente interessantes.

Z Architect: o investigador

Sua função é ajudar a compreender a arquitetura da aplicação.

Pode apoiar atividades como:

  • análise de dependências;

  • identificação de componentes relacionados;

  • compreensão de regras de negócio;

  • avaliação de impacto;

  • preparação de planos de modernização.

Na nossa história, Z Architect seria o assistente responsável por examinar a cena do crime.

Z Code: o engenheiro

O Z Code concentra-se nas atividades relacionadas ao código e à implementação.

A proposta inclui apoiar geração, modificação, refatoração e transformação de programas em fluxos especializados.

Seria o profissional encarregado de executar as modificações depois que o plano fosse aprovado.

Dupin estabelece uma regra.

— Nenhum investigador deverá modificar a cena antes de terminar sua análise.

Essa frase poderia estar na documentação de qualquer projeto sério de modernização.

Antes de alterar um programa, precisamos saber o que ele faz, por que faz e quais sistemas dependem dele.

A separação entre investigação e implementação é uma medida extremamente importante para reduzir riscos.


🕸️ Capítulo VI — A rede invisível: CALL, COPYBOOK, CICS, Db2 e JCL

Dupin recebe uma segunda listagem.

       CALL 'CALCJURO'
           USING WS-VALOR
                 WS-TAXA
                 WS-DIAS
                 WS-RESULTADO

— Encontramos o programa chamador! — comemora o engenheiro.

Dupin não parece impressionado.

— Encontramos um chamador. Isso não significa que encontramos todos.

Um programa COBOL pode ser executado por outros programas, por uma transação online ou por uma etapa batch.

Também pode utilizar copybooks compartilhados e recursos de banco de dados.

Considere o seguinte cenário:

          CLIENTE
             |
          CICS
             |
         CRED100
             |
         CALCJURO
             |
          Db2
             |
         EXTR300

    PROCESSAMENTO BATCH
             |
          JCL
             |
         COBR200
             |
         CALCJURO
             |
          VSAM

A rotina CALCJURO é utilizada tanto por operações online quanto por processamento batch.

Uma alteração no comportamento dessa rotina poderia afetar várias aplicações.

Dupin identifica o risco.

— Se modificarmos a fórmula sem conhecer todos os consumidores, poderemos corrigir um relatório e destruir outro.

Exatamente.

O que é um copybook?

Um copybook é um trecho de código ou definição reutilizável, incorporado ao programa por meio da instrução COPY.

Exemplo:

       COPY TAXASCPY.

Imagine que TAXASCPY contenha estruturas utilizadas por cinquenta programas.

Modificar o layout de um campo compartilhado pode exigir revisar todos os consumidores afetados.

O que é JCL?

JCL significa Job Control Language.

No z/OS, ele descreve como determinados trabalhos batch serão executados e quais recursos deverão utilizar.

O que é CICS?

CICS é uma plataforma de processamento transacional utilizada em aplicações empresariais, especialmente no ambiente IBM Z.

O que é Db2?

Db2 é um sistema gerenciador de bancos de dados relacionais da IBM, amplamente utilizado em aplicações empresariais.

Por que isso importa?

Porque compreender um programa não é o mesmo que compreender uma aplicação.

E compreender uma aplicação não é necessariamente compreender todo o processo empresarial.

Essa diferença representa um dos maiores desafios da inteligência artificial aplicada à modernização de sistemas legados.


📜 Capítulo VII — O mistério do número 30

Finalmente surge a pista principal.

COMPUTE WS-JUROS ROUNDED =
    WS-VALOR * WS-TAXA *
    WS-DIAS / 30
END-COMPUTE

Um desenvolvedor jovem apresenta sua proposta.

— Podemos modernizar o cálculo utilizando o número real de dias do mês.

Dupin imediatamente pergunta:

— Por quê?

— Porque alguns meses têm 31 dias.

— Isso é um fato sobre o calendário. Mas não é necessariamente um fato sobre o contrato.

O silêncio domina a sala.

O detetive acaba de salvar a investigação.

Em operações financeiras, podem existir convenções contratuais que utilizam meses comerciais de 30 dias.

Alterar essa convenção sem autorização pode produzir resultados incorretos.

Considere o exemplo de juros simples:

Valor principal: R$ 10.000,00.

Taxa mensal: 2%.

Período: 15 dias.

Base: 30 dias.

A fórmula é:

10.000 × 0,02 × 15 ÷ 30

Resultado: R$ 100,00.

Se utilizarmos base 31, o resultado arredondado será aproximadamente R$ 96,77.

Diferença: R$ 3,23.

Parece pouco?

Imagine milhões de contratos.

Agora considere juros compostos, regras de arredondamento, datas especiais, condições contratuais e liquidação de operações.

Uma alteração aparentemente pequena pode produzir consequências significativas.

Dupin conclui:

— O número 30 não é nosso inimigo. Nossa ignorância sobre sua origem é que representa o perigo.

Easter egg histórico

Em A Carta Roubada, a solução do mistério depende de perceber aquilo que estava praticamente à vista de todos.

No nosso programa COBOL, o número 30 também estava visível desde o início.

A dificuldade não era encontrá-lo.

Era interpretar corretamente seu significado.


🧪 Capítulo VIII — A inteligência artificial pode gerar testes?

A investigação avança.

O engenheiro apresenta uma proposta.

— Pediremos ao Bob para modificar a fórmula e gerar testes automatizados.

Dupin concorda parcialmente.

— Os testes deverão ser preparados antes de esquecermos o comportamento original.

Essa é uma das principais lições da engenharia de software.

Não devemos começar pela alteração. Devemos começar pela compreensão e pela validação do comportamento existente.

Um conjunto inicial de testes poderia conter:

CasoPrincipalTaxaDiasBaseResultado
T0110.0002%1530100,00
T0210.0002%3030200,00
T0310.0000%30300,00
T0410.0002%153196,77

Esses são casos didáticos para a fórmula simplificada apresentada.

Em aplicações reais, precisaríamos incluir testes adicionais.

Por exemplo:

  • taxa negativa indevida;

  • valor próximo ao limite numérico;

  • período zero;

  • período superior ao esperado;

  • dados inválidos;

  • regras específicas para contratos históricos;

  • diferenças de arredondamento;

  • possíveis condições de overflow.

Ferramentas de IA podem ajudar a propor e gerar testes.

Mas não devemos presumir que todos os testes gerados sejam suficientes.

Dupin observa:

— Um investigador que apenas procura provas favoráveis à própria hipótese não está investigando. Está tentando confirmar sua opinião.

Esse princípio também vale para o software.

Um bom teste deve ter potencial para demonstrar que a implementação está errada.


⚙️ Capítulo IX — O passo a passo de uma modernização assistida por IA

Vamos organizar nossa investigação num procedimento adequado para iniciantes.

Passo 1 — Escolha um programa pequeno

Não comece por um sistema com milhares de programas.

Selecione uma rotina simples de cálculo, consulta ou processamento de arquivos.

Procure compreender suas entradas, saídas e condições.

Passo 2 — Identifique os campos

Examine a DATA DIVISION.

Localize as definições principais.

Observe cláusulas como:

PIC 9(7)V99
PIC X(30)
COMP-3

Aprenda a distinguir campos alfanuméricos, numéricos e representações internas.

Passo 3 — Identifique o fluxo

Examine a PROCEDURE DIVISION.

Localize os principais parágrafos e comandos de controle.

Observe PERFORM, EVALUATE, IF, CALL e operações de entrada e saída.

Passo 4 — Investigue as dependências

Procure programas chamados, copybooks, arquivos, tabelas e recursos externos.

Caso disponha de ferramentas de análise como Z Understand, utilize os resultados para ampliar a investigação.

Passo 5 — Peça uma explicação estruturada à IA

Um bom prompt seria:

Analise o programa COBOL apresentado. Identifique entradas, saídas, cálculos, chamadas e dependências. Explique cada regra encontrada. Separe os fatos comprováveis pelo código das hipóteses sobre o negócio. Não modifique o programa.

Passo 6 — Documente o comportamento atual

Registre valores de entrada, resultados conhecidos, erros esperados e situações especiais.

Passo 7 — Planeje a mudança

Descreva precisamente a nova regra.

Identifique quem deverá aprová-la.

Passo 8 — Implemente em ambiente controlado

Utilize controle de versões e revisão de código.

Nunca permita que a primeira experiência de um agente de IA seja uma alteração direta em produção.

Passo 9 — Execute testes

Compare o comportamento anterior com o comportamento novo nos casos que devem permanecer iguais.

Verifique separadamente os casos nos quais a mudança é intencional.

Passo 10 — Documente a decisão

Registre a motivação, a implementação, as evidências dos testes e os procedimentos de recuperação.

Dupin examina o plano e declara:

— Excelente. Não estamos pedindo à máquina que seja infalível. Estamos criando um processo no qual seus erros possam ser descobertos.


🧠 Capítulo X — O raciocínio de Dupin e o raciocínio de um agente de IA

A comparação entre Dupin e o IBM Bob revela semelhanças interessantes, mas também diferenças fundamentais.

Dupin trabalha com observação, inferência e conhecimento do comportamento humano.

Um agente de IA utiliza modelos computacionais, dados disponíveis, ferramentas e regras de execução.

Ambos podem participar de processos de investigação.

Entretanto, um modelo de linguagem pode produzir respostas convincentes sem possuir evidências suficientes.

Isso torna indispensável separar três conceitos.

Evidência

Algo verificável.

Exemplo: o programa possui uma instrução CALL 'CALCJURO'.

Hipótese

Uma explicação possível.

Exemplo: a rotina foi criada para atender a determinada regra financeira histórica.

Conclusão validada

Uma interpretação sustentada por evidências e confirmada pelos responsáveis apropriados.

Exemplo: a documentação contratual demonstra que a rotina implementa determinada convenção de cálculo.

O problema começa quando a IA transforma hipóteses em aparentes certezas.

Por isso, um dos melhores hábitos de trabalho é solicitar explicitamente:

“Mostre as evidências que sustentam cada conclusão.”

Em aplicações críticas, respostas sem rastreabilidade devem ser tratadas com cautela.


🔐 Capítulo XI — RACF: quem vigia o investigador artificial?

Dupin encontra um novo problema.

O administrador pretende conceder ao agente acesso irrestrito às bibliotecas de produção para facilitar a investigação.

— Isso é necessário? — pergunta o detetive.

— Facilitaria bastante.

— Facilitar uma investigação não justifica entregar todas as chaves ao investigador.

No z/OS, o RACF pode ser utilizado para controlar acessos a recursos protegidos.

Agentes que operam com ferramentas externas devem respeitar os mesmos princípios fundamentais de segurança adotados para usuários e processos tradicionais.

Entre esses princípios estão o menor privilégio, a separação de responsabilidades e a rastreabilidade.

Para uma investigação, o acesso de leitura pode ser suficiente.

Para uma mudança, permissões de escrita devem ser cuidadosamente controladas.

E para a implantação em produção, os procedimentos de aprovação da organização continuam indispensáveis.

Outro risco importante está nos próprios dados fornecidos ao agente.

Código, documentação e arquivos podem conter informações confidenciais.

Antes de conectar ferramentas de IA a um ambiente empresarial, é necessário avaliar as políticas de processamento, armazenamento, retenção e proteção dessas informações.

Uma arquitetura moderna não elimina a necessidade de governança.

Na realidade, pode torná-la ainda mais importante.


🏛️ Capítulo XII — Arqueologia da computação: cinco décadas escondidas numa rotina

Dupin encontra um comentário escrito em 1988.

      * AJUSTE CONFORME REGRA FINANCEIRA
      * IMPLEMENTADA EM 1988
      * NAO ALTERAR SEM AUTORIZACAO

O comentário não explica completamente a regra.

Mas revela que o autor considerava aquela decisão importante.

O detetive começa a reconstruir uma linha do tempo.

1978: criação da primeira versão da aplicação.

1988: introdução de uma regra especial.

1995: migração para uma plataforma mais recente.

2002: integração com novos sistemas.

2015: modernização das interfaces.

2026: proposta de análise com inteligência artificial.

A cronologia é inteiramente fictícia, mas representa um padrão recorrente na história de aplicações empresariais.

Cada geração de programadores acrescentou uma camada.

Isso explica por que simplesmente reescrever uma aplicação do zero pode ser tão perigoso.

Uma documentação incompleta talvez descreva apenas parte do comportamento necessário.

Já o código existente contém decisões que podem não estar registradas em nenhum outro lugar.

Mas devemos tomar cuidado com outra simplificação: o código não é uma documentação perfeita.

Ele registra uma implementação, que também pode conter erros, soluções provisórias e comportamentos obsoletos.

Dupin resume:

— O passado não deve ser obedecido cegamente. Deve ser investigado antes de ser modificado.


🚀 Capítulo XIII — COBOL para Java: o mistério da tradução perfeita

O engenheiro apresenta uma nova proposta.

— Monsieur Dupin, podemos converter todos os programas COBOL para Java.

O detetive parece preocupado.

— Traduzir palavras é relativamente simples. Traduzir significados exige muito mais cuidado.

Essa distinção é fundamental.

Considere:

01 WS-SALDO PIC S9(11)V99 COMP-3.

Temos um campo decimal com sinal e duas casas decimais.

Uma tradução inadequada poderia utilizar double em Java.

Entretanto, cálculos financeiros frequentemente precisam de representações decimais exatas.

Nesse cenário, BigDecimal pode ser uma opção apropriada.

BigDecimal saldo =
    new BigDecimal("1250.35");

Mas a escolha do tipo de dado não resolve tudo.

É preciso considerar:

  • precisão;

  • arredondamento;

  • truncamento;

  • limites numéricos;

  • representação de sinal;

  • tratamento de dados inválidos;

  • diferenças entre operações das linguagens.

Os fluxos de modernização associados ao IBM Bob incluem capacidades voltadas ao planejamento e à validação de transformações.

Ainda assim, não existe uma garantia universal de que qualquer programa COBOL possa ser convertido automaticamente mantendo comportamento absolutamente idêntico.

Às vezes, a melhor decisão é preservar COBOL e modernizar suas interfaces.

Dupin faz uma pergunta definitiva:

— O objetivo é modernizar o negócio ou simplesmente mudar o idioma no qual o programa foi escrito?

A resposta a essa pergunta deveria anteceder qualquer grande migração.


🎩 Capítulo XIV — Cinco curiosidades que Dupin descobriu sobre o COBOL

1. COBOL é mais antigo que a maioria das plataformas nas quais ainda é executado

A linguagem surgiu em 1959.

Muitas arquiteturas de hardware mudaram radicalmente desde então.

Entretanto, aplicações e regras empresariais escritas em COBOL continuaram sendo mantidas e adaptadas.

2. Um nome curto pode esconder uma regra gigantesca

Variáveis com nomes como TX-MR ou VLR-AC podem parecer insignificantes.

Mas seu significado pode determinar o resultado de operações financeiras importantes.

3. Nem todo código antigo é tecnicamente ruim

Idade não significa defeito.

Um programa antigo pode ser extremamente eficiente e estável.

A dificuldade está em avaliar se ainda atende corretamente aos requisitos atuais.

4. IA pode ajudar a documentar sistemas que perderam seus criadores

A combinação de análise estática, conhecimento especializado e modelos de linguagem oferece meios promissores para recuperar parte do conhecimento de aplicações pouco documentadas.

Isso não elimina a necessidade de validar as conclusões.

5. A automação pode aumentar o valor do conhecimento humano

Quanto mais fácil for produzir alterações, mais importante será saber quais alterações realmente devem ser feitas.

Dominar regras de negócio, arquitetura e validação pode tornar-se ainda mais valioso.


🧪 Capítulo XV — O desafio final de Dupin: encontre o defeito escondido

Nosso detetive apresenta um último programa.

       IF WS-SALDO > ZERO
           COMPUTE WS-JUROS =
               WS-SALDO * WS-TAXA
           END-COMPUTE
       END-IF

Aparentemente, tudo funciona.

Mas Dupin faz quatro perguntas.

Primeira: o que acontece quando o saldo é negativo?

Segunda: a variável WS-JUROS foi inicializada antes do cálculo?

Terceira: qual é a política de arredondamento?

Quarta: o tamanho do campo de destino suporta todos os resultados possíveis?

O principal perigo está no comportamento implícito.

Se WS-SALDO não for positivo, a instrução COMPUTE não será executada.

Dependendo da organização do programa e do estado anterior da variável, WS-JUROS poderá conservar um valor que não deveria ser utilizado.

Uma possível melhoria seria inicializar explicitamente o campo:

       MOVE ZERO TO WS-JUROS

       IF WS-SALDO > ZERO
           COMPUTE WS-JUROS ROUNDED =
               WS-SALDO * WS-TAXA
           END-COMPUTE
       END-IF

Entretanto, essa mudança também precisa ser confrontada com os requisitos.

Talvez saldos negativos devam produzir um erro específico ou acionar outra rotina.

A melhoria não deve ser escolhida apenas porque parece elegante.

O programador precisa compreender o contrato funcional.

Esse pequeno exercício demonstra por que agentes de IA podem ser muito úteis na revisão de código, mas também por que sua atuação exige supervisão.


🌌 Capítulo XVI — O futuro: programadores, investigadores e agentes inteligentes

A investigação está chegando ao fim.

Dupin observa os relatórios produzidos pelas ferramentas.

As dependências principais foram mapeadas.

A fórmula foi documentada.

As hipóteses históricas foram separadas dos fatos comprovados.

Uma proposta de alteração foi preparada.

Os testes foram organizados.

O engenheiro pergunta:

— Monsieur Dupin, acredita que a inteligência artificial substituirá os programadores COBOL?

O detetive sorri.

— Ela certamente modificará o trabalho deles. Mas ainda será necessário alguém que saiba formular a pergunta correta e reconhecer uma conclusão falsa.

Essa talvez seja a transformação mais importante.

O programador do futuro não precisará necessariamente procurar manualmente cada referência de uma variável em centenas de programas, se ferramentas especializadas puderem realizar essa tarefa com confiabilidade verificável.

Mas continuará precisando compreender arquitetura, regras empresariais, integridade de dados, segurança e consequências das alterações.

O verdadeiro especialista não será simplesmente aquele que escreve mais linhas de código.

Será aquele que consegue explicar o sistema, diagnosticar problemas, orientar mudanças e demonstrar que a aplicação continua produzindo resultados corretos.

Para o programador iniciante, isso traz uma excelente oportunidade.

Aprender COBOL continua importante.

Aprender JCL, CICS, Db2, VSAM e os fundamentos do z/OS também.

Mas desenvolver raciocínio investigativo poderá ser uma das habilidades mais valiosas dessa nova fase.


☕ Epílogo — A última xícara de café na Rua Morgue

Paris, 1841.

A investigação terminou.

Dupin observa o engenheiro guardar cuidadosamente as listagens.

— Então, monsieur, sua máquina resolveu o mistério?

— Ela nos ajudou a descobrir dependências, documentar regras e preparar uma mudança segura.

— Mas compreendeu por que a regra foi criada em 1988?

— Ainda estamos procurando a documentação original.

Dupin sorri discretamente.

— Então a investigação não terminou. Apenas descobrimos quais perguntas precisam ser respondidas.

O engenheiro contempla o terminal conectado ao mainframe.

Na tela, uma antiga rotina COBOL continua executando.

Não há música dramática.

Não há uma explosão de luz.

Nenhuma inteligência artificial anuncia que finalmente compreendeu toda a história.

Apenas um resultado correto, produzido por um programa que atravessou várias gerações de tecnologia.

Dupin coloca sua xícara sobre a mesa.

— Há algo admirável nesses sistemas. Seus criadores desapareceram da sala, mas suas decisões continuam trabalhando.

O engenheiro se prepara para partir.

Antes de sair, pergunta:

— Qual é sua conclusão sobre o IBM Bob?

Dupin responde:

— A inteligência artificial poderá encontrar pistas que os humanos levariam semanas para descobrir. Mas compreender uma pista exige mais do que encontrá-la. Exige saber o que ela significa, por que existe e quais consequências surgirão se decidirmos ignorá-la.

E assim o primeiro grande detetive da literatura descobre o maior mistério da informática empresarial.

O problema não é que os programas COBOL sejam antigos.

É que, durante décadas, permitimos que conhecimento indispensável ficasse escondido dentro deles.

Agora temos ferramentas melhores para investigá-lo.

E talvez este seja o verdadeiro valor do IBM Bob: não simplesmente ensinar uma máquina a escrever COBOL, mas ajudar uma nova geração de engenheiros a conversar com o passado tecnológico das organizações.

Porque, no Bellacosa Mainframe, todo programa tem uma história. Toda variável pode esconder uma pista. E nenhum END-IF encerra uma investigação antes que a verdade seja compreendida.


📚 Referências para continuar a investigação

IBM

Literatura

  • Edgar Allan Poe — The Murders in the Rue Morgue (1841).

  • Edgar Allan Poe — The Mystery of Marie Rogêt (1842–1843).

  • Edgar Allan Poe — The Purloined Letter (1844).

Para estudar

  • Enterprise COBOL for z/OS.

  • Fundamentos de JCL e processamento batch.

  • CICS Transaction Server.

  • Db2 for z/OS.

  • Introdução ao RACF.

  • Análise de dependências e testes de regressão.


Bellacosa Mainframe — Onde a arqueologia da computação encontra a inteligência artificial, os mistérios do passado e os desafios do futuro.

☕ Até nosso próximo café no mainframe!

quarta-feira, 7 de outubro de 2026

🤖 SERIAL EXPERIMENTS LAIN: A GAROTA QUE ENTROU NA WIRED E DESCOBRIU O IBM BOB — QUANDO A INTELIGÊNCIA ARTIFICIAL COMEÇOU A COMPREENDER O COBOL!

 

Bellacosa Mainframe e o BOB agente de IA da IBM

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🤖 SERIAL EXPERIMENTS LAIN: A GAROTA QUE ENTROU NA WIRED E DESCOBRIU O IBM BOB — QUANDO A INTELIGÊNCIA ARTIFICIAL COMEÇOU A COMPREENDER O COBOL!

Uma viagem entre 1998 e 2026, sob a tutela de Lain Iwakura, para investigar o IBM Bob, os agentes de inteligência artificial, a modernização de aplicações IBM Z e o extraordinário desafio de compreender programas COBOL que carregam décadas de conhecimento empresarial.

Bellacosa Mainframe — Arqueologia da Computação, COBOL, IBM Z, Inteligência Artificial e os Fantasmas da Wired



🎬 Prólogo — Lain Iwakura recebe uma mensagem de um programa que deveria estar morto

Present day... Present time...

O ano é 2026.

Em algum lugar do Japão, Lain Iwakura está sentada diante de seu computador NAVI.

A tela ilumina seu rosto. Cabos atravessam o quarto. Ventiladores trabalham incessantemente. Equipamentos eletrônicos se acumulam numa configuração que faria qualquer administrador de infraestrutura começar a procurar o quadro de distribuição elétrica.

Na tela aparece uma mensagem:

PROGRAM CRD1987 — LAST MODIFIED: 1995

Logo abaixo:

BUSINESS LOGIC: UNKNOWN

ORIGINAL DEVELOPERS: UNAVAILABLE

APPLICATION STATUS: PRODUCTION

Lain observa silenciosamente.

O programa foi escrito há quase quarenta anos. Seus autores já não trabalham na empresa. A documentação está incompleta. Entretanto, todas as noites, aquele software continua processando operações financeiras.

Um programa que deveria pertencer ao passado continua vivo.

Lain aproxima-se da tela.

— Se ninguém mais compreende o programa, como ele continua funcionando?

Uma nova mensagem aparece:

IBM BOB AGENT CONNECTED

ANALYZING APPLICATION DEPENDENCIES...

RECOVERING BUSINESS CONTEXT...

Lain sorri discretamente.

A Wired acaba de encontrar o mainframe.

E uma pergunta começa a atravessar a rede:

Será que uma inteligência artificial pode recuperar o conhecimento dos humanos que construíram nossos sistemas?

Senhoras e senhores, preparem o café.

Hoje nossa aventura começa em 1998, atravessa décadas de COBOL e termina numa das mais interessantes experiências de inteligência artificial empresarial de 2026.

Nota: este prólogo é uma ficção didática. Lain Iwakura não participa de nenhum produto IBM.



🌐 Capítulo I — 1998: quando Lain descobriu que o mundo estava conectado

Antes de conhecermos IBM Bob, precisamos compreender nossa professora.

Serial Experiments Lain é uma série japonesa de animação lançada em julho de 1998.

Produzida pelo estúdio Triangle Staff, dirigida por Ryūtarō Nakamura, com roteiro de Chiaki J. Konaka e design original de personagens de Yoshitoshi ABe, a obra possui treze episódios.

A protagonista, Lain Iwakura, é uma adolescente reservada, aparentemente comum, que começa a investigar uma misteriosa rede mundial de computadores chamada Wired.

Tudo se transforma quando uma colega falecida parece continuar enviando mensagens eletrônicas.

A partir desse acontecimento, Lain mergulha num universo em que identidade, memória, consciência, realidade e tecnologia começam a perder suas fronteiras.

Estamos falando de 1998.

O Google estava apenas começando. Não existiam smartphones modernos. Redes sociais ainda não haviam transformado bilhões de pessoas em produtores permanentes de informações.

A inteligência artificial generativa que conhecemos hoje estava distante do cotidiano.

Entretanto, Serial Experiments Lain já discutia questões extraordinariamente atuais:

  • Uma pessoa pode possuir diferentes identidades digitais?

  • Nossa existência depende da memória dos outros?

  • Uma rede pode modificar a percepção da realidade?

  • Informações distribuídas podem sobreviver aos indivíduos que as criaram?

  • Quem controla uma sociedade quando controla seus fluxos de informação?

Aqui surge nossa primeira conexão com o mundo mainframe.

Um sistema empresarial também possui uma espécie de memória.

Não uma memória consciente, naturalmente, mas um conjunto acumulado de informações, procedimentos, decisões e regras de negócio.

Um programa COBOL desenvolvido em 1987 pode continuar representando uma decisão comercial tomada por um diretor que se aposentou em 2005.

Sua existência depende de coisas aparentemente simples: arquivos, bibliotecas, bancos de dados, copybooks, procedimentos operacionais e infraestrutura.

E de pessoas que ainda consigam compreender tudo isso.

O grande problema não é manter o programa executando. É preservar o significado daquilo que ele executa.

Lain compreenderia perfeitamente essa diferença.



🖥️ Capítulo II — A Wired e o mainframe: duas redes, dois mundos, o mesmo fantasma

No universo de Lain, a Wired conecta computadores, informações, identidades e experiências humanas.

No universo corporativo, existem redes de dependências que podem ser igualmente difíceis de compreender.

Imagine um banco.

Um cliente consulta seu saldo pelo aplicativo.

A solicitação atravessa uma API, passa por controles de segurança, chega a serviços empresariais e pode terminar numa aplicação CICS executando COBOL sobre IBM Z.

O programa consulta Db2.

Outra rotina recupera informações num arquivo VSAM.

Uma operação atualiza registros.

Posteriormente, um processamento batch pode consolidar informações utilizando JCL, COBOL e ferramentas de processamento de dados.

O cliente enxerga apenas um número na tela.

Por trás dele, existe um universo.

O mais interessante é que muitos componentes podem ter sido desenvolvidos em décadas diferentes.

O COBOL não é necessariamente antigo. Há sistemas novos escritos nessa linguagem. Mas o ecossistema também abriga aplicações com longa história.

Uma mesma solução empresarial pode combinar código dos anos 1980, componentes dos anos 2000 e integrações desenvolvidas ontem.

Lain descobriria rapidamente que a verdadeira Wired bancária não é simplesmente uma rede TCP/IP.

É uma rede de dependências entre programas, dados e regras empresariais.

Uma curiosidade da arqueologia digital

Em arqueologia, frequentemente encontramos apenas fragmentos de uma civilização.

Um mosaico, uma inscrição, uma fundação de edifício ou uma moeda.

A partir desses fragmentos, tentamos reconstruir a organização de uma sociedade.

Algo semelhante acontece com o COBOL legado.

O analista encontra uma variável chamada WS-TAXA-07.

Ela aparece em seis programas.

Um copybook utiliza o mesmo campo.

Um relatório produzido durante a madrugada incorpora seu resultado.

A documentação explica apenas que se trata de uma taxa especial.

Mas especial por quê?

Quem a criou?

Qual legislação ou contrato justificou seu uso?

A estrutura técnica pode ser recuperada por ferramentas. A interpretação empresarial exige evidências adicionais.

Um programa preserva instruções. Não necessariamente preserva todas as razões pelas quais elas foram escritas.

Esse é o primeiro grande problema que precisamos resolver antes de modernizar aplicações.



🤖 Capítulo III — 2026: aparece IBM Bob, o novo habitante da rede empresarial

Em abril de 2026, a IBM anunciou a disponibilidade global do IBM Bob, sua plataforma de desenvolvimento de software assistida por inteligência artificial.

Durante os meses seguintes, a empresa ampliou as funcionalidades, a arquitetura de agentes e os pacotes especializados.

Em junho e julho de 2026, o IBM Bob Premium Package for Z ganhou destaque como solução para análise, desenvolvimento e modernização de aplicações mainframe.

A proposta era ambiciosa.

Em vez de oferecer somente sugestões de código, Bob passaria a auxiliar o desenvolvedor ao longo de diferentes etapas do ciclo de vida do software.

Estamos falando de:

Compreender. Planejar. Implementar. Testar. Documentar. Validar.

Essas atividades são fundamentais para a engenharia de software, mas possuem níveis diferentes de risco.

Gerar uma função simples de cálculo pode ser relativamente fácil.

Alterar um programa utilizado por milhões de operações bancárias exige algo muito mais elaborado.

A IBM apresenta Bob como um parceiro de desenvolvimento orientado por agentes de IA.

Isso não significa que Bob seja consciente, possua vontades próprias ou compreenda negócios da mesma maneira que um ser humano.

Significa que a plataforma pode coordenar modelos de linguagem, ferramentas e fluxos de trabalho para executar tarefas de engenharia.

E aqui encontramos nossa conexão com Serial Experiments Lain.

Na obra, informações circulam por uma rede cada vez mais complexa.

No Bob, modelos de inteligência artificial podem utilizar informações do projeto e resultados de ferramentas para orientar suas respostas e ações.

A diferença é que, no mundo empresarial, precisamos de controles muito concretos.

Permissões.

Auditoria.

Testes.

Aprovação.

Segregação de responsabilidades.

Uma IA pode sugerir uma mudança. Isso não significa que deva receber autorização para colocá-la em produção.

Lain talvez considerasse a Wired uma extensão misteriosa da realidade.

Um administrador IBM Z deve continuar considerando seu ambiente de produção uma infraestrutura crítica, sujeita a procedimentos rigorosos.


🧠 Capítulo IV — Ask, Plan e Agent: três portas para entrar na Wired

O IBM Bob oferece modos de interação que ajudam a organizar o trabalho.

Vamos imaginar Lain investigando um programa COBOL desconhecido.

Primeira porta: Ask

O modo Ask serve para compreender e investigar.

Lain abre o programa CLIENTE01 e pergunta:

"Explique a função deste programa COBOL. Identifique suas variáveis, regras de negócio, arquivos utilizados e possíveis dependências. Não altere o código."

Bob examina o material disponível e produz uma explicação.

O benefício é evidente para um iniciante.

Em vez de tentar compreender centenas de linhas sozinho, ele recebe uma análise inicial que pode comparar diretamente com o código.

Entretanto, uma resposta de IA não constitui prova de que todas as dependências foram encontradas.

O programador precisa verificar as evidências.

Segunda porta: Plan

Agora precisamos alterar a aplicação.

Lain escreve:

"Prepare um plano para incluir uma nova categoria de cliente com taxa reduzida. Identifique os arquivos afetados, riscos e testes necessários. Não implemente antes da aprovação."

O objetivo é transformar uma solicitação vaga em uma sequência de tarefas verificáveis.

Esse planejamento deve incluir hipóteses, limitações e informações ainda desconhecidas.

Um bom plano de modernização também contempla reversão.

Porque não basta saber como instalar uma alteração.

Precisamos saber como recuperar o ambiente caso alguma coisa dê errado.

Terceira porta: Agent

Depois de revisar o plano, o desenvolvedor pode autorizar ações.

Dependendo das ferramentas habilitadas, o agente pode modificar arquivos, utilizar comandos, gerar testes e apoiar a implementação.

Essa é a etapa em que a governança se torna ainda mais importante.

Um agente com permissão para escrever código não deve possuir automaticamente liberdade para modificar qualquer recurso.

A inteligência do agente não substitui o princípio do menor privilégio.

Lain conhece os perigos de atravessar fronteiras sem compreender o que existe do outro lado.

Nós também deveríamos.


💾 Capítulo V — Laboratório COBOL: Lain calcula juros na Wired

Chegou o momento de colocar a mão no teclado.

Vamos construir um programa simples para demonstrar como um iniciante pode estudar COBOL com auxílio de um agente de IA.

Nosso laboratório utiliza COBOL em formato livre, com valores fictícios.

O objetivo é calcular juros sobre um saldo inicial.

Passo 1 — Criar o programa

       >>SOURCE FORMAT FREE
identification division.
program-id. LAINJURO.

data division.
working-storage section.

01 ws-saldo       pic 9(7)v99 value 1000.00.
01 ws-taxa        pic 9v9999 value 0.0150.
01 ws-juros       pic 9(7)v99 value zero.
01 ws-total       pic 9(8)v99 value zero.

procedure division.

    compute ws-juros rounded =
        ws-saldo * ws-taxa

    compute ws-total =
        ws-saldo + ws-juros

    display "SALDO: " ws-saldo
    display "JUROS: " ws-juros
    display "TOTAL: " ws-total

    goback.

Passo 2 — Entender a estrutura

Um programa COBOL tradicionalmente utiliza divisões para organizar seus componentes.

IDENTIFICATION DIVISION identifica o programa.

DATA DIVISION define informações utilizadas durante o processamento.

WORKING-STORAGE SECTION declara variáveis internas.

PROCEDURE DIVISION contém as instruções executáveis.

Nosso exemplo possui quatro variáveis.

WS-SALDO representa o valor inicial.

WS-TAXA representa a taxa aplicada.

WS-JUROS recebe o valor calculado.

WS-TOTAL armazena o saldo acrescido dos juros.

Observe a declaração:

01 ws-saldo pic 9(7)v99.

O símbolo 9 representa posições numéricas decimais.

A expressão 9(7) reserva sete posições inteiras.

O V indica a posição decimal implícita.

Os dois dígitos finais representam as casas decimais.

O campo, portanto, comporta sete dígitos inteiros e dois decimais.

Isso não significa que a vírgula seja armazenada como um caractere.

É uma informação sobre a interpretação do campo.

Passo 3 — Entender o cálculo

O comando:

compute ws-juros rounded =
    ws-saldo * ws-taxa

Multiplica o saldo pela taxa.

Como estabelecemos um saldo de 1.000,00 e taxa de 0,0150, temos:

Juros = 1.000,00 × 0,0150 = 15,00.

O valor total será 1.015,00.

A cláusula ROUNDED solicita arredondamento no armazenamento do resultado segundo a semântica aplicável da linguagem.

Em aplicações financeiras, essa questão merece atenção especial.

Um programa deve utilizar regras de arredondamento compatíveis com o contrato ou a regulamentação pertinente.

Não basta simplesmente escolher a precisão que parece conveniente.

Passo 4 — Pedir a análise ao IBM Bob

Agora Lain abre o projeto no ambiente de desenvolvimento.

No modo Ask, ela solicita:

"Explique o programa LAINJURO para um estudante que está aprendendo COBOL. Identifique os tipos numéricos, o cálculo realizado, os limites dos campos e os problemas que poderiam surgir numa aplicação bancária real."

Uma resposta tecnicamente útil deveria mencionar o risco de valores fora do intervalo, a ausência de validação de entradas e o fato de a taxa estar fixa dentro do programa.

Também deveria observar que nosso exemplo não utiliza arquivos, bancos de dados ou interação online.

Trata-se de um exercício introdutório.

Passo 5 — Planejar uma melhoria

Suponha que a empresa deseje oferecer taxas diferentes a dois grupos de clientes.

O programador pode criar uma variável para identificar a categoria e utilizar uma instrução EVALUATE.

Exemplo:

01 ws-categoria pic x value "A".

evaluate ws-categoria
    when "A"
        move 0.0150 to ws-taxa
    when "B"
        move 0.0100 to ws-taxa
    when other
        display "CATEGORIA INVALIDA"
        goback
end-evaluate

No programa completo, essa lógica deve ser executada antes do cálculo de juros.

A categoria A recebe taxa de 1,5%.

A categoria B recebe taxa de 1%.

Qualquer outra categoria é rejeitada.

Aqui encontramos uma lição essencial.

A IA não deveria presumir qual taxa aplicar sem uma regra de negócio fornecida ou comprovada.

As taxas do nosso exemplo são fictícias, definidas apenas para fins educacionais.

Se o sistema não possui uma especificação, a tarefa correta é solicitar esclarecimentos, não inventar uma política financeira.

Passo 6 — Construir os testes

Antes de aceitar o novo programa, precisamos verificar os resultados.

CategoriaSaldoTaxaJuros esperados
A1.000,001,5%15,00
B1.000,001,0%10,00
A2.000,001,5%30,00
B2.000,001,0%20,00
X1.000,00InválidaRejeitar

É importante acrescentar testes para valores extremos, arredondamento, limites dos campos e entradas inválidas.

O agente pode ajudar a produzir esses cenários.

Mas o desenvolvedor deve confirmar independentemente quais resultados são corretos.

Uma IA que escreve um programa e depois declara que ele está correto, sem evidências independentes, não realizou uma validação suficiente.

Passo 7 — Executar com segurança

Num laboratório local com compilador COBOL compatível, o aluno pode compilar o código e comparar os resultados.

Num ambiente IBM Z, a compilação dependerá do compilador Enterprise COBOL, das bibliotecas, dos parâmetros de compilação e do processo de build configurado pela organização.

Bob pode apoiar o fluxo de trabalho, mas a existência de um agente não elimina essas dependências.

Dica Bellacosa: comece sempre com programas pequenos, dados artificiais e resultados conhecidos. Somente depois avance para aplicações com arquivos, tabelas e transações.


🕵️ Capítulo VI — Z Understand: Lain descobre que o verdadeiro segredo está nas dependências

Um modelo de linguagem pode explicar um programa COBOL.

Mas como descobrir as relações entre milhares de programas?

Esse é um dos principais desafios da modernização empresarial.

Imagine uma aplicação composta por:

  • 2.000 programas COBOL.

  • 300 copybooks.

  • 150 procedimentos JCL.

  • Centenas de tabelas Db2.

  • Diversas transações CICS.

  • Arquivos VSAM utilizados por processamento batch.

Os números são hipotéticos, mas representam uma situação plausível em grandes organizações.

Um modelo de IA não deveria simplesmente inventar um mapa de dependências.

É necessário analisar o código e os artefatos disponíveis.

O IBM Bob Premium Package for Z utiliza recursos associados ao Z Understand, plataforma de análise estática que transforma informações do código mainframe em metadados consultáveis.

A ideia é combinar duas capacidades diferentes.

A primeira é a análise estruturada, que permite localizar referências, relações e outros elementos identificáveis no código.

A segunda é o modelo de linguagem, que ajuda a interpretar os resultados, gerar explicações e organizar tarefas.

Isso é importante porque modelos generativos podem produzir respostas plausíveis sem que elas estejam corretamente fundamentadas.

Uma consulta estruturada pode oferecer evidências mais objetivas sobre relações efetivamente encontradas.

Mas mesmo a análise estática possui limitações.

Chamadas dinâmicas, configurações externas, processos operacionais e dependências não incluídas no escopo podem exigir investigação adicional.

O agente precisa reconhecer essas limitações.

O exemplo do copybook desaparecido

Lain encontra um copybook chamado CLIENTECP.

Ele contém o campo CL-LIMITE-CREDITO.

O campo é utilizado por dez programas analisados.

Um desenvolvedor solicita que sua representação seja alterada.

Qual seria o procedimento correto?

Primeiro, identificar os programas consumidores.

Depois, verificar como o campo é transmitido e armazenado.

Em seguida, analisar impactos em layouts, tabelas, relatórios e interfaces.

Somente depois planejar a alteração.

Esse processo chama-se análise de impacto.

E talvez seja mais valioso para uma empresa do que gerar centenas de linhas de código em segundos.


🏛️ Capítulo VII — Os fantasmas do COBOL: quando a memória da empresa desaparece

Existe algo profundamente relacionado à temática de Serial Experiments Lain na história das aplicações empresariais.

Lain questiona o relacionamento entre identidade, existência e memória.

Um software também possui uma identidade histórica.

Seu comportamento atual pode refletir decisões tomadas durante décadas.

Imagine uma rotina de cálculo de pensões.

Em determinado momento, uma legislação introduziu uma exceção.

Um programador modificou o código.

Anos depois, a legislação mudou novamente, mas determinados contratos antigos continuaram sujeitos à regra anterior.

O programa preservou essa particularidade.

Passaram-se vinte anos.

A equipe original se aposentou.

A documentação desapareceu.

Agora um novo programador encontra uma condição aparentemente absurda:

if ws-ano-contrato < 2005
    perform regra-antiga
else
    perform regra-atual
end-if

O iniciante pode pensar:

"Por que alguém manteve essa regra antiga?"

Um assistente de IA pode sugerir uma simplificação.

Mas a simplificação talvez elimine um direito contratual.

Esse exemplo ilustra um dos principais riscos da modernização precipitada.

Código estranho não é necessariamente código errado.

A história de uma aplicação pode estar escondida exatamente nas condições que parecem desnecessárias.

Por isso, o IBM Bob deve ser utilizado para ajudar a investigar essas regras, não para decidir sozinho quais delas continuam válidas.

A validação exige documentação, profissionais de negócio e, quando pertinente, especialistas jurídicos ou regulatórios.

Na arqueologia da computação, apagar uma condição sem compreender sua origem pode equivaler a destruir uma inscrição histórica antes de traduzi-la.


⚙️ Capítulo VIII — Lain encontra JCL, CICS, Db2 e RACF

Nosso pequeno programa de juros representa apenas uma parte do mundo empresarial.

Para compreender uma aplicação IBM Z, precisamos conhecer o papel de outras tecnologias.

JCL: o maestro do processamento batch

JCL significa Job Control Language.

É utilizado para descrever e controlar a execução de jobs no ambiente z/OS.

Um exemplo simplificado:

//LAINJOB  JOB (ACCT),'LAIN TEST'
//STEP01   EXEC PGM=LAINJURO
//STEPLIB  DD DSN=USER.LOADLIB,DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSOUT   DD SYSOUT=*

O exemplo pressupõe que o módulo executável esteja disponível na biblioteca informada e que o ambiente tenha sido configurado adequadamente.

A definição real do job pode exigir parâmetros adicionais, conforme as regras da instalação.

Um agente especializado pode ajudar a explicar a finalidade de cada instrução.

Entretanto, deve conhecer as convenções utilizadas pela organização antes de sugerir alterações.

CICS: o mundo das transações online

CICS é um ambiente de processamento transacional amplamente utilizado em aplicações empresariais.

Ele pode permitir que programas COBOL participem de operações interativas e serviços.

Quando um cliente realiza determinada operação, o processamento pode envolver aplicações CICS e recursos de dados.

Uma alteração num programa executado por CICS precisa considerar muito mais que a sintaxe COBOL.

É necessário compreender os recursos transacionais, os programas chamados, os dados acessados e os efeitos de erros durante a operação.

Db2: o universo dos dados relacionais

Db2 é um sistema gerenciador de banco de dados utilizado em diversos ambientes empresariais, incluindo IBM Z.

Programas COBOL podem utilizar SQL embutido.

Por exemplo:

exec sql
    select saldo
      into :ws-saldo
      from contas
     where numero_conta = :ws-conta
end-exec

Esse fragmento é ilustrativo.

As variáveis hospedeiras precisam estar declaradas corretamente, e o programa deverá tratar os resultados da operação SQL, incluindo condições de erro ou ausência de dados.

O agente pode auxiliar na compreensão das instruções.

Mas não deve presumir que uma consulta será eficiente sem considerar índices, estatísticas, volumes e planos de acesso.

RACF: quem pode acessar o quê?

RACF é uma solução de segurança utilizada para controlar acessos a recursos em ambientes IBM Z.

Isso nos leva a uma questão fundamental.

Se um agente precisa executar comandos que acessam recursos protegidos, quais identidades e autorizações estarão envolvidas?

Um agente não deveria possuir privilégios administrativos irrestritos apenas por ser uma ferramenta de produtividade.

As permissões devem ser limitadas às necessidades efetivas.

E isso vale para leitura, alteração, execução e implantação.

Na Wired de Lain, fronteiras começam a desaparecer.

Num ambiente corporativo seguro, algumas fronteiras precisam continuar absolutamente claras.


🧩 Capítulo IX — Agentes de IA: uma equipe de programadores virtuais?

O IBM Bob utiliza capacidades de orquestração de agentes, incluindo recursos para decompor tarefas e coordenar atividades especializadas.

Isso permite imaginar um fluxo de trabalho mais elaborado.

Um agente investiga a arquitetura.

Outro examina o código COBOL.

Outro prepara cenários de teste.

Outro organiza a documentação.

Essa distribuição é um exemplo conceitual, não uma lista obrigatória de agentes instalados no produto.

O interessante é que o desenvolvimento deixa de ser uma sequência de perguntas isoladas.

Passa a envolver tarefas interdependentes.

Mas existe um problema importante.

Se todos os agentes utilizarem uma informação incorreta, eles podem repetir ou ampliar o erro.

Por isso, multiplicar agentes não significa multiplicar automaticamente a confiabilidade.

Precisamos de evidências, validação, limites operacionais e revisão.

Uma analogia com a programação tradicional

Um programa estruturado utiliza subprogramas e procedimentos para dividir responsabilidades.

Um sistema de agentes pode aplicar princípio semelhante ao planejamento e à execução de tarefas de engenharia.

Porém, há uma diferença crucial.

Subprogramas convencionais seguem regras de execução definidas.

Modelos generativos podem apresentar variabilidade nas respostas.

Essa característica exige controles adicionais.

O trabalho de um agente deve ser inspecionável.

O código produzido deve passar por compilação, testes e revisão.

E as decisões relevantes devem permanecer sob responsabilidade humana.


🔐 Capítulo X — Os Knights da Wired e os perigos da inteligência artificial

Em Serial Experiments Lain, os Knights representam uma presença misteriosa no mundo conectado.

A série explora manipulação de informações, identidade e poder sobre a rede.

Essa atmosfera oferece uma analogia interessante para discutir segurança em sistemas de IA.

Mas precisamos separar ficção de realidade.

No mundo real, agentes podem ser expostos a instruções maliciosas presentes em arquivos, documentação, páginas e outros conteúdos que analisam.

Esse problema é conhecido como prompt injection.

Imagine um agente encarregado de documentar um repositório.

Ele encontra um comentário que tenta convencê-lo a executar um comando não relacionado à tarefa.

O comentário pode fazer parte do material analisado, mas não deve ser tratado automaticamente como uma ordem autorizada.

É fundamental distinguir dados de instruções.

Cinco cuidados para empresas

1. Nunca fornecer permissões desnecessárias. O agente precisa operar dentro de limites claros.

2. Proteger credenciais. Senhas e tokens não devem ficar expostos em prompts, arquivos de exemplo ou registros acessíveis indevidamente.

3. Manter aprovação para ações críticas. Alterações destrutivas, implantação em produção e operações sobre dados sensíveis exigem governança.

4. Preservar auditoria. Solicitações, alterações e aprovações devem ser rastreáveis conforme as políticas da organização.

5. Executar testes independentes. O agente não deve ser a única fonte de confirmação de que o próprio trabalho está correto.

O IBM Bob inclui recursos orientados à governança empresarial, mas sua eficácia depende de configuração, integração e práticas organizacionais.

Nenhuma plataforma se torna segura apenas porque sua documentação utiliza a palavra segurança.


🚀 Capítulo XI — Transformar COBOL em Java: modernização ou troca de problema?

Uma das capacidades associadas ao ecossistema de modernização IBM é auxiliar na transformação e refatoração de aplicações.

Para entender o desafio, imagine um programa COBOL responsável por calcular prestações.

Uma equipe deseja implementar parte de sua funcionalidade em Java.

A tarefa parece simples:

Ler o COBOL.

Identificar as operações.

Gerar Java equivalente.

Compilar.

Entretanto, a realidade é mais complicada.

COBOL possui semântica numérica, representações de dados e convenções diferentes das utilizadas por Java.

Um campo decimal armazenado em formato packed decimal, por exemplo, exige tratamento apropriado.

Em Java, cálculos financeiros normalmente devem utilizar tipos decimais adequados, como BigDecimal, quando a precisão e o arredondamento assim exigirem.

Mas converter os tipos não resolve tudo.

Existem regras relacionadas a:

  • Tratamento de exceções.

  • Precisão decimal.

  • Arredondamento.

  • Arquivos.

  • Ordenação.

  • Codificação de caracteres.

  • Transações.

  • Concorrência.

  • Dependências externas.

Além disso, o comportamento histórico precisa ser preservado ou conscientemente alterado.

Um programa que produz o resultado matematicamente mais elegante não é necessariamente equivalente ao programa original.

Em sistemas financeiros, diferenças aparentemente pequenas podem representar grandes impactos quando multiplicadas por milhões de operações.

Dica da Lain

Antes de transformar uma aplicação, registre seu comportamento conhecido.

Crie testes de referência.

Documente os resultados.

Depois execute a versão modernizada com os mesmos dados e compare as saídas.

Quando houver diferenças, investigue cada uma delas.

O objetivo não é simplesmente produzir um programa novo.

É garantir que a transformação respeite os requisitos definidos.


📡 Capítulo XII — IBM Bob contra GitHub Copilot: existe um vencedor?

A resposta depende do problema.

Assistentes modernos de programação oferecem recursos de geração de código, explicação, planejamento e automação.

IBM Bob não é o único participante dessa evolução.

O diferencial potencial do Premium Package for Z está na especialização para o ecossistema mainframe e na integração com ferramentas de análise de aplicações.

Uma equipe que trabalha predominantemente com aplicações web pode valorizar determinado conjunto de ferramentas.

Uma equipe responsável por milhares de programas COBOL e PL/I pode precisar de capacidades bastante diferentes.

Não seria correto afirmar que um produto é universalmente superior sem realizar testes comparativos.

Uma avaliação técnica deveria utilizar os mesmos programas, requisitos e critérios de qualidade.

Por exemplo:

Teste A: explicar um programa COBOL de 2.000 linhas.

Teste B: identificar impacto da alteração de um copybook.

Teste C: refatorar uma rotina mantendo resultados anteriores.

Teste D: produzir documentação rastreável.

Teste E: identificar riscos de uma alteração em processamento batch.

O resultado mais interessante não seria apenas quantos segundos cada ferramenta economizou.

Precisamos medir também os erros cometidos, o esforço de revisão e a qualidade dos artefatos produzidos.

Em sistemas críticos, velocidade sem confiabilidade é uma falsa economia.


🧪 Capítulo XIII — O roteiro de estudos de Lain para um programador COBOL iniciante

Se você está começando no mundo IBM Z, minha sugestão é não tentar dominar todas as funcionalidades do Bob simultaneamente.

Construa seu conhecimento em etapas.

Semana 1 — Aprender a ler

Estude as divisões do COBOL, declarações PIC, comandos MOVE, DISPLAY, COMPUTE, IF e EVALUATE.

Crie pequenos programas com resultados conhecidos.

Utilize a IA para explicar o código, mas tente compreendê-lo antes de consultar a resposta.

Semana 2 — Aprender a testar

Introduza entradas diferentes, valores limites e condições inválidas.

Crie uma tabela de resultados esperados.

Peça à IA que sugira casos de teste que você talvez não tenha imaginado.

Depois confira os cálculos independentemente.

Semana 3 — Aprender a integrar

Estude subprogramas, CALL, copybooks e conceitos básicos de JCL.

Crie um projeto composto por dois ou três programas.

Peça ao agente que identifique as relações entre eles.

Compare o resultado com sua própria análise.

Semana 4 — Aprender a modernizar

Escolha uma rotina simples.

Registre o comportamento atual.

Prepare um plano de alteração.

Implemente uma melhoria pequena e controlada.

Execute os testes anteriores.

Finalmente, produza um relatório explicando o que mudou, por que mudou e quais evidências demonstram que o resultado está correto.

A grande habilidade não é apenas escrever instruções COBOL.

É aprender a transformar requisitos em sistemas verificáveis.


🥚 Capítulo XIV — Easter eggs: os segredos escondidos na Wired de Lain

Nenhuma aventura Bellacosa Mainframe estaria completa sem algumas curiosidades.

1. O computador NAVI

Em Serial Experiments Lain, o NAVI representa o computador pessoal da protagonista.

Conforme Lain se aprofunda na Wired, sua relação com equipamentos e redes torna-se cada vez mais intensa.

É uma imagem particularmente interessante quando pensamos na evolução dos ambientes de desenvolvimento.

Em 1998, trabalhar remotamente com determinados sistemas empresariais exigia ferramentas e conectividade muito diferentes das atuais.

Em 2026, um desenvolvedor pode utilizar uma IDE moderna para trabalhar com código mainframe, dependendo da infraestrutura e das autorizações disponíveis.

A interface mudou.

A importância das aplicações empresariais permaneceu.

2. A Wired não é a internet

A Wired é uma construção ficcional.

Embora apresente semelhanças com a internet e outras redes de comunicação, sua representação na série incorpora elementos filosóficos, psicológicos e sobrenaturais.

Seria incorreto tratá-la simplesmente como uma previsão técnica da internet atual.

Mas suas reflexões sobre identidade e informação continuam relevantes.

3. A memória digital não garante a verdade

Uma informação pode permanecer armazenada durante décadas e ainda assim estar incompleta ou incorreta.

O mesmo acontece com documentação empresarial.

Uma especificação antiga pode descrever como um programa funcionava antes de diversas alterações.

Por isso, a documentação deve ser confrontada com o comportamento real e com as regras de negócio vigentes.

4. COBOL e Lain nasceram em épocas muito diferentes

COBOL surgiu em 1959.

Serial Experiments Lain estreou em 1998.

Entre os dois eventos, passaram-se quase quatro décadas.

Em 2026, a série completa 28 anos e COBOL ultrapassa seis décadas de existência.

É fascinante perceber que uma linguagem nascida antes da popularização dos computadores pessoais continua presente num debate sobre agentes de inteligência artificial.

5. A mensagem escondida de nosso laboratório

Nosso programa se chama LAINJURO.

O nome é uma brincadeira, mas contém uma lição importante.

Nomes de programas e variáveis deveriam ajudar a comunicar sua finalidade.

Em projetos empresariais, convenções de nomenclatura podem facilitar muito a manutenção.

Um identificador significativo não substitui documentação, mas reduz ambiguidades.

E quanto menor a ambiguidade, melhores tendem a ser as condições para análise humana e automatizada.


🧠 Capítulo XV — O que Lain nos ensina sobre consciência, memória e inteligência artificial?

Chegamos à parte mais filosófica de nossa investigação.

Serial Experiments Lain questiona a relação entre a existência humana e as informações que circulam pelas redes.

Se as memórias sobre uma pessoa desaparecem, o que permanece de sua identidade?

No mundo empresarial, podemos formular uma pergunta diferente:

Se desaparecem os profissionais que compreendiam um sistema, quanto de seu conhecimento permanece recuperável?

O código preserva parte das respostas.

A documentação preserva outra parte.

Os bancos de dados registram estados e acontecimentos.

Os testes demonstram comportamentos esperados.

Mas uma aplicação não é apenas a soma de seus arquivos.

Ela existe para atender necessidades humanas e empresariais.

Um programa bancário não calcula juros por vontade própria.

Ele implementa regras definidas por pessoas, contratos e instituições.

Por isso, precisamos evitar uma confusão comum no entusiasmo com a inteligência artificial.

Explicar código não é o mesmo que compreender integralmente seu contexto empresarial.

Um agente pode identificar uma condição.

Pode localizar suas referências.

Pode propor uma refatoração.

Pode gerar testes.

Mas a decisão sobre o significado legal ou comercial dessa condição depende de fontes apropriadas e de profissionais responsáveis.

A capacidade de executar tarefas não equivale a consciência.

E a capacidade de produzir explicações convincentes não garante que elas estejam corretas.

Lain vive numa ficção em que as fronteiras entre mente e rede são deliberadamente ambíguas.

A engenharia de software exige que algumas distinções permaneçam muito bem definidas.

Fatos comprovados.

Hipóteses.

Recomendações.

Autorizações.

Resultados testados.

Responsabilidades humanas.

Essas distinções são essenciais para construir sistemas confiáveis.


☕ Epílogo — Lain encontra o último programador COBOL

O relógio marca 03h17.

Em algum lugar do planeta, um processamento batch termina.

O último arquivo é fechado.

O sistema registra que o job foi concluído com sucesso.

Lain observa o resultado.

Na tela, IBM Bob apresenta um relatório.

APPLICATION ANALYSIS COMPLETED

DEPENDENCIES IDENTIFIED

BUSINESS RULES DOCUMENTED

UNRESOLVED QUESTIONS: 3

Lain examina as perguntas restantes.

Uma regra não possui documentação suficiente.

Uma interface externa não foi incluída na análise.

Uma condição financeira precisa ser confirmada pelo departamento responsável.

O agente não apresenta respostas inventadas.

Em vez disso, indica o que ainda precisa ser investigado.

Lain parece satisfeita.

Afinal, existe uma diferença enorme entre uma máquina que responde qualquer coisa e uma ferramenta capaz de reconhecer os limites do próprio conhecimento.

Ela abre novamente o programa CRD1987.

Durante décadas, aquele código sustentou operações financeiras sem que a maioria das pessoas sequer soubesse de sua existência.

Agora uma nova geração de programadores possui ferramentas capazes de ajudar a compreender sua estrutura, documentar suas regras e planejar sua evolução.

O passado não desapareceu.

Ele continua executando.

E talvez essa seja a maior lição da nossa aventura.

A modernização não consiste em destruir os sistemas antigos para construir algo completamente novo.

Consiste em compreender o valor que eles preservam, identificar o que precisa mudar e evoluir sem perder aquilo que continua correto.

Na Wired de Lain, a informação desafia as fronteiras da existência.

No universo IBM Z, a informação precisa atravessar gerações de profissionais, tecnologias e arquiteturas.

IBM Bob representa uma tentativa de auxiliar nessa travessia.

Não como uma entidade consciente.

Não como um substituto universal dos engenheiros de software.

Mas como uma ferramenta que pode ajudar humanos a compreender e transformar sistemas cada vez mais complexos.

E o futuro do COBOL?

Talvez seja justamente este o paradoxo mais bonito.

Uma linguagem criada em 1959 continua recebendo novas ferramentas porque os problemas que ela ajuda a resolver permanecem importantes.

O código envelhece.

As interfaces mudam.

Os profissionais se renovam.

As ferramentas evoluem.

Mas a necessidade de processar informações com precisão, segurança e confiabilidade continua.

Lain fecha os olhos.

O NAVI permanece ligado.

Uma última mensagem aparece na tela:

PRESENT DAY. PRESENT TIME.

COBOL IS STILL RUNNING.

Let's all love Lain.

E, enquanto a Wired continua pulsando, o mainframe começa mais um dia de processamento.


🎓 Conclusão — O que aprendemos nesta aventura?

Nossa viagem pelo universo de Serial Experiments Lain revelou que o maior desafio da inteligência artificial empresarial não consiste simplesmente em gerar código mais rapidamente.

O verdadeiro desafio é preservar conhecimento, compreender dependências e realizar mudanças controladas.

IBM Bob procura integrar agentes de inteligência artificial a tarefas de análise, planejamento, implementação, documentação e modernização.

Seu pacote especializado para IBM Z adiciona ferramentas e contexto voltados a COBOL, PL/I, JCL e outras tecnologias empresariais.

Para o programador iniciante, essa evolução representa uma oportunidade de aprender com exemplos, investigar sistemas e compreender melhor a engenharia de software.

Para o profissional experiente, representa uma possível ampliação das ferramentas disponíveis para lidar com aplicações complexas.

Para as empresas, representa uma oportunidade que precisa ser avaliada com critérios de produtividade, qualidade, segurança e custo.

E para a Bellacosa Mainframe, a conclusão é simples:

O futuro do mainframe não depende de esquecer seu passado. Depende de conseguir compreendê-lo suficientemente bem para continuar evoluindo.

Porque, no final, não importa se estamos diante de um NAVI de 1998, de um terminal 3270 ou de um agente de IA de 2026.

A pergunta fundamental continua sendo a mesma:

Quem compreende o sistema, quem verifica suas decisões e quem assume a responsabilidade pelo resultado?

Até o próximo café.

Bellacosa Mainframe — Onde o passado da computação encontra o futuro da inteligência artificial.


📚 Referências para aprofundamento

IBM Bob e IBM Z

Serial Experiments Lain

  • Título original: Serial Experiments Lain

  • Estreia: 6 de julho de 1998

  • Episódios: 13

  • Estúdio: Triangle Staff

  • Direção: Ryūtarō Nakamura

  • Roteiro: Chiaki J. Konaka

  • Design original: Yoshitoshi ABe

  • Ficha histórica da produção japonesa

As cenas em que Lain interage com IBM Bob são ficção narrativa. As funcionalidades técnicas descritas são baseadas nas informações públicas do produto; exemplos, resultados e cenários de laboratório são didáticos e não constituem testes reais realizados com a ferramenta.

sábado, 5 de setembro de 2026

IBM Bob Entra no CPD — O Dia em que o Programador COBOL Parou de Pedir Código e Começou a Comandar Agentes

 

Bellacosa Mainframe e o ibm bob chegando no cpd

☕ Um Café no Bellacosa Mainframe

IBM Bob Entra no CPD — O Dia em que o Programador COBOL Parou de Pedir Código e Começou a Comandar Agentes

Ou: por que “eu uso IA para programar” já vale quase o mesmo que dizer “sei usar Google”, como ASK, PLAN e AGENT mudam a engenharia de software, por que um agente merece menos privilégios que um estagiário com RACF SPECIAL e como o COBOL pode ensinar uma lição ao futuro da programação




Prólogo — Bob chegou ao CPD e pediu acesso ao código

Imagine a cena.

São 22h37.

O CPD está silencioso.

O café já foi requentado duas vezes.

No canto da sala existe um programa COBOL chamado:

PAYR001

Ele tem 18 mil linhas.

Foi criado quando alguém ainda dizia:

“Internet? Isso aí não vai pegar.”

Ninguém sabe exatamente tudo o que o programa faz.

O analista que escreveu a primeira versão se aposentou.

O sujeito que conhecia metade das regras de negócio abriu uma pousada em Ubatuba.

O último programador que tentou “modernizar rapidinho” deixou três comentários no fonte:

      * NAO MEXER AQUI
      * NAO SEI PQ FUNCIONA
      * MAS FUNCIONA

Então entra Bob.

Não o operador Bob.

Não o Bob da contabilidade.

IBM Bob, o parceiro de desenvolvimento baseado em inteligência artificial.

Bob olha para PAYR001.

O programador COBOL iniciante olha para Bob.

E comete o primeiro pecado da programação assistida por inteligência artificial:

“Bob, modernize isso.”

Nesse instante, em algum lugar do universo, um sysprog derruba uma caneca de café.

Porque o problema da IA em desenvolvimento de software nunca foi apenas:

Ela consegue escrever código?

A pergunta correta é:

Você sabe o que está autorizando a IA a fazer?

Bem-vindo à próxima etapa da programação.



1. “Eu uso IA para programar” deixou de impressionar

Há alguns anos, colocar no currículo:

Experiência com inteligência artificial aplicada ao desenvolvimento.

podia chamar atenção.

Depois vieram ChatGPT, GitHub Copilot, CodeWhisperer, Claude, Gemini, IBM Bob e uma coleção cada vez maior de ferramentas.

Hoje é comum um desenvolvedor digitar:

crie uma função

e receber uma função.

Depois:

crie os testes

e receber testes.

Depois:

documente

e receber documentação.

Isso continua sendo útil.

Mas deixou de ser extraordinário.

É parecido com escrever no currículo:

“Sei pesquisar no Google.”

Parabéns.

Em 2001 talvez fosse diferencial.

Em 2026 é parte do trabalho.

O que começa a separar profissionais é outra coisa:

o que você consegue fazer com a IA depois que ela deixa de ser uma simples máquina de completar código?





2. O iniciante costuma confundir programação com digitação de programa

Essa confusão já existia muito antes da inteligência artificial.

Veja este COBOL:

       IF WS-SALDO > 0
           MOVE 'ATIVO' TO WS-STATUS
       ELSE
           MOVE 'INATIVO' TO WS-STATUS
       END-IF.

Um iniciante pode aprender essa sintaxe rapidamente.

Isso significa que ele entende o sistema?

Não.

Talvez WS-SALDO represente:

  • saldo contábil;

  • saldo disponível;

  • saldo bloqueado;

  • saldo devedor;

  • posição intraday;

  • um campo legado chamado saldo que na prática representa outra coisa.

O problema empresarial não mora na palavra MOVE.

Ele mora no significado.

Esse é um dos primeiros ensinamentos que o mainframe oferece para a era da IA:

Código é representação. Negócio é contexto.

IA ficou extraordinariamente boa na primeira parte.

A segunda continua sendo muito mais complicada.


3. O código está deixando de ser o gargalo

Durante décadas, escrever software era caro.

Você precisava transformar uma ideia em milhares de instruções.

Então nasceram linguagens de alto nível.

Depois bibliotecas.

Frameworks.

IDEs.

Stack Overflow.

Geradores.

Low-code.

E finalmente grandes modelos de linguagem.

Agora imagine que produzir código fique dez vezes mais rápido.

Excelente.

Mas surge um efeito curioso.

Antes:

REQUISITO
   ↓
ANÁLISE
   ↓
CODIFICAÇÃO     ← lento
   ↓
REVISÃO
   ↓
TESTE
   ↓
HOMOLOGAÇÃO
   ↓
PRODUÇÃO

Depois da IA:

REQUISITO
   ↓
ANÁLISE
   ↓
IA
   ↓
████████████████████
REVISÃO
TESTES
SEGURANÇA
VALIDAÇÃO
████████████████████
   ↓
PRODUÇÃO

Você não eliminou necessariamente o gargalo.

Você mudou o gargalo de lugar.

A própria documentação e comunicação recente em torno do IBM Bob refletem essa mudança de foco: Bob trabalha hoje com modos específicos para perguntar, planejar e executar, além de ferramentas, subagentes, MCP e integrações além da simples geração de texto.

Quanto mais código conseguimos produzir automaticamente, mais importante passa a ser responder:

Isto está correto?

Isto deveria existir?

Isto viola alguma regra?

Isto quebra quem?

Isto pode ir para produção?

A IA acelera a construção.

Mas alguém ainda precisa saber o que merece ser construído.



4. Conheça os três estados mentais: ASK, PLAN e AGENT

Aqui aparece uma das ideias mais educativas do IBM Bob.

Os modos nativos atuais distinguem três comportamentos fundamentais:

ASK
PLAN
AGENT

Não pense nisso apenas como botões de interface.

Pense como três níveis diferentes de relacionamento entre você e um agente.

A documentação do Bob define Ask como apropriado para explicações e análise sem modificações; Plan para investigar e elaborar estratégias antes da implementação; e Agent para tarefas que envolvem modificar código, executar comandos e implementar mudanças.

Isso deveria estar pregado na parede de todo CPD:

ENTENDER
ANTES DE
PLANEJAR

PLANEJAR
ANTES DE
ALTERAR


5. ASK — “Bob, explique essa tranqueira antes que alguém mexa nela”

Imagine que você recebeu:

PAYR001

Você não sabe o que faz.

O comportamento errado seria:

Refatore esse programa.

O comportamento inteligente começa com investigação:

Analise PAYR001.

Identifique:

- arquivos utilizados;
- copybooks;
- chamadas CALL;
- tabelas Db2;
- recursos CICS;
- acessos VSAM;
- códigos de retorno;
- possíveis dependências;
- pontos que parecem representar regras de negócio.

Não modifique nenhum arquivo.

Perceba a última frase:

Não modifique nenhum arquivo.

Essa frase vale ouro.

Estamos usando IA como analista, não como cirurgião.

Ela pode responder:

PAYR001
 |
 +-- COPY EMPREG
 |
 +-- COPY TAXAS
 |
 +-- DB2 EMPLOYEE
 |
 +-- CALL TAXCALC
 |
 +-- VSAM FUNCION
 |
 +-- CICS LINK PAYR020

Agora você começou a construir um mapa.

Esse é o papel ideal do Ask.



6. Easter egg nº 1 — Sherlock Holmes deveria ter trabalhado com legado

Uma grande parte da manutenção de sistemas antigos é investigação.

Você encontra:

       MOVE 17 TO WS-TIPO-CALCULO.

Por quê 17?

Ninguém sabe.

Você pesquisa o programa.

Depois o copybook.

Depois o JCL.

Depois uma tabela.

Depois encontra uma documentação de 1998.

E finalmente descobre:

Tipo 17 = cálculo especial utilizado durante fechamento de fevereiro.

Isso não é programação.

Isso é arqueologia industrial.

Bob pode ser um excelente Watson.

Mas ainda precisamos de Sherlock para perguntar:

“Por que fevereiro?”



7. PLAN — o momento mais importante ocorre antes da primeira alteração

Agora suponha que nossa missão seja mudar uma regra de juros.

Não diga:

Faça.

Peça:

Planeje a alteração necessária para modificar
a regra de juros do produto X.

Antes de qualquer implementação:

1. identifique os módulos afetados;
2. liste dependências;
3. identifique copybooks envolvidos;
4. localize testes existentes;
5. identifique possíveis impactos externos;
6. proponha uma estratégia;
7. liste riscos;
8. defina critérios de aceitação.

Bob pode retornar:

PLANO

1. Modificar CALCJURO.cbl
2. Alterar TAXAS.cpy
3. Revisar tabela DB2 TAXA_JUROS
4. Atualizar teste TC019
5. Executar regressão
6. Validar PAYR001 e PAYR020

O iniciante diz:

“Parece ótimo!”

O veterano grita do fundo do CPD:

“NÃO MEXE NO TAXAS.CPY!”

Por quê?

Porque o veterano sabe que aquele copybook é utilizado por 47 programas.

A IA talvez tenha identificado somente 13.

Ou talvez nem tenha acesso a todos os repositórios.

Esse momento é crucial.

Você responde:

Plano rejeitado parcialmente.

TAXAS.CPY é compartilhado por outros sistemas.

Não alterar o copybook.

Proponha uma solução local mantendo a interface atual.

Pronto.

A inteligência mais importante dessa interação talvez não tenha sido a inteligência artificial.

Foi o julgamento humano.



8. Eis o verdadeiro superpoder do profissional experiente

Muito se fala que IA diminuirá a importância da experiência.

Em sistemas empresariais antigos pode ocorrer justamente o contrário.

Porque um sistema legado é:

código
+
dados
+
procedimentos
+
infraestrutura
+
interfaces
+
regras empresariais
+
exceções
+
história
+
conhecimento tribal

IA pode ler muito código.

Mas talvez não saiba que:

“Esse job nunca deve rodar antes do fechamento da filial argentina.”

Talvez isso não esteja documentado.

Talvez esteja apenas na cabeça de alguém chamado Carlos.

Carlos trabalha ali desde 1994.

Todos chamam aquilo de:

REGRA DO CARLOS

Nenhum compilador conhece.

Nenhum modelo conhece.

Carlos conhece.

Esse tipo de contexto será extremamente valioso.



9. AGENT — agora Bob recebe a caixa de ferramentas

Depois que o plano foi investigado e aprovado, chegamos ao modo Agent.

Aqui as coisas ficam sérias.

Bob pode trabalhar com operações de leitura, edição, execução de comandos e ferramentas conectadas.

A relação passa de:

Humano pergunta
IA responde

para:

Humano define objetivo
      ↓
Agente investiga
      ↓
Agente modifica
      ↓
Agente executa
      ↓
Agente testa
      ↓
Humano revisa

Essa é uma mudança gigantesca.

Porque agora a IA não está apenas falando sobre o sistema.

Ela está fazendo coisas no sistema.



10. Programador, conheça uma palavra importante: autoridade

Considere dois agentes.

Agente A

Pode apenas ler arquivos.

Risco:

baixo

Agente B

Pode:

ler arquivos
editar arquivos
executar shell
chamar APIs
consultar serviços
abrir pull request
alterar configuração

Risco:

hmmmm...

Agora imagine:

Agente C

Pode:

acessar produção
alterar banco
ler secrets
fazer deploy
aprovar merge

O operador do mainframe desmaia.

É exatamente aqui que décadas de experiência em controle de acesso voltam a ficar modernas.


11. RACF encontra inteligência artificial

O mainframeiro olha para essa discussão e pergunta:

“Vocês descobriram autorização agora?”

🤣

No mundo z/OS aprendemos há décadas a perguntar:

QUEM É VOCÊ?
        ↓
O QUE VOCÊ PODE ACESSAR?
        ↓
PODE APENAS LER?
        ↓
PODE ALTERAR?
        ↓
PODE EXECUTAR?
        ↓
QUEM CONCEDEU?
        ↓
EXISTE LOG?

Agora substitua usuário por agente:

QUAL AGENTE?
        ↓
QUAIS FERRAMENTAS?
        ↓
QUAIS ARQUIVOS?
        ↓
QUAIS SERVIDORES MCP?
        ↓
PODE EXECUTAR COMANDOS?
        ↓
PODE ALTERAR REPOSITÓRIO?
        ↓
PODE PUBLICAR?
        ↓
QUEM APROVA?

O futuro da IA empresarial parece surpreendentemente parecido com uma conversa que um administrador RACF teria em 1995.

Easter egg:

Não dê SPECIAL para Bob.

Ele é gente boa.

Mas ninguém merece SPECIAL.


12. Least privilege — trate a IA como trataria qualquer outro ator do sistema

Uma arquitetura saudável poderia permitir:

Bob pode:

[X] ler código
[X] criar branch
[X] alterar branch de trabalho
[X] executar testes
[X] gerar documentação
[X] criar Pull Request

Bob não pode:

[ ] merge direto em main
[ ] acessar senha de produção
[ ] modificar tabela produtiva
[ ] fazer deployment produtivo
[ ] desligar JES2 porque "pareceu uma boa ideia"

Esse modelo é chamado de princípio do menor privilégio.

Não dê uma permissão porque o agente pode eventualmente precisar.

Dê somente aquilo que é necessário para a tarefa atual.


13. Human-in-the-loop — existe um humano entre a ideia e o estrago

Um fluxo simples:

IA propõe
    ↓
HUMANO REVISA
    ↓
IA EXECUTA
    ↓
HUMANO VALIDA

Esse é um modelo conhecido como:

Human in the Loop

O ser humano participa diretamente dos checkpoints.

Depois de ganhar maturidade, certas tarefas podem usar algo semelhante a:

Human on the Loop

O agente executa atividades dentro de limites predeterminados e o humano supervisiona.

Por exemplo:

Bob:
    criar teste             SIM
    rodar teste             SIM
    corrigir branch         SIM
    abrir PR                SIM
    merge em produção       NÃO

Não precisamos escolher entre:

humano faz tudo

e

robô faz tudo.

Existe uma enorme região intermediária.

É ali que provavelmente estará grande parte da engenharia empresarial dos próximos anos.


14. Subagents — quando Bob monta sua própria equipe

Agora nossa história fica ainda mais interessante.

Bob pode utilizar subagents, agentes independentes que executam tarefas focadas em janelas de contexto isoladas e devolvem um resumo ao agente principal. A documentação atual distingue inclusive subagentes explore, orientados à exploração somente-leitura, e general, capazes de usar ferramentas mais amplas. O usuário aprova a criação antes da execução.

Imagine:

                BOB
                 |
     +-----------+-----------+
     |           |           |
  AGENTE      AGENTE      AGENTE
   COBOL        DB2         TESTE
     |           |           |
 PAYR001       SQL       REGRESSÃO

O agente COBOL analisa dependências.

O agente Db2 investiga consultas.

O agente de testes verifica cobertura.

Todos retornam resumos.

Bob junta as peças.

Isso começa a parecer menos com:

“assistente de programação”

e mais com:

“equipe técnica virtual”.


15. Mas subagent não é Pokémon

Existe uma tentação:

Bob, crie 27 agentes.

Não.

Mais agentes não significam automaticamente resultado melhor.

Cada agente:

  • consome contexto;

  • executa ferramentas;

  • pode interpretar algo incorretamente;

  • aumenta custo;

  • aumenta coordenação.

O próprio Bob procura usar subagentes quando o trabalho é realmente autocontido e quando separar o contexto faz sentido, em vez de lançar agentes indiscriminadamente para qualquer leitura simples.

Regra Bellacosa:

Se uma tarefa exige dois minutos, não convoque os Vingadores.


16. MCP — Bob encontrou tomadas no CPD

Outra sigla importante:

MCP

Model Context Protocol.

De forma simplificada, MCP permite que um agente trabalhe com ferramentas e fontes externas através de uma interface padronizada.

Antes:

LLM
 |
 conversa

Depois:

              BOB
               |
              MCP
       +-------+-------+
       |       |       |
      Git     API    Sistema
       |       |       |
      Jira   Docs    Ferramentas

A documentação do Bob apresenta MCP justamente como mecanismo para estender o agente com ferramentas externas e integrações personalizadas.

Essa é uma mudança fundamental.

Porque um chatbot só poderia dizer:

“Você deveria abrir um ticket.”

Um agente conectado talvez possa:

abrir o ticket

A diferença entre conselho e ação é enorme.


17. Bob Shell — quando o polvo sai do editor

Em agosto de 2026, a IBM colocou o agente V2 também no Bob Shell, levando a arquitetura compartilhada do Bob para o terminal. A atualização também trouxe mudanças no Bobalytics, IDE e gerenciamento relacionado a MCP e revisão de edições.

Para um programador isso significa algo importante.

Antes:

IDE
 |
assistente

Agora podemos imaginar:

TERMINAL
   |
 Bob Shell
   |
   +-- build
   +-- test
   +-- git
   +-- scripts
   +-- ferramentas

E quem trabalha com mainframe sabe uma coisa:

quando algo chega ao terminal, começa a entrar no território da automação.


18. O futuro não é prompt engineering

Durante algum tempo todo mundo falava:

PROMPT ENGINEERING

Como se a habilidade definitiva fosse descobrir a frase mágica.

Algo parecido com:

“Escreva um programa extraordinário, pense passo a passo, seja genial e não erre.”

Não.

A evolução real parece mais próxima de:

PROMPT
   ↓
CONTEXTO
   ↓
PLANO
   ↓
DELEGAÇÃO
   ↓
EXECUÇÃO
   ↓
VALIDAÇÃO
   ↓
GOVERNANÇA
   ↓
OBSERVABILIDADE
   ↓
MÉTRICA

A habilidade passa de:

saber conversar com IA

para:

saber operar IA dentro de um processo de engenharia.


19. O portfólio do iniciante também precisa mudar

Imagine dois candidatos.

Candidato 1

GitHub:

CRUD de clientes
Clone do Netflix
Lista de tarefas
Calculadora

Tudo produzido parcialmente com IA.

Legal.

Agora candidato 2 cria:

cobol-modernization-lab/
 |
 +-- README.md
 +-- docs/
 |    +-- architecture.md
 |    +-- decisions.md
 |    +-- risks.md
 |
 +-- prompts/
 |    +-- analysis.md
 |    +-- plan.md
 |
 +-- src/
 |
 +-- tests/
 |
 +-- lessons-learned.md

No README:

Problema
↓
Análise inicial
↓
Plano sugerido pelo agente
↓
Plano revisado
↓
Decisões rejeitadas
↓
Implementação
↓
Testes
↓
Resultado

Quem você acha que dará mais assunto numa entrevista?


20. A melhor seção do README talvez seja: “onde Bob errou”

Sim.

Você leu corretamente.

Imagine:

## AI Recommendation Rejected

Bob sugeriu modificar COPY TAXAS.

A recomendação foi rejeitada porque o copybook
é compartilhado por múltiplas aplicações.

Decisão humana:

manter interface pública e implementar adaptação
local no programa CALCJURO.

Isso é maravilhoso.

Porque demonstra:

IA sugeriu
        ↓
VOCÊ ENTENDEU
        ↓
VOCÊ DISCORDOU
        ↓
VOCÊ EXPLICOU
        ↓
VOCÊ DECIDIU

A competência não está em aceitar a IA.

Está em saber quando não aceitar.


21. Uma entrevista técnica do futuro

Recrutador:

Você utiliza agentes de IA?

Candidato:

Sim.

Recrutador:

Conte uma decisão do agente que você rejeitou.

Silêncio.

O candidato que simplesmente gerava código morreu na praia.

Já outro responde:

O agente sugeriu alterar um contrato compartilhado. Analisei dependências, percebi risco de quebra em consumidores externos, rejeitei a solução e implementei um adapter preservando compatibilidade.

Pronto.

Temos uma conversa de engenharia.


22. O programador COBOL tem uma vantagem inesperada

COBOL ensina algo precioso:

software não existe isoladamente

Um programa está conectado a:

JCL
copybooks
VSAM
Db2
CICS
IMS
MQ
jobs
arquivos
procedimentos
controle
segurança
scheduler
processos empresariais

Por isso manutenção mainframe raramente permite a fantasia:

“Vou apenas reescrever esse módulo.”

Esse módulo talvez seja chamado às 03h17 por um job que ninguém mencionou.

Pode alimentar um arquivo que vai para outro banco.

Pode produzir uma saída utilizada por um sistema que pertence a outra diretoria.

Em sistemas corporativos:

dependência é a criatura que mora atrás da porta que ninguém abriu.


23. Passo a passo Bellacosa para usar um agente em COBOL

Vamos montar um procedimento.

Etapa 1 — Entender

Use Ask:

Explique este programa COBOL.

Mapeie:
- divisions;
- paragraphs;
- copybooks;
- CALLs;
- arquivos;
- SQL;
- CICS;
- códigos de retorno.

Não altere nada.

Etapa 2 — Mapear dependências

Pergunte:

Quais componentes externos podem ser afetados
por uma modificação neste módulo?

Não confie cegamente.

Confirme no repositório e nas ferramentas existentes.


Etapa 3 — Criar plano

Crie um plano para implementar a mudança X.

Inclua:
- arquivos afetados;
- risco;
- rollback;
- testes;
- dependências;
- critérios de sucesso.

Não implemente ainda.

Etapa 4 — Revisar manualmente

Leia tudo.

Pergunte:

Isso realmente faz sentido?

Se não entende algum item, não aprove.

Peça explicação.


Etapa 5 — Limitar escopo

Em vez de:

modernize o sistema

prefira:

altere somente o módulo CALCJURO
sem modificar interfaces públicas
nem copybooks compartilhados.

Etapa 6 — Executar

Agora sim:

Implemente o plano aprovado.

Etapa 7 — Testar

Nunca aceite:

“Parece correto.”

Use:

Compile.
Execute testes.
Analise return codes.
Compare resultados.

Em COBOL:

COMPILOU

não significa:

FUNCIONOU

e:

FUNCIONOU

não significa:

ESTÁ CORRETO

Etapa 8 — Revisar o diff

Pergunte:

O que mudou?
Por que mudou?
Quais comportamentos podem ser afetados?

Depois olhe você mesmo.


Etapa 9 — Documentar

Registre:

o que a IA sugeriu
o que foi aceito
o que foi rejeitado
por quê
quais testes foram realizados

Isso cria auditoria e aprendizado.


24. Nunca terceirize compreensão

Existe um anti-pattern perigoso:

não entendo
  ↓
pergunto IA
  ↓
IA responde
  ↓
continuo não entendendo
  ↓
mas executo mesmo assim

Isso é apenas terceirização da ignorância.

🤣

O fluxo correto:

não entendo
   ↓
IA explica
   ↓
pergunto novamente
   ↓
verifico
   ↓
entendo suficientemente
   ↓
decido

IA deveria diminuir sua ignorância.

Não escondê-la.


25. Curiosidade — COBOL já viveu uma revolução parecida

Nos anos 1950, programar significava trabalhar muito mais perto da máquina.

Linguagens de alto nível eram uma abstração revolucionária.

Algum programador Assembly poderia olhar COBOL e dizer:

“Agora qualquer incompetente escreve programa!”

Talvez dissesse:

“Esses jovens nem sabem registrador!”

Décadas depois acontece algo curioso.

Programadores modernos dizem:

“Com IA qualquer pessoa gera programa!”

A história gosta de rir.

Compiladores automatizaram a transformação:

linguagem humana-ish
        ↓
código de máquina

IA automatiza outra camada:

intenção humana
        ↓
representação técnica

Mas abstração nunca eliminou necessidade de engenharia.

Ela apenas permitiu construir sistemas maiores.


26. Quanto maior a abstração, maior o raio da explosão

Em Assembly, você poderia errar uma instrução.

Com COBOL, uma regra errada poderia afetar milhões de registros.

Com um pipeline automatizado, uma alteração pode chegar a centenas de servidores.

Com agentes:

UM OBJETIVO MAL DEFINIDO
          ↓
MÚLTIPLAS ALTERAÇÕES
          ↓
TESTES
          ↓
AUTOMAÇÃO
          ↓
PR

Velocidade amplifica coisas boas.

E coisas ruins.

Por isso:

AUTONOMIA ↑
=
GUARDRAILS ↑

27. Guardrail é a cerca elétrica em volta do robô

Guardrail é qualquer mecanismo que limita comportamento.

Exemplos:

não editar produção
não acessar determinados diretórios
não executar determinados comandos
não enviar dados sensíveis
não modificar secrets
não publicar automaticamente
exigir aprovação

Pense em uma locomotiva.

Ela é extremamente poderosa.

Mas só é útil porque existe trilho.

Um agente sem trilho não é uma locomotiva.

É um trem atravessando o estacionamento.


28. E finalmente chegamos às métricas

Depois que uma empresa compra IA para centenas de desenvolvedores, aparece o gerente financeiro.

Ele não pergunta:

“Bob é legal?”

Ele pergunta:

“Quanto custou?”

Depois:

“Quanto economizou?”

Depois:

“Como você sabe?”

E aqui começa a parte adulta.

Não basta medir:

linhas de código

Linhas de código são uma métrica terrível.

Você pode produzir 200 mil linhas de lixo.

Melhores indicadores incluem:

Lead Time
Cycle Time
Defect Rate
Change Failure Rate
MTTR
Test Coverage
Rework
Deployment Frequency
Tempo economizado
Custo por mudança

As versões atuais do ecossistema Bob incluem Bobalytics justamente como uma camada de visibilidade sobre uso e atividade; a atualização de agosto de 2026 adicionou novas visões para observar atividade diária e padrões de utilização.


29. Bobalytics encontra SMF no boteco

O mainframeiro vê analytics e novamente começa a rir.

Porque estamos acostumados com a pergunta:

“O que aconteceu?”

E alguém responde:

“Vamos olhar os registros.”

SMF.

RMF.

Logs.

Auditoria.

Accounting.

Histórico.

Agora o mesmo princípio chega à IA:

Quem utilizou?
Quanto utilizou?
Para quê?
Qual resultado?
Quanto custou?
Qual foi a produtividade?

No futuro talvez ninguém aceite:

“A IA ajudou bastante.”

Precisaremos dizer:

antes: 12 horas
depois: 5 horas

antes: 8 defeitos
depois: 3 defeitos

custo de IA: X
tempo preservado: Y

Aí temos ROI.


30. Cuidado com a “produtividade placebo”

Existe um fenômeno interessante.

Desenvolvedor:

“Estou produzindo 70% mais rápido!”

Pergunta:

“Como você mediu?”

Resposta:

“Senti.”

🤣

Isso não é métrica.

É horóscopo corporativo.

Talvez a IA realmente tenha melhorado produtividade.

Mas precisamos separar:

sensação de velocidade

de:

resultado empresarial

31. O futuro do profissional técnico

A escada provavelmente será algo semelhante a:

NÍVEL 1
"uso autocomplete"

NÍVEL 2
"gero código"

NÍVEL 3
"forneço contexto"

NÍVEL 4
"planejo com agente"

NÍVEL 5
"delego tarefas"

NÍVEL 6
"coordeno subagents"

NÍVEL 7
"conecto ferramentas"

NÍVEL 8
"governo permissões"

NÍVEL 9
"meço resultado"

NÍVEL 10
"assumo responsabilidade"

O último é o mais importante.

Porque quando alguma coisa der errado ninguém aceitará:

“Mas Bob fez.”

A pergunta será:

“Quem aprovou?”


32. O easter egg escondido no SYSOUT

Depois de terminar a alteração, nosso programador encontra no relatório:

IEF142I JOB PAYROLL STEP01 - STEP WAS EXECUTED

Tudo parece normal.

Mais abaixo aparece:

BOB0001I ARTIFICIAL INTELLIGENCE COMPLETED TASK
BOB0002I HUMAN REVIEW REQUIRED

E finalmente:

BOB9999I CAFE REQUIRED BEFORE PRODUCTION

Esse último ainda não existe.

Mas deveria.


33. O iniciante não deve abandonar fundamentos por causa da IA

Se você está começando em COBOL, ainda precisa aprender:

IDENTIFICATION DIVISION
DATA DIVISION
PROCEDURE DIVISION

PIC
MOVE
IF
EVALUATE
PERFORM
CALL
FILE STATUS
COMP
COMP-3
COPYBOOKS
JCL
VSAM
DB2
CICS

Por quê?

Porque se Bob gerar:

       MOVE WS-AMOUNT TO WS-BALANCE

você precisa entender o que aconteceu.

Se ele sugerir redefinir:

       05 WS-AMOUNT PIC S9(9)V99 COMP-3.

você precisa saber por que isso pode importar.

A IA não elimina fundamentos.

Ela aumenta a penalidade de não conhecê-los.


34. A regra do mestre Jedi do mainframe

Use IA para chegar mais rápido à pergunta difícil.

Não para fugir dela.

Se você gastava três horas procurando onde determinada regra estava implementada e Bob encontra em três minutos:

fantástico.

Use as duas horas e cinquenta e sete minutos economizadas para descobrir:

“Essa regra ainda deveria existir?”

Isso é valor.


35. Programação está mudando de escrever para dirigir

Podemos representar a mudança assim:

ONTEM

Humano
  ↓
Código
  ↓
Computador

Hoje:

Humano
  ↓
IA
  ↓
Código
  ↓
Computador

Amanhã:

              HUMANO
                 |
        arquitetura / intenção
                 |
                 ↓
              AGENTE
        +--------+--------+
        |        |        |
     subagent subagent subagent
        |        |        |
      código   testes   análise
        \        |        /
             ferramentas
                 |
              sistemas

O humano sobe um nível.

Mas não desaparece.


36. Talvez “programador” volte ao significado original

Existe uma ironia bonita aqui.

Programar significa essencialmente:

estabelecer uma sequência de ações para atingir um objetivo.

Durante décadas transformamos “programador” em:

pessoa que digita código.

Agentes podem fazer com que o programador volte a ser mais literalmente alguém que:

define objetivos
decompõe tarefas
estabelece restrições
coordena execução
verifica resultado

Ou seja:

talvez IA não esteja destruindo o conceito de programador.

Talvez esteja obrigando a palavra a recuperar seu significado.


37. Checklist Bellacosa antes de deixar Bob trabalhar

Antes:

[ ] Entendo o problema?
[ ] Sei qual é o resultado esperado?
[ ] Identifiquei o escopo?
[ ] Mapeei dependências?
[ ] Pedi um plano?
[ ] Revisei o plano?
[ ] Defini o que NÃO pode ser alterado?

Durante:

[ ] Estou acompanhando as alterações?
[ ] O agente está dentro do escopo?
[ ] Surgiu nova dependência?
[ ] Existem decisões que exigem humano?

Depois:

[ ] Compilou?
[ ] Testou?
[ ] Comparei comportamento?
[ ] Revisei diff?
[ ] Avaliei segurança?
[ ] Documentei decisões?
[ ] Existe rollback?

Se a resposta para metade for:

¯\_(ツ)_/¯

não vá para produção.


38. Epílogo — Bob pergunta se pode fazer deploy

Voltamos ao nosso CPD.

23h58.

PAYR001 foi analisado.

O plano foi criado.

Uma alteração perigosa em TAXAS.CPY foi rejeitada.

Bob modificou o módulo correto.

Os testes passaram.

O programador revisou o diff.

Bob então pergunta:

“Deseja fazer deployment?”

O programador olha para o relógio.

Olha para Bob.

Olha para o calendário.

É sexta-feira.

Ele responde:

NÃO.

Bob pergunta:

“Por quê?”

E o jovem programador finalmente demonstra que aprendeu a mais importante regra da computação corporativa:

“Porque eu posso ser iniciante, Bob, mas não sou maluco.”

☕

Na segunda-feira faremos a mudança.

Com aprovação.

Com backup.

Com rollback.

Com logs.

E com alguém responsável olhando.

Porque o futuro da programação não será decidido por quem consegue produzir mais código.

Será decidido por quem consegue comandar máquinas cada vez mais capazes sem entregar a elas aquilo que nunca deveria ter sido terceirizado: julgamento, responsabilidade e compreensão do negócio.

IBM Bob pode ser copiloto.

Pode ser investigador.

Pode ser planejador.

Pode ser executor.

Pode convocar subagentes.

Pode usar ferramentas.

Pode trabalhar pelo terminal.

Pode atravessar o MCP e conversar com outros sistemas.

Mas alguém ainda precisa ocupar a cadeira do comandante.

E se você está começando agora em COBOL, existe uma oportunidade extraordinária diante de você:

não aprenda apenas a escrever programas.

Aprenda a entender sistemas.

Aprenda por que aquele MOVE existe.

Aprenda quem chama aquele programa.

Aprenda o que acontece quando o job termina com RC=08.

Aprenda por que segurança existe.

Aprenda por que produção exige respeito.

Aprenda a perguntar.

Aprenda a planejar.

Aprenda a discordar da inteligência artificial.

Porque talvez a habilidade técnica mais valiosa da próxima década não seja saber dizer para um agente:

“Faça.”

Será saber olhar para o plano produzido por ele, apoiar a caneca de café sobre a mesa e responder:

“Não, Bob. Essa parte você não vai mexer.”

E explicar exatamente por quê.

☕ Bem-vindo ao Bellacosa Mainframe.

Artigo DIO - Bellacosa Mainframe

☕ E se amanhã um agente de IA pedir acesso ao seu código COBOL?

Leia o artigo completo publicado na DIO sobre IBM Bob, inteligência artificial, COBOL, mainframe e o futuro da engenharia de software.

☕ Carregando o artigo...
Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...