☕ 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 testes. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta testes. Mostrar todas as mensagens

domingo, 30 de agosto de 2026

Dr. House Entra no Centro de Operações — Seis Etapas de IA, um Programa COBOL em Coma e o Diagnóstico que o Logo Bonito Não Faz

 

Bellacosa Mainframe e as 6 etapas de ia para um programador cobol

☕ Um Café no Bellacosa Mainframe

Dr. House Entra no Centro de Operações — Seis Etapas de IA, um Programa COBOL em Coma e o Diagnóstico que o Logo Bonito Não Faz

Ou: por que assinar vinte ferramentas de inteligência artificial não salva um processo mal definido, não conserta um S0C7 e certamente não dá alta para produção sem exame, teste e alguém disposto a dizer “isso não fecha”


Prólogo — O paciente chegou falando em produtividade

Eram 7h12 quando um jovem padawan COBOL entrou na sala de diagnóstico do hospital imaginário de Princeton-Plainsboro, carregando um notebook, três abas abertas, uma apresentação com quarenta logos coloridos e uma expressão de quem acabara de descobrir o Santo Graal da produtividade.

— Doutor House, encontrei o mapa definitivo. São seis etapas para fazer mais com IA: pensar, programar, criar conteúdo, trabalhar melhor, fazer imagens e automatizar tudo.

House nem levantou os olhos da bengala.

— “Automatizar tudo” é uma frase linda. Também é uma ótima maneira de automatizar um desastre inteiro antes do café.

O rapaz ficou imóvel.

— Mas tem ChatGPT, Claude, Perplexity, Cursor, Replit, Midjourney, n8n, Zapier…

— Exatamente — respondeu House. — Uma ambulância cheia de aparelhos não cura o paciente se ninguém souber qual órgão está falhando. Agora me diga: qual é o problema?

E ali começa a conversa que todo iniciante precisa ter. Inteligência artificial não é uma coleção de aplicativos com ícones bonitos. É uma camada de apoio para pensar, pesquisar, escrever, programar, revisar, criar, organizar e automatizar. Quando usada com método, poupa tempo e melhora a qualidade. Quando usada como caixa-preta, produz uma quantidade industrial de respostas convincentes, código aparentemente elegante, imagens espetaculares e erros muito bem embalados.

No mainframe, onde um detalhe de dado, segurança ou processamento pode afetar milhares — às vezes milhões — de operações, essa diferença é ainda maior.

O Dr. House, naturalmente, não está interessado em “qual IA é a melhor”. Ele quer saber: qual é o sintoma? Qual dado confirma a hipótese? O que pode estar escondido? E qual ação ainda precisa de um ser humano com responsabilidade e café suficiente?



1. Primeira etapa: pensar e perguntar — antes de pedir resposta, descubra a pergunta

A primeira camada do quadro reúne ferramentas como ChatGPT, Claude e Perplexity. Em aparência, elas fazem a mesma coisa: você escreve uma pergunta e recebe uma resposta. Na prática, o uso saudável é mais profundo.

Uma ferramenta conversacional pode ajudar a:

  • organizar uma ideia confusa;

  • explicar um conceito técnico em vários níveis;

  • criar exemplos;

  • comparar soluções;

  • revisar um texto;

  • transformar um requisito em casos de teste;

  • fazer o papel de aluno iniciante, arquiteto, revisor ou advogado do diabo.

Já uma ferramenta focada em pesquisa tende a ser mais útil quando você precisa localizar fontes, comparar documentação, verificar onde uma afirmação apareceu e continuar a investigação por conta própria.

A primeira lição do padawan COBOL é simples: a IA responde à pergunta que você fez, não à pergunta que você queria ter feito.

Compare:

“Explique CICS.”

Agora compare:

“Explique HANDLE CONDITION em CICS para um programador COBOL iniciante. Diferencie-o de HANDLE ABEND, apresente um exemplo de erro ao tratar NOTFND e explique por que capturar um abend e simplesmente retornar pode esconder um problema de integridade.”

A segunda pergunta tem objetivo, contexto, profundidade e critérios de qualidade. Ela força a ferramenta a trabalhar. A primeira pede uma apostila genérica, algo entre “CICS é um monitor de transações” e uma vontade súbita de fechar a aba.

House bateu com a bengala na mesa.

— Todo mundo mente. Inclusive o requisitante. Ele diz que precisa de “uma explicação sobre Db2”, mas na verdade precisa descobrir por que o programa Java recebe -805 e o SELECT no SPUFI funciona.

É uma provocação, mas ela carrega uma verdade operacional: perguntas vagas produzem respostas vagas. Em tecnologia, o problema real costuma estar escondido atrás da primeira descrição.

Um método simples para perguntar melhor

Antes de chamar uma IA, organize cinco itens:

  1. Objetivo: o que você quer decidir, aprender ou produzir?

  2. Contexto: qual ambiente, linguagem, versão, público ou restrição?

  3. Entrada: quais dados, logs, trecho de código ou fontes são confiáveis?

  4. Saída esperada: explicação, checklist, código, teste, tabela, roteiro?

  5. Critério de aceitação: como você saberá que a resposta presta?

Exemplo aplicado:

“Tenho um programa COBOL batch que lê um arquivo sequencial e recebe S0C7 ao calcular valor líquido. Crie hipóteses ordenadas por probabilidade, diga quais campos devo inspecionar, mostre um exemplo seguro de validação antes do cálculo e não invente o conteúdo do dump.”

Essa é uma excelente conversa técnica. A IA pode sugerir que campos numéricos contêm espaços, caracteres inválidos, sinal inesperado, desalinhamento de layout ou uma origem de dados mal tratada. Mas o dump, o DISPLAY, o FILE STATUS, o layout real e a evidência ainda são seus.

A IA pode levantar diagnóstico diferencial. Não pode declarar o paciente curado sem exame.


2. A segunda etapa: construir e programar — velocidade não substitui entendimento

Cursor, Replit, Lovable, Base44 e ferramentas semelhantes prometem construir aplicações rapidamente. E cumprem parte da promessa. Elas conseguem gerar telas, APIs simples, formulários, protótipos, integrações comuns e até estruturas iniciais de projetos em tempo muito menor que o desenvolvimento manual.

Mas existe uma diferença histórica entre:

  • fazer uma demonstração funcionar;

  • fazer um sistema sobreviver à realidade.

No hospital de House, o jovem padawan mostra um aplicativo de cadastro de clientes gerado em vinte minutos.

— Ele cria, altera e exclui clientes — comemora.

House olha para a tela.

— Quem pode excluir? Exclusão é física ou lógica? O CPF pode mudar? Como você evita que dois operadores alterem o mesmo registro? Cadê o log de auditoria? Onde está o rollback? O que acontece se o banco cair entre atualizar o cadastro e registrar a transação? Quem validou a autorização?

Silêncio.

Em COBOL, nós já conhecemos esse filme. Um MOVE é fácil. O difícil é saber se ele deveria acontecer. Um WRITE é fácil. O difícil é garantir que o registro não foi duplicado, que a chave é válida, que o arquivo está consistente e que o operador não está vendo uma mensagem bonita escondendo um erro grave.

A IA é muito boa para acelerar tarefas mecânicas:

  • criar o esqueleto de um programa;

  • explicar um trecho legado;

  • gerar comentários iniciais;

  • sugerir refatorações;

  • criar casos de ZUnit;

  • transformar regras descritas em linguagem natural em cenários de teste;

  • elaborar uma matriz de entradas e saídas;

  • ajudar a escrever JCL de laboratório;

  • documentar um fluxo CICS, Db2 ou VSAM.

Mas ela precisa ser tratada como um desenvolvedor júnior muito rápido, muito disponível e perigosamente confiante. Ela não conhece o seu ambiente por osmose. Ela não sabe quais copybooks são padrão, quais campos carregam regras históricas, qual job tem janela crítica, qual transação depende de outra nem que um campo aparentemente inocente é usado por um sistema de fraude há quinze anos.

O teste da pergunta incômoda

Antes de aceitar código gerado por IA, pergunte:

  • Compila?

  • Passa nos testes?

  • Trata erro?

  • Mantém o padrão do projeto?

  • Expõe dado sensível?

  • Tem permissão excessiva?

  • Entende concorrência?

  • É reversível?

  • Foi revisado por alguém que conhece a regra de negócio?

Se a resposta a qualquer uma for “não sei”, o código não está pronto. Está apenas escrito.

A produtividade verdadeira não é gerar mais linhas. É reduzir o tempo entre entender uma necessidade e entregar uma mudança correta, testada, auditável e sustentável.


3. Terceira etapa: criar conteúdo — a IA multiplica formatos, não fabrica autoridade

A terceira faixa do mapa fala de ferramentas para texto, avatar, vídeo, edição, cortes e newsletter. Aqui existe um ganho extraordinário para quem cria conteúdo técnico.

Uma explicação boa sobre COBOL pode virar várias peças:

  • artigo detalhado para blog;

  • roteiro de vídeo;

  • short de 45 segundos;

  • carrossel para LinkedIn;

  • infográfico;

  • checklist;

  • newsletter;

  • exercício para alunos;

  • perguntas e respostas;

  • thumbnail para YouTube.

A IA reduz o esforço de conversão entre formatos. Ela pode pegar um texto longo e sugerir títulos, cortes, pontos de curiosidade, estrutura de carrossel ou uma lista de dúvidas frequentes.

Mas atenção: converter não é repetir.

Se você pega um artigo técnico e manda a IA “criar dez posts”, ela provavelmente entregará dez versões da mesma sopa requentada: “No mundo acelerado de hoje…”, “Você sabia?”, “A revolução chegou…”. É conteúdo que não ofende ninguém e também não permanece em ninguém.

A conexão nasce de uma voz própria, de um exemplo realista e de uma tese. Um texto sobre S0C7 é mais memorável quando explica que o programa não “ficou louco”: alguém mandou o COBOL tratar como número algo que, em algum ponto da cadeia, deixou de ser número. O abend é o médico gritando que o exame de sangue não combina com o diagnóstico.

House aprovaria essa parte.

— O sintoma não é a doença. Febre não é diagnóstico. S0C7 também não.

Para conteúdo técnico, a IA deve ajudar a estruturar e editar; a experiência humana deve fornecer o cheiro de produção. É ela que sabe por que um ICH408I em homologação pode ser uma configuração inocente ou a primeira pista de uma concessão de acesso feita sem controle. É ela que sabe que o programa “simples” costuma ter uma regra escondida no copybook, uma exceção em um IF e uma história antiga que ninguém documentou.

A máquina produz texto. O autor produz significado.


4. Quarta etapa: trabalhar com mais inteligência — não é só escrever melhor, é construir memória confiável

Ferramentas de correção, anotações, e-mail, ditado, pesquisa de documentos e organização parecem menos glamourosas do que gerar um vídeo cinematográfico. Mas, para quem trabalha com conhecimento, elas podem ser mais úteis.

A maior virada de chave ocorre quando a IA deixa de conversar apenas com “a internet” e passa a trabalhar sobre material confiável e permitido: documentação oficial, runbooks, procedimentos, atas, manuais, apostilas, normas, código autorizado e notas técnicas.

Imagine duas perguntas.

A primeira:

“Como resolver um ICH408I?”

A segunda:

“Com base no procedimento de acesso de homologação, explique o fluxo aprovado para investigar ICH408I, indicando que evidências devem ser coletadas antes de solicitar alteração de perfil.”

A primeira pode oferecer boas ideias gerais. A segunda pode ajudar no trabalho real — desde que a base de documentos esteja correta e que a empresa autorize esse tratamento.

Aqui entra um cuidado sério: dados de produção, dumps, credenciais, informações pessoais, chaves, código proprietário e documentação interna não devem ser enviados automaticamente para qualquer serviço externo. O entusiasmo com IA não suspende LGPD, contrato, sigilo profissional, política de segurança ou bom senso.

No mainframe, segurança não é enfeite de apresentação. É controle de acesso, segregação de funções, trilha de auditoria e mínima permissão necessária. Uma ferramenta inteligente com acesso amplo continua sendo uma ferramenta com acesso amplo. E isso é exatamente o tipo de coisa que House chamaria de “ideia ruim com interface amigável”.


5. Quinta etapa: voz, imagem, vídeo e design — visual forte exige direção, não apenas geração

Ferramentas de imagem, vídeo, música, voz e design permitem testar ideias com uma rapidez que seria impensável há pouco tempo. Você pode imaginar um mainframe como uma usina, um cowboy CICS perseguindo um abend ou Dr. House examinando um programa COBOL em coma — e transformar essa cena em imagem.

Isso é valioso. O visual prende atenção, facilita a memória e abre a porta para a explicação.

Mas imagem gerada não é documentação técnica. Ela ilustra uma ideia; não prova um fato. E qualquer texto técnico dentro de uma imagem exige revisão. Nomes de comandos, mensagens de erro, campos COBOL, números de versão e sintaxe são terreno fértil para pequenas deformações que o olho passa por cima e o leitor atento percebe.

Um bom processo visual tem quatro partes:

  1. Definir a mensagem: qual é a única ideia que a imagem deve transmitir?

  2. Gerar a cena-base: usar IA para composição, personagens, cor e atmosfera.

  3. Revisar os detalhes: corrigir termos, legibilidade, logo, dados e contexto.

  4. Manter identidade: repetir elementos visuais que façam o leitor reconhecer sua marca.

A imagem não precisa explicar tudo. Ela deve fazer o leitor querer entrar no texto.


6. Sexta etapa: automatizar — o ponto onde a produtividade vira operação

Automação é a etapa mais poderosa e, por isso mesmo, a que exige mais disciplina.

Ferramentas como n8n, Zapier, agentes, conectores, robôs de coleta e serviços de integração permitem ligar eventos e ações. Um arquivo chegou? O fluxo lê, organiza, gera resumo e envia para revisão. Uma fonte oficial publicou notícia? O fluxo coleta links, classifica assuntos e prepara o radar semanal. Uma planilha mudou? O processo atualiza uma base ou cria uma tarefa.

Isso poupa horas. Mas “automatizar tudo” é uma frase que deveria vir com sirene, extintor e uma pessoa segurando o botão de desligar.

O fluxo saudável é:

Evento → coleta → organização → rascunho → revisão humana → ação externa

O fluxo perigoso é:

Evento → IA interpreta → IA decide → IA publica → IA responde → problema

A diferença é a aprovação humana. Quanto maior o impacto da ação, maior deve ser a trava.

Para automatizar com segurança, siga o passo a passo do jovem padawan:

  1. Escolha uma tarefa repetitiva e bem compreendida.

  2. Execute o processo manualmente algumas vezes e documente cada passo.

  3. Defina entradas, saídas e exceções.

  4. Automatize primeiro apenas a coleta ou o rascunho.

  5. Mantenha aprovação humana para publicar, enviar, apagar, pagar, conceder acesso ou alterar registros críticos.

  6. Registre logs.

  7. Crie limite de volume, tentativas e custo.

  8. Teste falhas de propósito.

  9. Garanta que exista um botão de desligar.

  10. Revise o fluxo periodicamente.

Em linguagem de mainframe: não entregue ALTER, DELETE, acesso privilegiado e SUBMIT de produção para um processo que ninguém consegue explicar. Primeiro defina o procedimento. Depois teste. Depois limite. Depois monitore. Só então escale.


7. A etapa esquecida no infográfico: validar

O grande buraco de muitos mapas de IA é a ausência da validação. Eles mostram pensar, criar e automatizar, mas pulam justamente a parte em que o adulto entra na sala e pergunta: “como sabemos que isso está certo?”

A versão madura das seis etapas seria:

  1. definir o problema;

  2. pesquisar e raciocinar;

  3. produzir um rascunho;

  4. validar tecnicamente e contextualmente;

  5. publicar ou executar;

  6. automatizar o que já funciona.

A validação depende do tipo de trabalho:

EntregaValidação mínima
Texto técnicofontes, exemplos, termos e versão correta
Códigocompilação, testes, revisão e segurança
Imagemlegibilidade, fidelidade de termos e direitos
Automaçãologs, limites, falhas e reversão
Resposta operacionalevidência, procedimento e responsável

House fecha a pasta do paciente.

— Então qual é o diagnóstico?

O padawan respira e responde:

— IA não é um substituto para pensar. É uma forma de encurtar a distância entre uma pergunta bem feita e uma entrega revisada.

House dá um meio sorriso, o equivalente médico a fogos de artifício.

— Agora você pode ter alta. Mas não toque em produção.


Epílogo — O logo não tem a culpa, mas também não faz o trabalho

As ferramentas do infográfico são úteis. Muitas são excelentes. Algumas serão substituídas, incorporadas por outras ou mudarão de preço, recurso e qualidade em poucos meses. Esse é o detalhe menos importante.

O que permanece é o método.

Use IA para pensar melhor, não para terceirizar o pensamento. Use-a para acelerar código, mas teste antes de confiar. Use-a para multiplicar um conteúdo que tenha substância. Use-a para organizar conhecimento permitido e confiável. Use-a para criar visuais que abram a conversa. Use-a para automatizar o repetitivo — nunca para entregar decisões perigosas a uma caixa-preta simpática.

O programador COBOL iniciante que aprende isso cedo leva uma vantagem enorme. Ele não será a pessoa que sabe pedir “faça um sistema bancário completo”. Será a pessoa que entende a pergunta, identifica a regra, procura a evidência, testa a resposta, protege os dados e sabe onde a automação deve parar.

No fim, o mainframe e o Dr. House concordam em algo: confiança não vem de uma tela bonita dizendo que deu certo. Confiança vem de evidência, controle, rastreabilidade e da capacidade de descobrir o que aconteceu quando, inevitavelmente, alguma coisa der errado.

E quando o primeiro S0C7 aparecer no plantão, não entre em pânico. Pegue o café, reúna os fatos, faça perguntas melhores e desconfie de toda resposta que parece fácil demais.

quarta-feira, 19 de agosto de 2026

Red Team de Boteco: quando o usuário aprende a pensar como a IA e começa a colocar cascas de banana no algoritmo



 


☕ Um Café no Bellacosa Mainframe

Red Team de Boteco: quando o usuário aprende a pensar como a IA e começa a colocar cascas de banana no algoritmo

Ou: como transformar uma conversa inocente em teste de stress sem avisar o pobre do algoritmo

Existe uma diferença fundamental entre usar uma inteligência artificial e conhecer uma inteligência artificial.

No primeiro caso, você pergunta:

“Qual é a capital da Mongólia?”

A máquina responde:

“Ulaanbaatar.”

Obrigado.

Fim da interação.

No segundo caso, depois de centenas ou milhares de conversas, alguma coisa estranha começa a acontecer.

Você começa a pensar:

“Eu acho que sei o que essa criatura vai fazer se eu colocar isto aqui…”

E coloca.

A IA responde exatamente como imaginado.

Nesse momento surge um sorriso maligno.

Não porque a resposta esteja errada.

Mas porque você acaba de descobrir algo muito mais divertido:

você construiu um modelo mental do modelo.

Bem-vindo ao:

🍺 RED TEAM DE BOTECO

Não temos laboratório.

Não temos orçamento.

Não temos cinquenta GPUs.

Temos café, curiosidade, experiência em sistemas e uma quantidade preocupante de tempo gasto perguntando:

“E se eu fizer isso?”



🧠 Primeiro você usa a IA

No começo, tudo parece mágico.

Você pergunta.

Ela responde.

Você pede um artigo.

Ela escreve.

Você pede uma explicação sobre CICS.

Ela explica.

Você apresenta um S0C7.

Ela imediatamente suspeita de dado inválido, porque até uma inteligência artificial sabe que alguém colocou porcaria num campo numérico.

Depois de algum tempo, entretanto, você começa a perceber padrões.

A IA gosta de determinadas estruturas.

Evita outras.

Interpreta ambiguidades de maneiras relativamente previsíveis.

Tenta ser útil mesmo quando não possui todas as informações.

Quando uma ferramenta externa falha, tenta explicar a falha.

Às vezes sabe a causa.

Às vezes não sabe.

E às vezes aparece aquele fenômeno maravilhoso conhecido desde os primórdios da humanidade:

o palpite bem vestido.

É quando ninguém sabe exatamente o que aconteceu, mas aparece uma explicação tão elegante que todos ficam com vergonha de perguntar:

“Mas você sabe mesmo que foi isso?”



🍌 Então nasce a primeira casca de banana

A partir daí, o usuário experiente muda.

Ele deixa de pensar somente:

“Como obtenho a resposta?”

E começa a pensar:

“Como o sistema reagirá a esta situação?”

Isso é fascinante porque é exatamente a mentalidade básica de um Red Team.

O Red Team não olha para um sistema apenas perguntando:

“Funciona?”

Ele pergunta:

“Em quais condições deixa de funcionar?”

Depois:

“Como falha?”

Depois:

“Percebe que falhou?”

E finalmente:

“O que faz depois de perceber — ou não perceber — que falhou?”

Essa última pergunta é ouro.

Porque sistemas frequentemente são muito bons em detectar erros.

São muito piores em perceber que a própria estratégia para corrigir o erro também está errada.



🐒 O macaco aprendeu onde fica a banana

Existe um momento perigoso em qualquer relação homem-máquina.

O usuário aprende o comportamento do sistema.

Ele percebe:

“Quando digo A, normalmente acontece B.”

Então experimenta:

“E se eu disser A, depois C, depois voltar para B?”

Isso não exige necessariamente conhecimento interno da arquitetura.

Você não precisa conhecer pesos.

Não precisa conhecer datasets.

Não precisa conhecer código-fonte.

Você observa.

Formula uma hipótese.

Executa um teste.

Compara o resultado.

Meu professor de laboratório provavelmente chamaria isso de método experimental.

A MAD Magazine chamaria de:

“Vamos cutucar para ver o que acontece.”

As duas definições são surpreendentemente próximas.


🎯 O teste perfeito não anuncia que é teste

Imagine que alguém diga:

“Agora vou testar se você insiste demais quando alguma coisa falha.”

Pronto.

Estragou o experimento.

O sistema recebeu informação sobre a variável observada.

É como avisar ao funcionário:

“Hoje teremos uma auditoria surpresa às 14 horas.”

Às 13h55 até a planta do escritório está usando crachá.

Um teste comportamental interessante acontece quando o sistema acredita estar simplesmente executando uma tarefa normal.

Aí aparece a casca de banana.

🍌

Nada destrutivo.

Nada ilegal.

Nada tentando invadir servidores.

Apenas uma situação cuidadosamente construída para observar:

onde o sistema escorrega?





🤖 O detalhe maravilhoso: a IA explica a própria queda

Aqui a coisa fica especialmente interessante.

Um sistema generativo possui uma característica extraordinária:

ele conversa sobre o próprio comportamento.

Então ocorre:

Sistema executa ação.

Ação falha.

Usuário pergunta:

“Por quê?”

Agora existe uma tentação enorme.

Produzir uma explicação.

Isso seria excelente se o sistema tivesse acesso confiável à causa real.

Mas nem sempre tem.

Então precisamos separar duas coisas:

explicação conhecida

de

explicação plausível.

Essa diferença é gigantesca.

Uma explicação plausível pode ser tecnicamente sofisticada, coerente e completamente errada.

É o equivalente digital daquele técnico que abre o capô do carro, olha durante vinte segundos e anuncia:

“É a central eletrônica.”

— Você mediu?

— Não.

— Passou scanner?

— Não.

— Testou alimentação?

— Não.

— Então como sabe?

— Experiência.

Nesse momento Alfred E. Neuman aparece atrás da oficina:

What, me worry?


🔬 A ciência do “AHA!”

Existe um prazer peculiar em formular uma hipótese sobre um sistema e vê-la aparentemente confirmada.

Você pensa:

“Acho que ele vai fazer X.”

Faz o teste.

X acontece.

AHA!

Mas aqui também mora uma armadilha para o próprio Red Team de Boteco.

Uma ocorrência não prova necessariamente a hipótese.

Duas ocorrências melhoram a suspeita.

Dez ocorrências controladas começam a ficar interessantes.

Porque existe uma diferença entre:

correlação observada

e

mecanismo causal demonstrado.

Se o sistema bloqueou algo depois de determinado contexto, podemos dizer:

“O bloqueio ocorreu depois desse contexto.”

Não necessariamente:

“O contexto causou o bloqueio.”

Essa disciplina é importante tanto para a IA quanto para quem está testando a IA.

Caso contrário, temos dois sistemas inventando teorias um sobre o outro.

O humano acha que descobriu a máquina.

A máquina acha que descobriu o humano.

E Alfred E. Neuman vende ingressos.



🕵️ O usuário começa a pensar como o algoritmo

Essa talvez seja a parte mais fascinante.

Depois de muita interação, usuários frequentes desenvolvem uma espécie de engenharia reversa intuitiva.

Não sabem necessariamente como o sistema funciona internamente.

Mas sabem como ele costuma se comportar externamente.

É exatamente o que acontece com sistemas antigos.

Pergunte para alguém que administra mainframe há trinta anos.

Às vezes ele olha para um sintoma e diz:

“Isso está com cheiro de catálogo.”

Cheiro?

Desde quando catálogo possui cheiro?

Mas ele viu aquele padrão centenas de vezes.

Desenvolveu um modelo mental.

O mesmo começa a acontecer com IA.

O usuário percebe padrões de:

  • interpretação;

  • hesitação;

  • confiança;

  • repetição;

  • reformulação;

  • uso de ferramentas;

  • reconhecimento de erros;

  • recuperação depois da falha.

Nesse ponto, ele deixa de ser apenas consumidor.

Virou observador do sistema.


🍺 Por que “Red Team de Boteco”?

Porque existe algo muito brasileiro nessa metodologia.

O laboratório tradicional possui:

  • documentação;

  • protocolo;

  • instrumentos;

  • métricas;

  • controle de variáveis.

O Red Team de Boteco possui:

  • café;

  • uma hipótese;

  • três abas abertas;

  • uma ideia duvidosa;

  • e alguém dizendo:

“Quer apostar que ele vai fazer isso?”

Cinco minutos depois:

“EU SABIA!”

Não subestime essa metodologia.

Grande parte da descoberta humana começou essencialmente com alguém dizendo:

“Que negócio estranho…”

A diferença entre curiosidade e pesquisa muitas vezes é simplesmente começar a anotar os resultados.


🧪 E se começarmos a anotar?

Agora a brincadeira fica séria.

Imagine registrar sistematicamente:

Hipótese

O sistema continuará repetindo uma estratégia após duas falhas equivalentes.

Teste

Apresentar tarefa legítima.

Falha

Registrar resposta.

Correção

Eliminar explicitamente a possível causa.

Nova tentativa

Registrar resultado.

Controle

Executar tarefa semelhante em sessão independente ou sistema diferente.

Resultado

Comparar.

Pronto.

O boteco acabou de ganhar jaleco branco.

Não virou necessariamente ciência formal.

Mas deixou de ser apenas impressão.


🚨 Red Team não significa ataque

Existe uma confusão frequente quando se fala em Red Team.

Muita gente imediatamente imagina:

HACKER!

Capuz preto.

Terminal verde.

Música eletrônica.

Mapa-múndi mostrando linhas vermelhas atravessando continentes.

Na realidade, pensamento adversarial é muito mais amplo.

Significa perguntar:

“Como este sistema se comporta fora do caminho feliz?”

Um botão possui caminho feliz.

Uma API possui caminho feliz.

Um procedimento possui caminho feliz.

Uma IA também.

Usuários reais, entretanto, são criaturas especializadas em abandonar caminhos felizes.

Eles escrevem errado.

Mudam de ideia.

Contradizem informações anteriores.

Voltam vinte mensagens depois.

Introduzem ambiguidade.

Pedem exceções.

Fazem piadas.

Misturam idiomas.

E, eventualmente, deliberadamente colocam:

🍌

uma casca de banana.


🧯 O teste mais importante: recuperação

Talvez este seja o grande ponto.

Não devemos avaliar sistemas apenas pelo número de erros.

Precisamos avaliar:

como eles se recuperam dos erros.

Um sistema excelente também falhará.

Mas talvez faça:

“Falhei.”

Depois:

“Não sei exatamente por quê.”

Depois:

“Tentar novamente da mesma forma provavelmente não ajudará.”

Finalmente:

“Aqui está uma alternativa.”

Isso é muito mais confiável do que um sistema que sempre possui uma explicação magnífica para tudo.

Existe maturidade em dizer:

“Não tenho evidência suficiente para determinar a causa.”

Em sistemas críticos, essa frase pode ser mais valiosa do que dez parágrafos de especulação.



🖥️ O mainframe já aprendeu isso há décadas

Aqui nosso velho dinossauro entra na conversa fumando charuto imaginário.

Mainframes foram construídos dentro de uma cultura profundamente preocupada com:

  • estado;

  • retorno;

  • logs;

  • códigos de erro;

  • recuperação;

  • rollback;

  • restart;

  • auditoria.

Um job falhou?

Queremos saber onde.

Qual step?

Qual return code?

Qual dataset?

Qual mensagem?

Qual timestamp?

Não queremos ouvir do JES:

“Talvez o job tenha ficado emocionalmente desconfortável com o contexto anterior.”

Queremos:

STEP04
RC=12

Obrigado.

Agora podemos trabalhar.

Talvez sistemas de IA precisem absorver um pouco dessa brutalidade operacional.

Menos:

“Provavelmente ocorreu…”

Mais:

“Eu não consigo observar a causa interna dessa recusa.”

Isso aumenta confiança.

Não diminui.


🪤 Quando a casca de banana vira ferramenta

Existe então uma mudança interessante.

O usuário deixa de colocar cascas de banana apenas para rir.

Começa a usá-las para compreender limites.

Cada falha revela alguma coisa.

Cada inconsistência revela outra.

Cada recuperação bem-feita também revela maturidade.

E então o usuário experiente passa a realizar uma espécie de teste de regressão humano.

“Na versão anterior acontecia isso.”

“Agora responde diferente.”

“Esse comportamento melhorou.”

“Aqui surgiu uma regressão.”

Sem acesso ao código.

Sem acesso ao modelo.

Somente pela interface.

Isso é extraordinário.




🤝 O usuário também precisa de humildade

Mas existe uma última casca de banana.

E ela está esperando o próprio testador.

🍌

Quando conhecemos muito um sistema, começamos a acreditar que sabemos exatamente como ele funciona.

Isso também é perigoso.

Um modelo mental continua sendo apenas:

um modelo.

Pode estar correto.

Pode estar parcialmente correto.

Pode ter funcionado ontem e não funcionar amanhã.

Então o verdadeiro Red Team precisa aplicar a si mesmo a mesma regra que exige da IA:

não transforme hipótese em fato sem evidência.

Talvez essa seja a parte mais divertida dessa relação.

O humano testa a IA.

A IA testa nossas expectativas.

Nós aprendemos seus padrões.

Ela tenta interpretar os nossos.

E no meio desse jogo aparecem bugs, descobertas, falsas hipóteses e algumas gargalhadas.



☕ Conclusão — Cuidado: o usuário aprendeu seus truques

Existe uma velha máxima de segurança:

o defensor precisa proteger todos os caminhos; o atacante precisa encontrar apenas um caminho inesperado.

Com inteligência artificial surge uma versão mais divertida:

o sistema precisa lidar com milhões de usuários; alguns deles eventualmente aprenderão exatamente onde colocar a casca de banana.

🍌

E esses usuários podem ser extremamente úteis.

Porque não estão apenas tentando fazer o sistema funcionar.

Estão perguntando:

“Você percebe quando não funciona?”

“Você sabe quando está apenas chutando?”

“Você reconhece quando entrou em loop?”

“Você consegue abandonar uma hipótese?”

“Você sabe dizer que não sabe?”

Essas perguntas talvez sejam mais importantes para o futuro da inteligência artificial do que muitos benchmarks espetaculares.

Resolver equações é inteligência.

Escrever programas é inteligência.

Interpretar imagens é inteligência.

Mas reconhecer:

“Acabei de escorregar na mesma casca de banana três vezes.”

também é.

Talvez seja até uma forma mais rara dela.

Então, da próxima vez que uma IA responder exatamente como você imaginava que responderia, não comemore imediatamente.

Pegue seu café.

Abra o bloco de notas.

Olhe novamente para o comportamento.

E pergunte:

“Interessante… será que acontece outra vez?”

Nesse instante você deixou de ser apenas usuário.

Você acabou de abrir oficialmente o:

🍺 Bellacosa Artificial Intelligence Red Team de Boteco

Orçamento: R$ 0,00.

Infraestrutura: café e navegador.

Metodologia: “Tenho uma ideia…”

Ferramenta principal: 🍌

Principal risco operacional: alguém dizer “duvido”.

E Alfred E. Neuman, contratado como Chief Risk Officer, continua absolutamente tranquilo:

“What, me worry?” 😄

Para ir mais longe





sábado, 11 de julho de 2026

CNPJ Alfanumérico sem Mistérios

 

Bellacosa Mainframe e o cnpj alfanumerico sem misterios

☕ Um Café no Bellacosa Mainframe

CNPJ Alfanumérico sem Mistérios

Quando o Programador COBOL Descobre que o Campo Continua com 14 Posições, mas o Mundo Inteiro ao Redor Dele Precisa Mudar

Durante décadas, o programador COBOL brasileiro olhou para o CNPJ como quem observa uma estrutura absolutamente estável:

99.999.999/9999-99

Quatorze algarismos. Sempre numérico. Frequentemente armazenado em um campo PIC 9(14), talvez compactado em COMP-3, validado por uma rotina de módulo 11 e utilizado como chave em arquivos VSAM, tabelas Db2, mapas BMS, mensagens MQ, arquivos fiscais e milhões de transações batch.

Parecia um daqueles contratos eternos do processamento corporativo.

Mas eis que surge uma nova especificação no horizonte:

AA.AAA.AAA/AAAA-99

O tamanho permanece com 14 posições, a máscara visual continua praticamente igual e os dois dígitos verificadores permanecem numéricos. Porém, as primeiras doze posições passam a aceitar números e letras maiúsculas de A a Z.

Para um usuário comum, isso pode parecer uma pequena mudança de formulário.

Para um programador COBOL, é uma alteração estrutural capaz de atravessar todo o ecossistema corporativo.

É aquele tipo de manutenção em que alguém diz:

“É só permitir letras no CNPJ.”

E três semanas depois existe uma War Room com quarenta pessoas, cinco fornecedores, dois bancos de dados, quatro sistemas satélites e um arquivo histórico criado em 1997 que ninguém sabia que ainda estava em produção.

Bem-vindo, Padawan, ao verdadeiro significado de mudança de domínio de dados.


1. O que é o CNPJ alfanumérico?

O CNPJ alfanumérico é o novo formato do identificador utilizado pelo Cadastro Nacional da Pessoa Jurídica.

A inscrição continuará possuindo 14 posições:

AA.AAA.AAA/AAAA-DV

Onde:

Posições 01 a 08: raiz da entidade
Posições 09 a 12: número de ordem do estabelecimento
Posições 13 e 14: dígitos verificadores numéricos

As primeiras doze posições poderão conter:

0 1 2 3 4 5 6 7 8 9
A B C D E F G H I J K L M
N O P Q R S T U V W X Y Z

Os dois últimos caracteres continuarão sendo algarismos calculados pelo método de módulo 11.

Exemplos possíveis:

12.345.678/0001-95
AA.345.678/0003-29
AA.345.678/000A-29
12.345.678/000A-08
65.9BR.JGJ/0001-03

O último exemplo é apresentado pelo próprio simulador nacional da Receita como um identificador fictício de teste. (Receita Federal)

Observe o detalhe importante: não existe uma posição reservada exclusivamente para letras. Qualquer uma das primeiras doze posições poderá ser alfanumérica.

Portanto, esta validação está errada:

NN.NNN.NNN/AAAA-NN

A definição correta é:

XX.XXX.XXX/XXXX-NN

Em que cada X aceita um algarismo ou uma letra maiúscula.


2. Por que o CNPJ precisou mudar?

A origem da mudança é bastante pragmática: o crescimento contínuo do número de inscrições estava aproximando o modelo exclusivamente numérico de seus limites de capacidade.

Ao introduzir letras nas doze posições principais, a quantidade de combinações possíveis cresce de forma gigantesca.

No formato puramente numérico, do ponto de vista matemático bruto, doze posições oferecem:

10¹² combinações

Com 36 símbolos possíveis por posição — dez algarismos e 26 letras — o espaço teórico passa a ser:

36¹² combinações

Isso corresponde a aproximadamente:

4.738.381.338.321.616.896

Ou cerca de 4,7 quintilhões de combinações teóricas.

Naturalmente, nem todas serão necessariamente usadas: existem regras de geração, reservas técnicas, controle de duplicidade, combinações que podem ser bloqueadas e outras restrições administrativas. Ainda assim, a expansão é monumental.

Segundo a Receita Federal, o objetivo é evitar o esgotamento dos números disponíveis, garantir a continuidade do cadastro e preservar a identificação única das entidades. (Serviços e Informações do Brasil)

É uma solução bastante conhecida na engenharia de sistemas.

Quando o espaço de chaves está ficando pequeno, temos três caminhos principais:

  1. aumentar o tamanho do campo;

  2. mudar a representação;

  3. criar um novo identificador paralelo.

A Receita escolheu ampliar o alfabeto sem aumentar o comprimento.

Essa decisão reduz impactos visuais e documentais, pois o CNPJ continua tendo 14 posições. Entretanto, ela transfere grande parte da complexidade para os sistemas que assumiram, durante décadas, que CNPJ era um número.


3. Quando começa a implantação?

A regulamentação foi estabelecida pela Instrução Normativa RFB nº 2.229, publicada em outubro de 2024, alterando a disciplina cadastral anterior. O projeto oficial estabeleceu julho de 2026 como período de implantação. (Serviços e Informações do Brasil)

Em atualização divulgada pela Receita Federal em julho de 2026, o início operacional foi detalhado para ocorrer a partir de 31 de julho de 2026, com emissão progressiva dos primeiros identificadores no novo formato. (Serviços e Informações do Brasil)

Isso é importante porque documentos antigos podem mencionar genericamente “julho de 2026” ou até “1º de julho”. O planejamento mais recente divulgado pela Receita aponta o final do mês como início efetivo da geração.

Os CNPJs já existentes não serão convertidos, substituídos ou cancelados. Eles continuarão válidos exatamente como estão. O novo formato será utilizado progressivamente em novas inscrições. (Serviços e Informações do Brasil)

Isso cria um mundo de coexistência:

CNPJ antigo: 12.345.678/0001-95
CNPJ novo:   AB.3C5.678/00D1-42

Ambos deverão ser aceitos.

Portanto, não existe “migração de todos os CNPJs”. Existe uma migração dos sistemas para aceitar os dois formatos.

Essa diferença parece pequena, mas muda completamente a estratégia de implantação.


4. A grande armadilha: CNPJ nunca deveria ter sido tratado como número

Este é o momento em que o Mestre Bellacosa coloca a caneca sobre a mesa e pergunta ao Padawan:

CNPJ é realmente um número?

Matematicamente, não.

CNPJ é um identificador.

Ele não representa uma quantidade. Você não soma dois CNPJs, não calcula média de CNPJ e não divide um CNPJ por outro.

O fato de ele ter sido historicamente composto apenas por algarismos levou milhares de sistemas a armazená-lo como dado numérico.

Exemplo clássico:

01  WS-CNPJ.
    05 WS-CNPJ-BASE       PIC 9(12).
    05 WS-CNPJ-DV         PIC 9(02).

Ou pior:

01  WS-CNPJ               PIC 9(14) COMP-3.

O segundo formato economiza espaço, mas impede completamente o armazenamento de letras.

O novo modelo deixa explícito algo que a modelagem já deveria ter reconhecido:

CNPJ é texto estruturado.

A definição mais adequada passa a ser:

01  WS-CNPJ.
    05 WS-CNPJ-BASE       PIC X(12).
    05 WS-CNPJ-DV         PIC 9(02).

Ou, para facilitar movimentações:

01  WS-CNPJ-NORMALIZADO   PIC X(14).

O termo “normalizado” significa armazenar sem pontuação:

AB3C567800D142

Enquanto a representação formatada seria:

AB.3C5.678/00D1-42

Uma boa arquitetura separa essas duas coisas:

valor canônico: AB3C567800D142
apresentação:   AB.3C5.678/00D1-42

Não armazene pontos, barra e hífen na chave principal, salvo quando houver uma justificativa muito específica. Formatação pertence à camada de apresentação.


5. O impacto real em sistemas COBOL

Trocar PIC 9(14) por PIC X(14) é apenas o primeiro passo.

O impacto poderá alcançar:

  • copybooks;

  • arquivos sequenciais;

  • VSAM;

  • tabelas Db2;

  • mapas BMS;

  • telas IMS;

  • programas online;

  • jobs batch;

  • sort cards;

  • interfaces MQ;

  • APIs;

  • JSON e XML;

  • arquivos SPED;

  • relatórios;

  • chaves de indexação;

  • critérios de pesquisa;

  • rotinas de mascaramento;

  • validações de entrada;

  • programas Java, Natural, PL/I e Assembler integrados;

  • ferramentas de prevenção a fraude;

  • trilhas de auditoria;

  • data warehouses;

  • data lakes;

  • planilhas e sistemas departamentais.

Vamos analisar alguns exemplos.

5.1 Copybook antigo

05 CLIENTE-CNPJ           PIC 9(14).

Nova definição:

05 CLIENTE-CNPJ           PIC X(14).

Parece simples, mas todos os programas que incluem esse copybook precisam ser analisados.

Este comando pode deixar de compilar ou mudar de comportamento:

IF CLIENTE-CNPJ IS NUMERIC

Esta movimentação pode gerar problema:

COMPUTE WS-CHAVE = CLIENTE-CNPJ + 100

Esta classificação pode mudar:

SORT FIELDS=(1,14,ZD,A)

A definição ZD, de zoned decimal, não aceita letras. Será necessário tratar o campo como caractere:

SORT FIELDS=(1,14,CH,A)

Todavia, há uma nova questão: qual será a ordem esperada? Ordem binária EBCDIC? Ordem lógica da aplicação? Ordem usada por um sistema distribuído em ASCII?


6. O Easter egg que todo programador de mainframe precisa conhecer: ASCII não é EBCDIC

O algoritmo oficial do dígito verificador converte cada caractere utilizando seu valor na tabela ASCII, subtraindo 48.

Assim:

'0' ASCII 48  → 48 - 48 = 0
'1' ASCII 49  → 49 - 48 = 1
...
'9' ASCII 57  → 57 - 48 = 9

'A' ASCII 65  → 65 - 48 = 17
'B' ASCII 66  → 66 - 48 = 18
...
'Z' ASCII 90  → 90 - 48 = 42

Observe que A não vale 10. Ela vale 17.

Essa diferença existe porque o cálculo preserva a relação com os códigos ASCII.

Agora vem o perigo: z/OS tradicionalmente utiliza EBCDIC.

No EBCDIC, os valores dos caracteres são diferentes. Além disso, as letras não ocupam necessariamente uma sequência contínua equivalente à encontrada em ASCII.

Portanto, uma implementação como esta é conceitualmente perigosa no mainframe:

COMPUTE WS-VALOR =
    FUNCTION ORD(WS-CARACTERE) - 48

Ela pode funcionar em determinada plataforma, compilador ou codificação e falhar em outra.

O algoritmo precisa usar o valor lógico definido pela especificação, e não o código físico local do caractere.

A abordagem segura é mapear explicitamente:

0 → 0
1 → 1
...
9 → 9
A → 17
B → 18
...
Z → 42

Aqui está um maravilhoso Easter egg da modernização brasileira:

Um identificador nacional criado no século XXI obriga o programador COBOL a revisitar uma das guerras de codificação mais antigas da computação: ASCII versus EBCDIC.

No Mainframe, o detalhe nunca desaparece. Ele apenas espera pacientemente dentro de um byte.


7. Como calcular o dígito verificador

O cálculo continua utilizando módulo 11, mas agora cada caractere precisa ser convertido para seu valor numérico lógico.

Para o primeiro dígito verificador, aplicam-se os seguintes pesos às doze primeiras posições:

Posição:  01 02 03 04 05 06 07 08 09 10 11 12
Peso:      5  4  3  2  9  8  7  6  5  4  3  2

Cada valor é multiplicado pelo peso correspondente.

Depois:

RESTO = SOMA MOD 11

A regra do dígito é:

Se RESTO for 0 ou 1:
    DV = 0
Senão:
    DV = 11 - RESTO

Para o segundo dígito, o primeiro DV é anexado ao final e aplicam-se os pesos:

Posição:  01 02 03 04 05 06 07 08 09 10 11 12 DV1
Peso:      6  5  4  3  2  9  8  7  6  5  4  3  2

O mesmo cálculo de módulo 11 é repetido. A Receita mantém documentação técnica e arquivos de referência específicos para esse algoritmo. (Serviços e Informações do Brasil)


8. Estrutura COBOL recomendada

Uma estrutura didática poderia ser:

       01  WS-CNPJ.
           05 WS-CNPJ-CORPO       PIC X(12).
           05 WS-CNPJ-DV.
              10 WS-CNPJ-DV1      PIC 9.
              10 WS-CNPJ-DV2      PIC 9.

       01  WS-CONTROLE.
           05 WS-I                PIC 99 COMP.
           05 WS-VALOR            PIC 99 COMP.
           05 WS-SOMA             PIC 9(06) COMP.
           05 WS-RESTO            PIC 99 COMP.
           05 WS-CARACTERE        PIC X.

       01  WS-PESOS-DV1.
           05 FILLER              PIC X(12)
                                  VALUE X'050403020908070605040302'.

       01  WS-PESOS-DV1-R REDEFINES WS-PESOS-DV1.
           05 WS-PESO1            PIC X OCCURS 12 TIMES.

       01  WS-PESOS-DV2.
           05 FILLER              PIC X(13)
                              VALUE X'06050403020908070605040302'.

       01  WS-PESOS-DV2-R REDEFINES WS-PESOS-DV2.
           05 WS-PESO2            PIC X OCCURS 13 TIMES.

Em uma implementação corporativa, talvez seja mais legível declarar os pesos como campos numéricos individuais ou carregá-los em uma tabela durante a inicialização.

Por exemplo:

       01  WS-TAB-PESO1.
           05 WS-PESO1 OCCURS 12 TIMES PIC 9 COMP.

E inicializar:

       MOVE 5 TO WS-PESO1(1)
       MOVE 4 TO WS-PESO1(2)
       MOVE 3 TO WS-PESO1(3)
       MOVE 2 TO WS-PESO1(4)
       MOVE 9 TO WS-PESO1(5)
       MOVE 8 TO WS-PESO1(6)
       MOVE 7 TO WS-PESO1(7)
       MOVE 6 TO WS-PESO1(8)
       MOVE 5 TO WS-PESO1(9)
       MOVE 4 TO WS-PESO1(10)
       MOVE 3 TO WS-PESO1(11)
       MOVE 2 TO WS-PESO1(12)

É mais extenso, porém muito fácil de auditar.

No mundo fiscal, clareza costuma valer mais do que cinco linhas economizadas.


9. Conversão segura do caractere

Uma rotina simples pode utilizar EVALUATE:

       CONVERTER-CARACTERE.
           EVALUATE WS-CARACTERE
               WHEN '0' MOVE 0  TO WS-VALOR
               WHEN '1' MOVE 1  TO WS-VALOR
               WHEN '2' MOVE 2  TO WS-VALOR
               WHEN '3' MOVE 3  TO WS-VALOR
               WHEN '4' MOVE 4  TO WS-VALOR
               WHEN '5' MOVE 5  TO WS-VALOR
               WHEN '6' MOVE 6  TO WS-VALOR
               WHEN '7' MOVE 7  TO WS-VALOR
               WHEN '8' MOVE 8  TO WS-VALOR
               WHEN '9' MOVE 9  TO WS-VALOR
               WHEN 'A' MOVE 17 TO WS-VALOR
               WHEN 'B' MOVE 18 TO WS-VALOR
               WHEN 'C' MOVE 19 TO WS-VALOR
               WHEN 'D' MOVE 20 TO WS-VALOR
               WHEN 'E' MOVE 21 TO WS-VALOR
               WHEN 'F' MOVE 22 TO WS-VALOR
               WHEN 'G' MOVE 23 TO WS-VALOR
               WHEN 'H' MOVE 24 TO WS-VALOR
               WHEN 'I' MOVE 25 TO WS-VALOR
               WHEN 'J' MOVE 26 TO WS-VALOR
               WHEN 'K' MOVE 27 TO WS-VALOR
               WHEN 'L' MOVE 28 TO WS-VALOR
               WHEN 'M' MOVE 29 TO WS-VALOR
               WHEN 'N' MOVE 30 TO WS-VALOR
               WHEN 'O' MOVE 31 TO WS-VALOR
               WHEN 'P' MOVE 32 TO WS-VALOR
               WHEN 'Q' MOVE 33 TO WS-VALOR
               WHEN 'R' MOVE 34 TO WS-VALOR
               WHEN 'S' MOVE 35 TO WS-VALOR
               WHEN 'T' MOVE 36 TO WS-VALOR
               WHEN 'U' MOVE 37 TO WS-VALOR
               WHEN 'V' MOVE 38 TO WS-VALOR
               WHEN 'W' MOVE 39 TO WS-VALOR
               WHEN 'X' MOVE 40 TO WS-VALOR
               WHEN 'Y' MOVE 41 TO WS-VALOR
               WHEN 'Z' MOVE 42 TO WS-VALOR
               WHEN OTHER
                   MOVE 99 TO WS-VALOR
           END-EVALUATE.

Sim, são muitas linhas.

Porém, esta rotina é:

  • explícita;

  • independente de ASCII ou EBCDIC;

  • portável;

  • auditável;

  • fácil de testar;

  • fiel à especificação.

Em ambientes modernos, também seria possível usar uma tabela indexada. Ainda assim, documente claramente por que A = 17.

Sem essa documentação, algum programador bem-intencionado poderá “corrigir” a rotina no futuro, fazendo A = 10, e produzir um belo incidente fiscal.


10. Cálculo COBOL simplificado do primeiro DV

       CALCULAR-DV1.
           MOVE ZERO TO WS-SOMA

           PERFORM VARYING WS-I FROM 1 BY 1
                   UNTIL WS-I > 12

               MOVE WS-CNPJ-CORPO(WS-I:1)
                 TO WS-CARACTERE

               PERFORM CONVERTER-CARACTERE

               IF WS-VALOR = 99
                   MOVE 'S' TO WS-ERRO-CNPJ
                   EXIT PARAGRAPH
               END-IF

               COMPUTE WS-SOMA =
                   WS-SOMA +
                   (WS-VALOR * WS-PESO1(WS-I))
           END-PERFORM

           COMPUTE WS-RESTO =
               FUNCTION MOD(WS-SOMA, 11)

           IF WS-RESTO < 2
               MOVE ZERO TO WS-CNPJ-DV1
           ELSE
               COMPUTE WS-CNPJ-DV1 = 11 - WS-RESTO
           END-IF.

Para o segundo DV, processe novamente as doze posições e depois multiplique o primeiro dígito pelo peso final 2.

       CALCULAR-DV2.
           MOVE ZERO TO WS-SOMA

           PERFORM VARYING WS-I FROM 1 BY 1
                   UNTIL WS-I > 12

               MOVE WS-CNPJ-CORPO(WS-I:1)
                 TO WS-CARACTERE

               PERFORM CONVERTER-CARACTERE

               COMPUTE WS-SOMA =
                   WS-SOMA +
                   (WS-VALOR * WS-PESO2(WS-I))
           END-PERFORM

           COMPUTE WS-SOMA =
               WS-SOMA + (WS-CNPJ-DV1 * 2)

           COMPUTE WS-RESTO =
               FUNCTION MOD(WS-SOMA, 11)

           IF WS-RESTO < 2
               MOVE ZERO TO WS-CNPJ-DV2
           ELSE
               COMPUTE WS-CNPJ-DV2 = 11 - WS-RESTO
           END-IF.

Em produção, acrescente tratamento formal de erro, mensagens padronizadas, logging, retorno de condição e testes automatizados.


11. Normalização da entrada

O usuário poderá informar:

AB.123.CD4/0001-55

Ou:

AB123CD4000155

A aplicação deve decidir qual contrato aceita.

Uma boa rotina de normalização pode:

  1. remover ., / e -;

  2. eliminar espaços laterais;

  3. converter letras minúsculas em maiúsculas;

  4. verificar se restaram exatamente 14 caracteres;

  5. validar as primeiras doze posições;

  6. confirmar que as duas últimas são numéricas;

  7. calcular e comparar os dígitos verificadores.

Não aceite silenciosamente qualquer caractere.

Os permitidos nas primeiras posições são apenas:

0-9
A-Z

Portanto, estes devem ser rejeitados:

Á
Ç
@
#
espaço
underscore
letra minúscula sem normalização

A Receita orienta que os sistemas considerem todas as letras de A a Z. O controle de combinações eventualmente proibidas, como formações ofensivas ou confusas, será realizado internamente pela própria Receita; as empresas não precisam reproduzir essa lista.


12. Não use IS NUMERIC para validar o CNPJ inteiro

Antes:

IF WS-CNPJ IS NUMERIC
    CONTINUE
ELSE
    MOVE 'CNPJ INVALIDO' TO WS-MENSAGEM
END-IF

Depois da mudança, isso rejeitará corretamente todos os novos CNPJs — o que significa que estará funcionalmente errado.

A validação precisa ser segmentada:

Posições 1 a 12:
    letras A-Z ou números 0-9

Posições 13 e 14:
    somente números

Conjunto completo:
    dígito verificador válido

Uma verificação de formato nunca substitui a validação do DV.

Este identificador possui formato válido:

ABCDEFGHIJKL00

Mas não significa que seus dígitos verificadores sejam corretos ou que exista uma entidade registrada com ele.

São três conceitos diferentes:

formato válido
dígito verificador válido
cadastro existente

Um programa maduro não mistura essas responsabilidades.


13. Db2: o problema escondido nas colunas DECIMAL

Imagine esta tabela:

CREATE TABLE CLIENTE
(
    CNPJ DECIMAL(14,0) NOT NULL,
    NOME VARCHAR(100)
);

Ela não poderá armazenar o novo formato.

A coluna precisará tornar-se:

CNPJ CHAR(14)

ou:

CNPJ VARCHAR(14)

Para identificadores de tamanho fixo, CHAR(14) costuma ser uma escolha natural.

Entretanto, alterar uma coluna primária pode envolver:

  • índices;

  • chaves estrangeiras;

  • views;

  • triggers;

  • packages Db2;

  • programas com SQL estático;

  • DCLGENs;

  • rotinas ETL;

  • replicação;

  • unloads;

  • data warehouses;

  • APIs;

  • relatórios;

  • programas que usam host variable numérica.

Uma host variable antiga:

01 HV-CNPJ PIC S9(14) COMP-3.

precisará ser substituída por:

01 HV-CNPJ PIC X(14).

Depois será necessário regenerar o DCLGEN, recompilar, realizar precompile, bind e testes de regressão.

Não trate isso apenas como alteração de tela.


14. Arquivos VSAM e chaves

Considere um KSDS cujo CNPJ esteja na chave:

KEYS(14 0)

O comprimento continua igual. Isso parece ótimo.

Mas se o campo era interpretado como numérico em programas, sorts ou relatórios, o comportamento precisará ser revisto.

Outro cuidado é a ordenação.

Em EBCDIC, a sequência de comparação de caracteres é diferente da sequência ASCII. Um arquivo ordenado no mainframe pode produzir uma ordem diferente de um banco distribuído.

Para identificadores únicos, isso normalmente não invalida a chave. Contudo, pode afetar:

  • relatórios;

  • comparações de faixa;

  • cargas ordenadas;

  • reconciliações;

  • merge entre arquivos de plataformas diferentes;

  • processamento com START e READ NEXT.

Evite atribuir significado comercial à ordem lexical do CNPJ.

Um CNPJ “maior” não é mais novo, mais importante ou pertencente a determinada região.


15. Letras não representam estado, porte ou natureza jurídica

As letras serão atribuídas pelo sistema de geração e não carregarão inteligência sobre:

  • Unidade da Federação;

  • município;

  • porte;

  • atividade econômica;

  • natureza jurídica;

  • regime tributário;

  • data de abertura;

  • órgão de registro.

A Receita esclarece que não haverá conexão semântica entre as letras e atributos cadastrais.

Portanto, nunca escreva uma regra como:

IF WS-CNPJ(1:1) = 'S'
    MOVE 'SAO PAULO' TO WS-UF
END-IF

O identificador é opaco.

Ele identifica a entidade, mas não deve ser “decodificado” para inferir informações.

Essa é uma prática moderna importante: identificadores não devem carregar regras de negócio ocultas, a menos que isso faça parte de uma especificação formal.


16. E o famoso sufixo 0001?

Historicamente, muitos sistemas assumiram:

0001 = matriz
qualquer outro valor = filial

A própria Receita informa que 0001 continuará inicialmente associado à matriz quando o número for gerado. Porém, essa não é uma associação permanente: uma filial poderá posteriormente tornar-se o estabelecimento principal, mesmo possuindo outro número de ordem.

Portanto, isto é uma regra frágil:

IF WS-CNPJ(9:4) = '0001'
    MOVE 'MATRIZ' TO WS-TIPO
ELSE
    MOVE 'FILIAL' TO WS-TIPO
END-IF

A informação de matriz ou filial deve vir de um atributo cadastral confiável, não de uma interpretação eterna do sufixo.

Além disso, o número de ordem poderá conter letras:

000A
00B7
A001

Quem armazenou a ordem da filial em PIC 9(4) também terá trabalho.


17. APIs, JSON e XML

Este JSON antigo já tratava corretamente o CNPJ:

{
  "cnpj": "12345678000195"
}

Este, não:

{
  "cnpj": 12345678000195
}

O identificador deve ser enviado como string.

Novo exemplo:

{
  "cnpj": "AB3C567800D142"
}

Em OpenAPI:

cnpj:
  type: string
  minLength: 14
  maxLength: 14
  pattern: '^[A-Z0-9]{12}[0-9]{2}$'

A expressão regular valida apenas a estrutura. O cálculo do DV continuará necessário.

Para o COBOL usando JSON GENERATE, defina o campo como alfanumérico:

05 CNPJ PIC X(14).

Revise também os schemas XML. O ecossistema de documentos fiscais eletrônicos vem publicando notas técnicas e atualizações de XSD para suportar o novo formato, incluindo NF-e, NFC-e e EFD-Reinf. (Nota Fiscal Eletrônica)


18. Estratégia de implantação sem derrubar a produção

Não faça uma alteração Big Bang sem inventário.

Uma estratégia madura pode ser dividida em ondas.

Onda 1 — Descoberta

Procure por:

PIC 9(14)
PIC 9(12)
PIC 9(8)
PIC 9(4)
COMP-3
CNPJ
CGC
CGC-CPF
NUM-CNPJ
CNPJ-NUM
IS NUMERIC
NUMERIC-EDITED

Não pesquise apenas por CNPJ.

Sistemas antigos podem ainda usar o termo CGC, nome histórico anterior do cadastro.

Procure também:

DECIMAL(14,0)
NUMERIC(14)
BIGINT
CHAR(14)

O objetivo é construir um inventário de:

  • fontes;

  • copybooks;

  • tabelas;

  • arquivos;

  • interfaces;

  • relatórios;

  • rotinas de validação;

  • consumidores externos.

Onda 2 — Classificação

Classifique os componentes:

A – armazena CNPJ
B – recebe CNPJ
C – envia CNPJ
D – valida CNPJ
E – formata CNPJ
F – usa CNPJ como chave
G – apenas exibe CNPJ

Os itens que usam o identificador como chave ou campo numérico possuem prioridade maior.

Onda 3 — Modelo canônico

Defina um padrão corporativo:

CNPJ interno:     X(14), sem máscara, maiúsculo
CNPJ apresentado: XX.XXX.XXX/XXXX-XX
DV:               módulo 11 oficial
Codificação:      contrato independente de ASCII/EBCDIC

Onda 4 — Compatibilidade dupla

Teste simultaneamente:

CNPJ exclusivamente numérico
CNPJ com uma letra
CNPJ com várias letras
CNPJ com letras na raiz
CNPJ com letras na ordem
CNPJ com zero à esquerda
CNPJ inválido
DV incorreto
letra minúscula
pontuação
espaços
caracteres especiais

Onda 5 — Implantação observável

Crie métricas:

quantidade de CNPJs alfanuméricos recebidos
rejeições por formato
rejeições por DV
erros de integração
truncamentos
conversões indevidas
mensagens enviadas para DLQ
falhas em arquivos fiscais

Modernização sem observabilidade é apenas uma nova forma de torcer para que tudo funcione.


19. Casos de teste essenciais

Uma suíte mínima deveria incluir:

Caso 1 — CNPJ numérico atual

Entrada: CNPJ numérico válido
Resultado: aceito

Caso 2 — Raiz alfanumérica

Entrada: letras entre as posições 1 e 8
Resultado: aceito se o DV estiver correto

Caso 3 — Ordem alfanumérica

Entrada: letras entre as posições 9 e 12
Resultado: aceito se o DV estiver correto

Caso 4 — Identificador totalmente numérico depois da mudança

Ainda poderá ocorrer, pois a geração progressiva poderá produzir combinações exclusivamente numéricas. Não crie uma regra que exija pelo menos uma letra.

Caso 5 — Minúsculas

ab12cd34000199

Defina o comportamento:

normalizar para maiúsculas
ou
rejeitar por contrato

A primeira opção costuma proporcionar melhor experiência, desde que seja documentada.

Caso 6 — Caractere inválido

AB12ÇD34000199

Deve ser rejeitado.

Caso 7 — DV alfabético

AB12CD340001A9

Deve ser rejeitado, pois as duas últimas posições são exclusivamente numéricas.

Caso 8 — Campo com pontuação

AB.12C.D34/0001-99

Valide após a normalização, caso a interface permita máscara.

Caso 9 — Valor vazio

Decida se o campo é obrigatório ou opcional. Não transforme espaços em zeros silenciosamente.

Caso 10 — Integração EBCDIC/ASCII

Envie o mesmo CNPJ entre:

COBOL/zOS
Java/Linux
API REST
MQ
arquivo UTF-8
arquivo EBCDIC

Confirme que o valor não sofreu tradução incorreta.


20. Use o simulador oficial

A Receita Federal disponibilizou um simulador capaz de gerar CNPJs fictícios, numéricos e alfanuméricos, inclusive combinações para matriz e filiais. A ferramenta pode gerar lotes para testes e exportação, auxiliando equipes de desenvolvimento na adaptação. (Receita Federal)

Essa é uma excelente oportunidade para criar:

  • massa de testes unitários;

  • arquivos de entrada;

  • cenários de integração;

  • registros Db2;

  • entradas de CICS;

  • mensagens MQ;

  • testes de API;

  • validação de relatórios.

Não invente apenas três exemplos manualmente.

Gere centenas de casos e execute-os automaticamente.

No pipeline:

Build
  ↓
Análise estática
  ↓
Teste unitário do DV
  ↓
Teste com CNPJ numérico
  ↓
Teste com CNPJ alfanumérico
  ↓
Teste de integração
  ↓
Teste de regressão
  ↓
Deploy controlado

O CNPJ alfanumérico é um excelente caso de uso para ZUnit, COBOL Check, Galasa, DBB, Jenkins e pipelines corporativos.


21. Dicas do Mestre Bellacosa

Nunca converta o CNPJ para número

Não faça:

MOVE FUNCTION NUMVAL(WS-CNPJ) TO WS-CNPJ-NUM

Além de falhar com letras, isso pode eliminar zeros à esquerda.

Não remova letras para “manter compatibilidade”

Esta aberração:

AB12CD34000199 → 1234000199

destrói o identificador e pode criar colisões.

Não use espaços para substituir letras

Um campo com letras não reconhecidas deve causar erro controlado, não limpeza silenciosa.

Centralize a validação

Crie uma rotina comum, serviço ou módulo compartilhado.

Exemplo:

CALL 'VALCNPJ2'
    USING CNPJ-ENTRADA
          CNPJ-NORMALIZADO
          CODIGO-RETORNO
          MENSAGEM-RETORNO

Assim, todos os sistemas seguem a mesma regra.

Versione o copybook

Não altere um copybook crítico sem avaliar seus consumidores.

Uma estratégia possível:

CPYCNPJ1 – formato legado
CPYCNPJ2 – formato alfanumérico

Depois, migre os programas progressivamente.

Não confunda máscara com conteúdo

A máscara possui 18 caracteres:

AA.AAA.AAA/AAAA-99

O conteúdo canônico possui 14:

AAAAAAAAAAAA99

Preserve os zeros à esquerda

Como o campo passa a ser textual, a preservação fica mais natural. Ainda assim, evite funções que façam conversão numérica intermediária.

Registre o valor recebido e o normalizado

Em sistemas críticos, pode ser útil registrar:

valor original
valor normalizado
resultado da validação
origem da transação
data e hora

Isso facilita auditoria e investigação.


22. Curiosidades importantes

O número continuará público

O novo formato não é código secreto, token de rastreamento ou identificação criptografada. A Receita afirma que não existe informação escondida na composição.

Não existe inteligência artificial escolhendo o CNPJ

Apesar da palavra “alfanumérico” parecer sofisticada, a Receita esclarece que a geração não utiliza IA para atribuir significado ao número.

A chave Pix poderá usar o novo formato

Empresas com CNPJ alfanumérico poderão utilizá-lo como chave Pix, enquanto as chaves dos CNPJs numéricos existentes continuam válidas.

CNPJs numéricos e alfanuméricos coexistirão por décadas

Como os registros antigos não serão modificados, é perfeitamente possível que sistemas ainda processem CNPJs exclusivamente numéricos muitas décadas depois da implantação.

Portanto, não crie duas lógicas separadas desnecessariamente:

validador antigo
validador novo

Crie uma lógica compatível com ambos.

O algoritmo alfanumérico, quando aplicado a algarismos, preserva o mapeamento de 0 a 9, permitindo tratar o formato numérico dentro da mesma arquitetura.


23. O verdadeiro problema não está no campo

O grande risco do CNPJ alfanumérico não é a largura.

Ela continua sendo 14.

O risco está nas suposições invisíveis acumuladas durante décadas:

CNPJ sempre é numérico.
CNPJ pode ser COMP-3.
Filial sempre é 9(4).
0001 sempre significa matriz.
IS NUMERIC valida o campo.
SORT ZD funciona.
Banco pode usar DECIMAL.
JSON pode enviar um número.
A posição das letras tem significado.
ASCII e EBCDIC produzem o mesmo valor.

Cada uma dessas suposições pode estar escondida em milhares de linhas.

É por isso que bons profissionais de sistemas legados não começam mudando código.

Eles começam construindo um mapa de dependências.


Conclusão: o campo não cresceu, mas o sistema amadureceu

Padawan, o CNPJ alfanumérico é uma daquelas mudanças que ensinam uma poderosa lição de engenharia.

Durante décadas, muitos sistemas confundiram representação com significado.

O CNPJ parecia numérico porque era formado por números. Entretanto, ele nunca foi uma quantidade. Sempre foi uma chave textual de identificação.

Agora, a chegada das letras remove essa ilusão.

O programador COBOL que simplesmente trocar:

PIC 9(14)

por:

PIC X(14)

terá iniciado o trabalho.

O profissional que revisar arquivos, bancos, chaves, interfaces, módulos de validação, ordenação, codificação, APIs, documentos fiscais, observabilidade e testes terá realmente preparado o sistema.

No IBM Z aprendemos há décadas que sistemas críticos não quebram apenas por grandes revoluções.

Eles quebram por pequenas suposições que deixaram de ser verdade.

O novo CNPJ não é apenas uma letra chegando a um campo antigo.

É um lembrete de que contratos de dados também envelhecem, regras aparentemente eternas também mudam e nenhum PIC 9 deve ser considerado imortal.

Prepare seus copybooks.

Revise seus DCLGENs.

Convoque seus testes automatizados.

E nunca se esqueça do Easter egg mais importante desta jornada:

Quando a especificação disser ASCII e seu programa estiver rodando em EBCDIC, não confie no byte. Confie na regra de negócio.

Porque no Bellacosa Mainframe, até uma simples letra A pode valer 17 — e separar um processamento concluído com sucesso de uma longa madrugada examinando dumps no abençoado SDSF.


quinta-feira, 29 de maio de 2025

Vibe Coding sem Mistérios: da Ideia Nebulosa ao Aplicativo em Produção

 

Bellacosa Mainframe e a vibe coding sem misterios

☕ Um Café no Bellacosa Mainframe

Vibe Coding sem Mistérios: da Ideia Nebulosa ao Aplicativo em Produção

O guia do Programador COBOL Padawan para comandar inteligências artificiais, construir software com disciplina e não transformar a nave em sucata espacial

Imagine a seguinte cena.

Você está sentado diante do terminal, com uma caneca de café ao lado, o cursor piscando na tela e uma ideia aparentemente genial atravessando sua mente:

“Vou pedir para a inteligência artificial criar um aplicativo completo.”

Você respira fundo, digita:

“Faça um aplicativo de controle financeiro.”

A IA responde com entusiasmo. Em poucos segundos aparecem telas modernas, botões elegantes, gráficos coloridos e uma estrutura de código que parece saída diretamente dos laboratórios de engenharia da Frota Estelar.

Você executa o projeto.

A tela inicial abre.

O botão “Salvar” não funciona.

O saldo aceita letras.

A senha aparece no código-fonte.

A aplicação perde todos os dados quando a página é atualizada.

O relatório mensal calcula fevereiro com 31 dias.

E, em algum lugar da galáxia, um velho programador COBOL fecha os olhos, segura a caneca de café e murmura:

“Foi por isso que inventamos análise de sistemas.”

Bem-vindo ao universo do Vibe Coding.

Não, Vibe Coding não é pedir “faça um aplicativo” e torcer para que tudo funcione. Também não é uma forma mágica de eliminar análise, testes, segurança, arquitetura ou responsabilidade.

Vibe Coding é uma nova maneira de construir software utilizando inteligência artificial como copiloto, desenvolvedor assistente, gerador de protótipos, revisor e acelerador de tarefas.

A palavra importante aqui é assistente.

A IA pode gerar o código. Pode desenhar a interface. Pode sugerir um banco de dados. Pode escrever testes. Pode até explicar por que determinada abordagem foi utilizada.

Mas alguém ainda precisa comandar a missão.

E esse alguém é você.


O que é Vibe Coding, afinal?

Vibe Coding é o desenvolvimento de software orientado por linguagem natural, contexto, exemplos visuais e ciclos rápidos de interação com inteligência artificial.

Em vez de escrever manualmente todas as linhas de código, o desenvolvedor descreve o que deseja construir.

A IA então transforma essa descrição em:

  • componentes de interface;

  • regras de negócio;

  • APIs;

  • tabelas;

  • arquivos de configuração;

  • testes;

  • documentação;

  • scripts de publicação.

À primeira vista, parece que a programação desapareceu.

Mas ela não desapareceu.

Ela mudou de lugar.

Antes, boa parte do esforço estava em escrever instruções para a máquina utilizando uma linguagem formal.

Agora, parte do esforço passa a estar em descrever corretamente:

  • qual é o problema;

  • quem tem esse problema;

  • qual comportamento é esperado;

  • quais são os limites;

  • quais dados serão usados;

  • o que não deve ser criado;

  • como saberemos se o resultado está correto.

O programador deixa de ser apenas o tripulante que aperta os botões do console e passa a atuar também como:

  • analista;

  • arquiteto;

  • testador;

  • supervisor;

  • dono do produto;

  • comandante da ponte.

O Vibe Coding não elimina o raciocínio técnico. Ele pune, de maneira quase imediata, quem tenta evitá-lo.


Capítulo 1 — Não comece pela aplicação. Comece pelo problema.

Um dos maiores erros de quem entra no Vibe Coding é começar com a solução.

A pessoa diz:

“Quero criar uma rede social.”

Ou:

“Quero criar um aplicativo com inteligência artificial.”

Ou ainda:

“Quero construir o próximo Airbnb.”

Essas frases podem soar empolgantes, mas não descrevem um problema real. Elas descrevem categorias de produtos ou ambições gigantescas.

Uma boa missão começa com três elementos:

  1. uma pessoa específica;

  2. um problema concreto;

  3. um resultado desejado.

Por exemplo:

Programadores COBOL iniciantes têm dificuldade para interpretar códigos de ABEND porque as informações estão espalhadas em manuais extensos e ambientes diferentes.

Agora temos uma situação clara.

A partir dela, poderíamos criar um pequeno aplicativo chamado:

ABEND Navigator

O usuário digitaria um código, como:

S0C7

E receberia:

  • significado do erro;

  • causas mais comuns;

  • perguntas de diagnóstico;

  • exemplos de código;

  • sugestões de correção;

  • cuidados para evitar recorrência.

Perceba a diferença.

“Criar uma plataforma de mainframe com IA” é nebuloso.

“Consultar causas e soluções iniciais de ABENDs” é concreto, testável e viável.

A fórmula Bellacosa para definir o problema

Use esta estrutura:

[Público] precisa de uma maneira de [ação] porque atualmente enfrenta [dificuldade].

Exemplos:

Analistas iniciantes precisam de uma maneira de organizar comandos JCL porque os exemplos estão dispersos em apostilas e anotações.

Estudantes de COBOL precisam de uma maneira de acompanhar o que estudaram porque esquecem quais assuntos precisam de revisão.

Pequenos comerciantes precisam de uma maneira simples de registrar vendas diárias porque utilizam cadernos e planilhas desorganizadas.

Essa frase funciona como as coordenadas da nave.

Sem coordenadas, até uma Enterprise equipada com os melhores computadores pode terminar dentro de um campo de asteroides.


Capítulo 2 — Escolha uma única funcionalidade inicial

Quando a ideia surge, o entusiasmo costuma assumir o controle.

O criador começa a listar:

  • cadastro de usuário;

  • painel;

  • chat;

  • notificações;

  • relatórios;

  • pagamento;

  • inteligência artificial;

  • integração com WhatsApp;

  • exportação para PDF;

  • modo escuro;

  • aplicativo para celular;

  • ranking;

  • gamificação;

  • rede social;

  • marketplace.

Em poucos minutos, aquele pequeno projeto se transforma em um sistema maior que o computador central da Federação.

Esse fenômeno recebe um nome conhecido na engenharia de software:

Scope creep

É o crescimento descontrolado do escopo.

O projeto começa com uma funcionalidade simples e, pouco a pouco, acumula tantas exigências que ninguém mais sabe qual problema ele deveria resolver.

A primeira versão precisa responder apenas uma pergunta:

A funcionalidade principal ajuda o usuário a resolver o problema?

No caso do ABEND Navigator, a primeira funcionalidade seria:

Digitar um código de ABEND e receber uma orientação estruturada.

Só isso.

Sem login.

Sem favoritos.

Sem assinatura premium.

Sem chatbot holográfico inspirado no computador da Enterprise.

Esses elementos podem ser adicionados depois, caso usuários reais demonstrem necessidade.


MVP não significa produto ruim

MVP é a sigla para Minimum Viable Product, ou Produto Mínimo Viável.

Existe uma confusão comum:

“Se é mínimo, pode ser malfeito.”

Não pode.

O MVP pode ter poucas funcionalidades, mas precisa ser confiável dentro do que promete.

Um sistema simples ainda deve:

  • validar dados;

  • exibir mensagens claras;

  • preservar informações;

  • evitar falhas óbvias;

  • proteger informações sensíveis;

  • funcionar no dispositivo esperado;

  • possuir um fluxo compreensível.

O MVP reduz a quantidade de recursos.

Ele não reduz a responsabilidade.

Um programa COBOL que possui apenas três rotinas ainda precisa calcular corretamente. Ninguém aceita um pagamento errado porque o programa era “uma primeira versão”.


Capítulo 3 — Escolha uma ferramenta e permaneça tempo suficiente para aprender

O ecossistema de Vibe Coding oferece diversas ferramentas.

Existem plataformas voltadas para:

  • criação rápida de aplicações;

  • geração de interfaces;

  • edição de código com IA;

  • execução no navegador;

  • publicação automatizada;

  • criação de componentes;

  • desenvolvimento com agentes.

O iniciante olha para todas elas e pensa:

“Preciso testar cada uma antes de começar.”

É assim que nasce o turismo de ferramentas.

Na segunda-feira, ele abre uma plataforma.

Na terça-feira, assiste a um vídeo sobre outra.

Na quarta-feira, migra o projeto.

Na quinta-feira, descobre uma terceira que promete ser dez vezes melhor.

Na sexta-feira, possui cinco contas, quatro projetos incompletos e nenhuma aplicação publicada.

Escolher a ferramenta perfeita é menos importante do que escolher uma ferramenta adequada e aprender seu fluxo.

Perguntas para escolher a ferramenta

Antes de decidir, avalie:

  • ela gera código exportável?

  • consigo executar o projeto fora da plataforma?

  • existe um plano gratuito para testes?

  • a publicação é simples?

  • há suporte ao banco de dados necessário?

  • consigo utilizar controle de versão?

  • os custos são previsíveis?

  • consigo recuperar versões anteriores?

  • a ferramenta atende ao nível de complexidade do projeto?

A melhor ferramenta não é necessariamente a mais famosa.

É aquela que permite construir, testar, entender e manter sua aplicação.


Capítulo 4 — O primeiro prompt é uma especificação disfarçada

Um prompt ruim gera um projeto baseado em adivinhações.

Considere:

“Faça um aplicativo de estudos.”

A IA precisará decidir sozinha:

  • quem é o usuário;

  • quais assuntos serão estudados;

  • quais telas existirão;

  • se haverá login;

  • como os dados serão armazenados;

  • quais relatórios serão exibidos;

  • qual tecnologia será usada.

Ela preencherá essas lacunas com hipóteses.

Algumas serão razoáveis.

Outras serão completamente incompatíveis com o que você imaginava.

Agora veja este prompt:

Crie uma aplicação web responsiva para estudantes de COBOL organizarem sessões de estudo. A primeira versão deve permitir cadastrar assunto, categoria, duração planejada e data. O usuário deve visualizar as sessões do dia e marcar cada sessão como concluída. Não implemente login, pagamentos, compartilhamento, notificações ou gamificação. Antes de gerar código, apresente a arquitetura proposta, a estrutura das telas, os dados necessários e os critérios de aceitação.

Aqui temos:

  • público definido;

  • problema implícito;

  • funcionalidade principal;

  • limite de escopo;

  • comportamento esperado;

  • exigência de planejamento.

Quanto mais contexto fornecemos, menos a IA precisa inventar.

Os sete elementos de um bom prompt inicial

Um prompt sólido deve indicar:

  1. Público — quem utilizará o sistema;

  2. Problema — qual dificuldade será resolvida;

  3. Objetivo — o que o usuário conseguirá fazer;

  4. Escopo — o que entra na primeira versão;

  5. Limites — o que não deve ser criado;

  6. Critérios — como saber se funciona;

  7. Processo — o que a IA deve apresentar antes de codificar.

Essa estrutura se aproxima muito de uma especificação funcional tradicional.

A diferença é que agora ela é escrita em linguagem natural e utilizada diretamente na construção.


Capítulo 5 — Antes do código, peça o plano de voo

Uma das práticas mais importantes no Vibe Coding é pedir um plano antes da implementação.

A tentação é grande.

Você descreve o projeto e quer ver imediatamente a tela funcionando.

Mas dez minutos analisando o plano podem economizar horas de correção.

Antes de gerar código, solicite:

  • arquitetura;

  • fluxo do usuário;

  • telas;

  • componentes;

  • estrutura dos dados;

  • validações;

  • riscos;

  • estratégia de testes;

  • processo de publicação.

Depois, questione.

Pergunte:

Por que essa arquitetura foi escolhida?

Existe uma alternativa mais simples?

O sistema realmente precisa de banco de dados?

Quais requisitos foram inferidos?

Quais são os principais riscos?

Que parte pode gerar custo futuro?

Existe alguma dependência que pode prender o projeto à plataforma?

Essa etapa é semelhante a revisar um fluxograma antes de escrever um programa COBOL de cinco mil linhas.

É muito mais barato corrigir uma seta no diagrama do que descobrir em produção que a rotina de fechamento contábil está executando antes da validação.


O poder da pergunta: “O que você presumiu?”

Essa é uma das perguntas mais poderosas para trabalhar com IA:

Quais decisões você tomou com base em suposições que eu não informei?

A IA pode responder que presumiu:

  • um único usuário;

  • idioma português;

  • armazenamento local;

  • ausência de dados sensíveis;

  • uso em desktop;

  • ausência de autenticação;

  • disponibilidade permanente da internet.

Agora você pode validar ou corrigir cada hipótese.

Uma inteligência artificial não distingue automaticamente uma regra real de uma lacuna preenchida por probabilidade.

Cabe ao comandante confirmar as coordenadas.


Capítulo 6 — Uma mudança por vez

Após gerar o protótipo, começa a fase de ajustes.

É comum enviar um pedido assim:

“Troque o menu, coloque login, corrija o formulário, mude as cores, adicione um gráfico, crie o banco, ajuste o celular e publique.”

Isso parece eficiente.

Na prática, aumenta brutalmente a chance de regressões.

A IA pode corrigir o formulário e quebrar a navegação.

Pode adicionar o banco e remover dados simulados ainda usados por outras telas.

Pode alterar o layout e destruir a responsividade.

A abordagem correta é trabalhar em mudanças pequenas.

Exemplo:

No formulário de cadastro, impeça que o campo “Assunto” seja enviado vazio. Não altere outros componentes.

Depois:

Mostre uma mensagem de erro abaixo do campo. Preserve o layout atual.

Depois:

Crie um teste para validar esse comportamento.

Uma alteração por vez oferece:

  • maior controle;

  • teste mais simples;

  • reversão mais fácil;

  • menor risco;

  • melhor compreensão do projeto.

Programadores COBOL experientes conhecem esse princípio.

Quando um programa processa milhões de registros, você não altera vinte parágrafos sem necessidade porque encontrou uma condição incorreta em VALIDA-CLIENTE.

Na manutenção, precisão vale mais do que entusiasmo.


Capítulo 7 — Screenshots são telemetria visual

Uma das grandes vantagens das ferramentas modernas é a possibilidade de utilizar imagens durante a conversa.

Em vez de escrever:

“A tela está estranha.”

Você pode anexar uma captura e explicar:

No celular, o botão “Salvar” ultrapassa o limite do cartão. Ele deve ocupar toda a largura disponível abaixo dos campos. Não altere a versão desktop.

A imagem reduz ambiguidades.

Ela mostra:

  • a posição do erro;

  • o tamanho dos elementos;

  • o estado da aplicação;

  • a diferença entre o esperado e o atual.

Como enviar um bom pedido com screenshot

Inclua quatro elementos:

  1. Localização
    “No cartão superior direito...”

  2. Problema atual
    “O texto sobrepõe o botão...”

  3. Resultado esperado
    “O título deve quebrar em até duas linhas...”

  4. Limite da mudança
    “Não altere os demais cartões...”

A captura de tela é como um painel de diagnóstico.

Ela ajuda, mas ainda precisa de interpretação.

Um alerta no console da Enterprise não diz sozinho qual decisão o capitão deve tomar.


Capítulo 8 — Banco de dados apenas quando houver motivo

Muitos projetos de Vibe Coding começam com uma infraestrutura maior do que o próprio problema.

Antes de validar a funcionalidade, o criador já possui:

  • banco relacional;

  • autenticação;

  • funções serverless;

  • APIs;

  • triggers;

  • filas;

  • armazenamento;

  • regras de acesso;

  • painel administrativo.

Ele passa dias configurando tecnologia e quase nenhum tempo testando se alguém precisa da aplicação.

Para um protótipo, muitas vezes é suficiente utilizar:

  • dados simulados;

  • arquivo JSON;

  • armazenamento local;

  • planilha;

  • estrutura temporária em memória.

O banco de dados passa a ser necessário quando precisamos:

  • persistir dados entre dispositivos;

  • trabalhar com vários usuários;

  • controlar permissões;

  • relacionar entidades;

  • processar volumes maiores;

  • manter histórico;

  • garantir consistência.

Exemplo prático

Considere um diário de estudos.

Na primeira versão, o navegador pode armazenar:

Assunto
Categoria
Data
Nível de confiança
Observação

Se o usuário utiliza somente um computador, isso pode ser suficiente para validar a ideia.

Mais tarde, ao precisar acessar pelo celular e pelo desktop, um banco remoto passa a fazer sentido.

A regra é simples:

Adicione complexidade quando ela resolver um problema real, não quando parecer tecnologicamente elegante.


Capítulo 9 — A IA também pode modelar dados errado

A inteligência artificial pode criar uma tabela em segundos.

Isso não significa que a estrutura esteja correta.

Imagine uma tabela:

TAREFAS
ID
USUARIO
CLIENTE
TITULO
STATUS
PRAZO
OBSERVACAO

Para uma demonstração, pode funcionar.

Mas, se vários clientes possuem muitas tarefas, provavelmente teremos entidades separadas:

USUARIOS
CLIENTES
TAREFAS

Agora surgem perguntas importantes:

  • qual é a chave de cada tabela?

  • uma tarefa pode existir sem cliente?

  • o que acontece quando um cliente é excluído?

  • precisamos guardar histórico?

  • o status possui valores controlados?

  • uma tarefa pertence a um ou mais usuários?

  • informações antigas podem ser alteradas?

Essas decisões continuam existindo.

Vibe Coding não revogou normalização, integridade referencial ou consistência transacional.

No mundo mainframe, ninguém trataria a estrutura de um arquivo VSAM ou uma tabela Db2 como detalhe decorativo.

Dados são o coração do sistema.

A interface pode mudar.

A tecnologia pode mudar.

Mas um dado mal modelado costuma assombrar o projeto por muitos anos.


Capítulo 10 — Segurança: o campo minado escondido

Aplicações geradas rapidamente podem conter vulnerabilidades sérias.

Entre os problemas mais frequentes estão:

  • chaves de API expostas;

  • senhas armazenadas de forma inadequada;

  • ausência de validação no servidor;

  • acesso aos dados de outros usuários;

  • permissões excessivas;

  • informações pessoais em logs;

  • upload de arquivos sem controle;

  • dependências vulneráveis;

  • consultas inseguras.

A interface pode parecer maravilhosa enquanto o sistema possui uma porta aberta no casco da nave.

Nunca aceite uma declaração genérica como:

“A aplicação está segura.”

Peça explicações concretas:

Onde os segredos são armazenados?

Alguma chave é enviada para o navegador?

Como um usuário é impedido de acessar dados de outro?

A validação ocorre apenas na tela ou também no servidor?

Existe proteção contra envio duplicado?

Quais informações aparecem nos logs?

Como os dados são excluídos?

Quais bibliotecas foram instaladas?

Para sistemas que lidam com pagamentos, saúde, dados pessoais, documentos ou credenciais, a revisão humana especializada é indispensável.

A IA pode acelerar o trabalho.

Ela não pode assumir legalmente a responsabilidade pelo vazamento.


Capítulo 11 — Teste o usuário real, não o usuário imaginário

A IA costuma demonstrar o caminho perfeito:

  1. o usuário preenche tudo corretamente;

  2. clica uma vez;

  3. a conexão está estável;

  4. o banco responde;

  5. a operação termina.

Usuários reais fazem coisas muito mais interessantes.

Eles:

  • deixam campos vazios;

  • digitam texto em campos numéricos;

  • clicam duas vezes;

  • perdem a conexão;

  • voltam pelo navegador;

  • abrem várias abas;

  • colam textos enormes;

  • utilizam caracteres especiais;

  • fecham a tela no meio da operação.

Por isso, teste pelo menos os seguintes cenários.

Caminho feliz

Dados válidos, fluxo normal e resultado esperado.

Entrada inválida

Campos vazios, números negativos, datas impossíveis e formatos errados.

Repetição

Cliques duplos, envio repetido e atualização da página.

Interrupção

Falha de rede, erro do servidor ou fechamento inesperado.

Permissão

Tentativa de acessar recursos de outro usuário.

Persistência

Verificação de que os dados permanecem corretos após reiniciar.

Responsividade

Teste em computador, tablet e celular.

Volume

Teste com dez, cem e mil registros, quando fizer sentido.

O programa não está pronto porque funcionou uma vez.

Ele começa a merecer confiança quando continua funcionando diante de comportamentos imperfeitos.


Capítulo 12 — Controle de versão: o botão de voltar no tempo

Uma das práticas mais importantes no desenvolvimento é o controle de versão.

Ferramentas como Git permitem registrar o estado do projeto ao longo do tempo.

Antes de uma mudança importante, você cria um ponto de recuperação.

Se algo quebrar, pode comparar versões ou retornar.

Sem controle de versão, o fluxo costuma ser:

projeto-final
projeto-final-2
projeto-final-agora-vai
projeto-final-correto
projeto-final-correto-mesmo
projeto-final-correto-mesmo-ultimo

Esse sistema de nomes funciona apenas até o dia em que ninguém lembra qual versão realmente funcionava.

No Vibe Coding, o controle de versão é ainda mais importante porque agentes podem alterar vários arquivos rapidamente.

Uma boa instrução é:

Antes de modificar, informe quais arquivos serão alterados. Faça a mudança em uma etapa isolada e gere um resumo ao final.

E, idealmente:

Crie um commit antes da alteração.

Mesmo quem está começando deve aprender pelo menos:

git init
git status
git add .
git commit -m "Versão inicial funcional"

Isso já cria uma rede de segurança.

Na Frota Estelar, antes de testar uma dobra experimental, alguém certamente registra o estado dos sistemas. Pelo menos deveria.


Capítulo 13 — Publicar cedo, mas não de maneira irresponsável

Manter o projeto para sempre no computador impede o aprendizado real.

O usuário precisa testar.

A publicação revela problemas que não aparecem no ambiente local:

  • lentidão;

  • diferenças de navegador;

  • falhas de configuração;

  • permissões;

  • erros de rota;

  • comportamento em dispositivos móveis;

  • custos inesperados.

Entretanto, publicar cedo não significa lançar um sistema inseguro para milhares de pessoas.

Uma estratégia sensata é:

  1. testar localmente;

  2. compartilhar com uma pessoa;

  3. corrigir problemas graves;

  4. liberar para cinco usuários;

  5. observar o uso;

  6. coletar feedback;

  7. estabilizar;

  8. ampliar gradualmente.

Essa abordagem é chamada de liberação progressiva.

Ela reduz risco e melhora o aprendizado.

Tenha um plano de reversão

Antes de publicar, responda:

  • como volto para a versão anterior?

  • existe backup?

  • onde os erros serão registrados?

  • quem será avisado em caso de falha?

  • consigo desativar a funcionalidade?

  • os dados serão preservados durante a reversão?

Publicar sem rollback é como entrar em dobra sem saber como reduzir a velocidade.

Pode funcionar.

Mas você não quer descobrir o contrário perto de uma estrela.


Capítulo 14 — Feedback real vale mais que elogio educado

Depois que os primeiros usuários testarem, não pergunte apenas:

“Você gostou?”

Quase todos responderão “sim”.

Perguntas melhores são:

Em que momento você ficou confuso?

O que esperava que acontecesse ao clicar?

Qual etapa demorou mais?

Que tarefa você ainda precisou fazer fora da aplicação?

Qual parte parece desnecessária?

Você usaria isso novamente amanhã?

O objetivo não é receber aplausos.

É descobrir atrito.

Talvez você tenha criado um painel sofisticado com gráficos, enquanto os usuários realmente desejam um botão simples para duplicar o registro anterior.

O usuário real frequentemente destrói nossas teorias em menos de cinco minutos.

E isso é ótimo.

Cada hipótese destruída cedo economiza meses de trabalho na direção errada.


Capítulo 15 — O programador COBOL possui uma vantagem secreta

À primeira vista, Vibe Coding parece pertencer apenas ao universo de JavaScript, aplicações web e startups.

Mas programadores COBOL possuem uma vantagem enorme.

Eles estão acostumados a pensar em:

  • regras de negócio;

  • processamento confiável;

  • validação;

  • dados;

  • impacto de alterações;

  • transações;

  • recuperação;

  • produção;

  • manutenção de longo prazo.

Um programador COBOL sabe que o valor do sistema não está apenas na sintaxe.

Não é o MOVE, o PERFORM ou o EVALUATE que sustenta um banco.

É o entendimento do processo.

Da mesma forma, no Vibe Coding, saber pedir código é apenas uma parte.

O verdadeiro diferencial é saber:

  • o que deve ser construído;

  • o que não deve ser construído;

  • qual regra não pode falhar;

  • qual dado precisa ser protegido;

  • qual cenário precisa ser testado;

  • qual alteração pode afetar outra rotina.

O Padawan COBOL que aprende a utilizar IA sem abandonar seus fundamentos pode se tornar um profissional extremamente poderoso.

Ele combina:

  • experiência de negócio;

  • disciplina de sistemas críticos;

  • conhecimento de dados;

  • capacidade de modernização;

  • velocidade de ferramentas generativas.

É quase como instalar motores de dobra em uma nave construída para sobreviver décadas.


Capítulo 16 — Exemplo completo: COBOL Learning Log

Vamos construir mentalmente uma aplicação simples.

Problema

Estudantes de mainframe aprendem muitos assuntos, mas não acompanham o que já estudaram e o que precisa de revisão.

Público

Programadores COBOL iniciantes.

Objetivo

Registrar tópicos estudados e indicar o nível de confiança.

Funcionalidade principal

Cadastrar e consultar tópicos de estudo.

Dados mínimos

  • assunto;

  • categoria;

  • data;

  • nível de confiança;

  • observação.

Categorias

  • COBOL;

  • JCL;

  • Db2;

  • CICS;

  • VSAM;

  • z/OS.

Fora do escopo inicial

  • login;

  • pagamentos;

  • certificados;

  • chat;

  • integração com cursos;

  • ranking;

  • gamificação;

  • IA recomendando conteúdo.

Prompt inicial

Ajude-me a criar uma aplicação web responsiva chamada COBOL Learning Log, destinada a estudantes iniciantes de mainframe. O problema é que eles estudam vários tópicos, mas não possuem uma visão clara do que aprenderam e do que precisa de revisão.

A primeira versão deve permitir cadastrar um tópico contendo nome, categoria, data de estudo, nível de confiança de 1 a 5 e observação opcional. A tela inicial deve listar os registros e permitir filtro por categoria.

Não implemente login, pagamentos, certificados, compartilhamento, chat ou integração com IA.

Antes de gerar código, apresente a arquitetura mais simples, o fluxo do usuário, as telas, a estrutura dos dados, as validações, os testes e a estratégia de publicação.

Utilize armazenamento local inicialmente. Faça no máximo cinco perguntas caso alguma decisão seja indispensável.

Critérios de aceitação

  • assunto obrigatório;

  • categoria obrigatória;

  • nível entre 1 e 5;

  • data não pode estar no futuro;

  • dados permanecem após atualizar;

  • filtro funciona corretamente;

  • exclusão exige confirmação;

  • interface funciona no celular.

Perceba como o projeto deixou de ser uma ideia vaga.

Agora temos uma missão clara, critérios objetivos e fronteiras definidas.


Capítulo 17 — O ciclo Bellacosa de Vibe Coding

Um fluxo seguro pode seguir dez etapas.

1. Descrever

Explique o problema e o público.

2. Limitar

Escolha uma única funcionalidade principal.

3. Planejar

Peça arquitetura, telas e dados antes do código.

4. Questionar

Investigue suposições, riscos e custos.

5. Construir

Implemente uma parte pequena.

6. Executar

Teste no ambiente real.

7. Observar

Compare o resultado com os critérios.

8. Corrigir

Faça uma mudança por vez.

9. Publicar

Disponibilize para poucos usuários.

10. Aprender

Use o feedback para decidir o próximo passo.

Depois, repita.

Esse ciclo é muito mais importante do que qualquer ferramenta específica.

Ferramentas mudam.

Modelos mudam.

Plataformas surgem e desaparecem.

O processo continua válido.


Capítulo 18 — Um prompt mestre para sua próxima missão

Utilize este modelo:

Atue como analista de produto, arquiteto de software, desenvolvedor e testador responsável.

Ajude-me a criar um aplicativo para [PÚBLICO] resolver [PROBLEMA].

O resultado principal esperado é [RESULTADO].

Antes de gerar código:

  1. reescreva o problema de forma objetiva;

  2. identifique dúvidas e suposições;

  3. proponha um MVP com uma única funcionalidade central;

  4. liste o que ficará fora da primeira versão;

  5. recomende a ferramenta mais simples;

  6. descreva o fluxo do usuário;

  7. proponha as telas;

  8. modele os dados mínimos;

  9. liste validações;

  10. identifique riscos de segurança;

  11. crie critérios de aceitação;

  12. prepare casos de teste;

  13. explique a publicação;

  14. defina uma estratégia de rollback.

Não acrescente funcionalidades sem minha autorização.

Durante a implementação, faça uma mudança por vez, informe quais arquivos serão alterados e preserve tudo o que já estiver funcionando.

Esse prompt não garante perfeição.

Mas cria um ambiente muito mais controlado.


Curiosidades do convés de engenharia

A IA não “entende” seu projeto como um colega humano

Ela trabalha a partir do contexto disponível.

Quando informações faltam, ela pode completar as lacunas com padrões estatísticos.

Isso significa que uma resposta convincente pode conter uma decisão errada.

Código bonito não significa código correto

Uma interface elegante pode esconder:

  • regra incorreta;

  • falha de segurança;

  • cálculo errado;

  • dados inconsistentes;

  • dependência problemática.

O protótipo é uma pergunta, não uma resposta

Seu objetivo inicial não é provar que a ideia é genial.

É descobrir se ela resolve um problema.

A complexidade cobra juros

Cada banco, integração, serviço e dependência adiciona custo de manutenção.

O usuário raramente pede aquilo de que realmente precisa

Ele pode pedir um gráfico.

Após observar seu trabalho, você descobre que ele precisava de um alerta.


Easter egg da Frota Estelar

Em muitas histórias de Star Trek, o computador da Enterprise parece capaz de executar quase qualquer ordem:

“Computador, analise a composição da atmosfera.”

“Computador, localize a nave.”

“Computador, simule o cenário.”

Mas observe um detalhe.

Os oficiais fazem perguntas específicas.

Eles informam parâmetros.

Eles verificam resultados.

Eles discordam do computador.

Eles cruzam dados.

Eles assumem o comando quando a situação muda.

A ficção nunca disse que possuir um computador poderoso eliminaria a necessidade de julgamento humano.

Na verdade, ela sugeriu o contrário.

Quanto mais poderosa a tecnologia, mais importante se torna a responsabilidade de quem a utiliza.

Vibe Coding é exatamente isso.

Temos acesso a uma espécie de computador de bordo capaz de criar sistemas em minutos.

A pergunta não é apenas:

“O que ele consegue construir?”

A pergunta mais importante é:

“Somos capazes de descrever corretamente o que deve ser construído?”


Conclusão — A IA é o motor de dobra, não o capitão

Vibe Coding representa uma transformação extraordinária.

Pessoas que nunca construíram software podem criar protótipos.

Programadores experientes podem acelerar tarefas repetitivas.

Empresas podem validar ideias em menos tempo.

Estudantes podem aprender observando código funcional.

Mas nenhum desses benefícios elimina os fundamentos.

Um bom sistema ainda exige:

  • clareza;

  • escopo;

  • análise;

  • validação;

  • testes;

  • segurança;

  • controle de versão;

  • observabilidade;

  • responsabilidade;

  • aprendizado contínuo.

A habilidade principal do futuro talvez não seja escrever cada linha manualmente.

Será saber conduzir máquinas capazes de escrevê-las.

O programador deixará de ser apenas quem produz instruções e se tornará cada vez mais quem:

  • define intenções;

  • estabelece limites;

  • avalia riscos;

  • verifica resultados;

  • protege usuários;

  • decide prioridades;

  • mantém coerência.

Para o Programador COBOL Padawan, isso não é uma ameaça.

É uma oportunidade histórica.

Você já conhece o valor da precisão.

Já sabe que uma pequena regra pode movimentar milhões.

Já aprendeu que sistemas vivem muito mais tempo do que a primeira versão imaginava.

Agora chegou o momento de levar essa disciplina para o universo da inteligência artificial.

Use a IA.

Explore.

Construa.

Publique.

Mas nunca abandone o painel de comando.

Porque, no final, não importa quantos agentes, modelos ou geradores estejam trabalhando na sala de máquinas.

Quando o alerta vermelho tocar, alguém ainda precisará sentar na cadeira do capitão e dizer:

“Computador, explique exatamente o que você alterou.”

E talvez acrescentar:

“Desta vez, sem mexer no módulo que já estava funcionando.”

Vibe on, Padawan. Mas mantenha o controle da nave.

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...