Translate

Mostrar mensagens com a etiqueta Claude Code. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Claude Code. Mostrar todas as mensagens

terça-feira, 2 de junho de 2026

O Que Todo Programador COBOL Padawan Precisa Saber Para Transformar um Chatbot em um Verdadeiro Ambiente de Engenharia de Software com Inteligência Artificial

 

Bellacosa Mainframe e 100 dicas do claude em uma pagina

☕ Um Café no Bellacosa Mainframe 

100 Dicas do Claude em Uma Página

O Que Todo Programador COBOL Padawan Precisa Saber Para Transformar um Chatbot em um Verdadeiro Ambiente de Engenharia de Software com Inteligência Artificial

"A maioria das pessoas conversa com uma IA. Os profissionais que realmente aumentam sua produtividade trabalham em parceria com ela."  


Introdução

Quando surgiram os primeiros assistentes de Inteligência Artificial, a maioria das pessoas acreditava que eles seriam apenas uma versão mais sofisticada de um mecanismo de busca.

Você fazia uma pergunta.

Recebia uma resposta.

Fim da conversa.

Era quase como consultar um manual técnico digital.

Mas a evolução dos LLMs (Large Language Models) mostrou que esse pensamento estava incompleto.

Hoje, ferramentas como Claude, ChatGPT, Gemini e outras deixaram de ser apenas sistemas de perguntas e respostas. Elas estão se transformando em plataformas completas de desenvolvimento, capazes de compreender projetos inteiros, escrever código, revisar arquitetura, automatizar tarefas, conectar-se a sistemas externos e colaborar como verdadeiros membros de uma equipe de engenharia.

Recentemente, circulou um infográfico chamado "100 Claude Tips in One Page", reunindo cem dicas organizadas em dez categorias. À primeira vista, parece apenas uma lista de atalhos. No entanto, ao analisá-lo com atenção, percebemos algo muito maior: ele descreve uma nova forma de trabalhar com IA.

Para quem vem do universo IBM Mainframe, isso pode soar familiar.

Durante décadas aprendemos que escrever um programa COBOL era apenas uma pequena parte do trabalho. Antes dele existiam JCLs, bibliotecas, catálogos, RACF, CICS, DB2, schedulers, padrões corporativos e processos de mudança.

Da mesma forma, usar um LLM de maneira profissional envolve muito mais do que escrever um prompt.

Neste artigo vamos explorar cada uma dessas ideias sob a ótica de um Programador COBOL Padawan, criando paralelos entre a engenharia tradicional do IBM Z e a nova engenharia baseada em Inteligência Artificial.

Pegue seu café.

A conversa de hoje promete.


O erro que quase todo iniciante comete

Imagine um desenvolvedor júnior chegando ao ambiente z/OS e perguntando:

"Onde eu escrevo meu COBOL?"

O analista sorri e responde:

"Antes disso precisamos criar o dataset, definir o PROC, configurar o JCL, preparar as bibliotecas, verificar o compilador e garantir as permissões RACF."

O novato fica surpreso.

Ele pensava que programar era apenas escrever código.

Com IA acontece exatamente o mesmo.

A maioria das pessoas faz algo assim:

Explique Docker.

Recebe uma resposta.

Abre outra conversa.

Pergunta novamente.

Tudo começa do zero.

Isso equivale a reinicializar um mainframe antes de cada JOB.

É desperdício.

Os usuários avançados trabalham de maneira completamente diferente.


Conversar não é trabalhar

Existe uma enorme diferença entre conversar com uma IA e trabalhar utilizando IA.

Veja dois cenários.

Usuário comum

Pergunta

↓

Resposta

↓

Nova pergunta

↓

Nova resposta

Cada conversa é isolada.

Nada é reaproveitado.

Todo contexto precisa ser reconstruído.


Usuário avançado

Projeto

↓

Documentação

↓

Memória

↓

Arquivos

↓

Ferramentas

↓

MCP

↓

Claude Code

↓

Subagentes

↓

Resultado Final

Agora existe continuidade.

Existe contexto.

Existe engenharia.

Esse é exatamente o conceito por trás das 100 dicas do Claude.


Categoria 1 — Setup: Preparando o Ambiente

Todo programador Mainframe sabe que um bom ambiente vale mais do que horas de retrabalho.

Antes de executar um programa precisamos preparar:

  • Bibliotecas

  • DDNAMEs

  • Catálogos

  • PROCs

  • Variáveis

  • Ambientes de teste

  • Permissões

No Claude acontece algo semelhante.

A preparação inicial define toda a qualidade das respostas futuras.

Escolhendo o modelo correto

Nem toda tarefa exige o modelo mais poderoso.

É como escolher entre:

  • IEBGENER

  • DFSORT

  • IDCAMS

Todos resolvem problemas diferentes.

Da mesma forma:

Um modelo rápido pode resumir documentos.

Outro modelo mais inteligente pode projetar uma arquitetura distribuída.

Saber quando utilizar cada um é uma habilidade importante.


Memória

Um dos recursos mais interessantes.

A memória não serve para armazenar documentos.

Ela serve para armazenar preferências.

Por exemplo:

Sempre explique utilizando exemplos IBM Mainframe.

Utilize linguagem técnica.

Evite excesso de marketing.

Faça analogias com COBOL.

Após algum tempo, Claude passa a produzir respostas muito mais alinhadas ao seu estilo.

É como possuir um analista que já conhece seu jeito de trabalhar.


Projects

Imagine criar um projeto chamado:

Bellacosa Mainframe

Dentro dele existem:

COBOL

JCL

DB2

IMS

VSAM

REXX

CICS

RACF

Arquitetura

Normas

Documentação

Sempre que iniciar uma conversa nesse projeto, Claude já conhece todo esse universo.

É semelhante a abrir um PDS contendo toda a documentação corporativa.


Categoria 2 — Prompt Engineering

Prompt Engineering talvez seja o equivalente moderno da especificação funcional.

Quanto melhor a especificação...

Melhor será a implementação.

Considere dois exemplos.

Prompt simples

Explique CICS.

Resultado?

Uma resposta genérica.

Agora veja este.

Explique CICS para um programador COBOL de banco.

Compare com Batch.

Utilize diagramas ASCII.

Mostre vantagens.

Mostre limitações.

Inclua exemplos reais.

Finalize com um resumo executivo.

A diferença é enorme.


Definindo papéis

Uma técnica extremamente poderosa.

Você pode pedir:

Atue como:

Arquiteto IBM

Professor Universitário

Sysprog

DBA

Especialista DevOps

Especialista em Segurança

Cada persona muda completamente a forma da resposta.

É semelhante a pedir opiniões para profissionais diferentes dentro da mesma empresa.


Definindo restrições

Claude trabalha melhor quando possui limites claros.

Exemplo:

Até 800 palavras.

Português técnico.

Sem emojis.

Markdown.

Inclua tabelas.

Não invente informações.

Sempre cite vantagens e riscos.

Curiosamente, limitar produz respostas melhores.


Categoria 3 — Claude Code

Agora começamos a entrar no território da engenharia de software.

Claude Code não é apenas um editor.

Ele pode:

  • Ler projetos inteiros

  • Executar testes

  • Refatorar código

  • Criar documentação

  • Gerenciar Git

  • Atualizar dependências

Imagine dizer:

Leia este projeto.

Encontre duplicações.

Refatore.

Execute os testes.

Atualize README.

Faça commit.

Isso está muito além de responder perguntas.


Plan Mode

Uma funcionalidade fantástica.

Antes de alterar qualquer arquivo, Claude pode apresentar um plano.

Semelhante ao CAB (Change Advisory Board).

Primeiro ele analisa.

Depois identifica riscos.

Depois propõe mudanças.

Somente então executa.

Isso reduz bastante erros.


Categoria 4 — CLAUDE.md

Se existe um recurso que lembra o mundo corporativo, é este.

CLAUDE.md funciona como um conjunto permanente de normas.

Por exemplo:

Sempre escreva testes.

Nunca utilize jQuery.

Explique arquitetura.

Comente funções públicas.

Use TypeScript.

Priorize Clean Code.

É semelhante aos padrões corporativos existentes em grandes bancos.

Todo projeto passa a seguir as mesmas regras automaticamente.


Categoria 5 — Artifacts

Artifacts representam uma mudança de paradigma.

Antes:

Explique como criar um dashboard.

Agora:

Crie um dashboard funcional.

Em vez de responder...

Claude gera:

  • HTML

  • CSS

  • JavaScript

  • SVG

  • React

  • Mermaid

  • Diagramas

  • Simuladores

É como pedir um programa COBOL e receber também o JCL, a documentação e os testes.


Versionamento

Cada alteração cria versões.

Quase um Git interno.

Isso permite experimentar ideias sem medo.


Categoria 6 — MCP — Model Context Protocol

Talvez a inovação mais importante dos últimos anos.

MCP pode ser comparado aos drivers universais da IA.

Sem MCP:

Claude

↓

Texto

Com MCP:

Claude

↓

GitHub

↓

Google Drive

↓

SQL

↓

Filesystem

↓

Slack

↓

ERP

↓

CRM

↓

APIs

Agora Claude deixa de conversar.

Ele passa a executar trabalho.


Pensando como um profissional IBM

Imagine um MCP para:

  • SDSF

  • JES2

  • RMF

  • SMF

  • DB2

  • IMS

  • CICS

  • RACF

Você poderia perguntar:

Qual JOB falhou ontem?

Mostre o LOG.

Analise o ABEND.

Explique a causa.

Sugira correções.

O potencial é gigantesco.


Categoria 7 — Cowork e Agentes

Aqui a IA deixa de ser individual.

Imagine criar especialistas.

Agente 1

Arquiteto

Agente 2

Programador COBOL

Agente 3

DBA DB2

Agente 4

Especialista RACF

Agente 5

Revisor Técnico

Todos colaborando.

É praticamente uma equipe virtual.


Categoria 8 — Power User

Chegamos ao nível avançado.

Aqui encontramos recursos que poucos usuários exploram.

Subagentes

Em vez de uma IA resolver tudo sozinha...

Ela divide o problema.

Projeto

↓

Arquitetura

↓

Backend

↓

Frontend

↓

Testes

↓

Documentação

↓

Integração

Cada agente trabalha de forma especializada.

Depois os resultados são consolidados.

Isso lembra muito o paralelismo do IBM Z.


Hooks

Hooks funcionam como gatilhos.

Sempre que determinada ação ocorrer...

Outra ação é executada automaticamente.

Exemplo:

Salvar código

↓

Executar testes

↓

Atualizar documentação

↓

Verificar segurança

↓

Executar lint

↓

Atualizar CHANGELOG

É automação pura.


A filosofia por trás das 100 dicas

O maior ensinamento desse infográfico não é ensinar comandos.

É ensinar mentalidade.

A pergunta deixa de ser:

"Como faço uma pergunta melhor?"

E passa a ser:

"Como construo um ambiente onde a IA trabalhe continuamente ao meu lado?"

Essa mudança é profunda.


Paralelos com o IBM Mainframe

Vamos resumir essa comparação.

IBM MainframeClaude
JCLPrompt estruturado
PROCTemplates
DatasetContexto
PDSProjects
SYSINPrompt
JES2Orquestração
SchedulerAutomação
RACFPermissões
DB2Conhecimento estruturado
UtilitiesFerramentas
Change ManagementPlan Mode
Normas CorporativasCLAUDE.md
Equipe TécnicaAgentes

Perceba que praticamente todos os conceitos clássicos continuam existindo.

Mudou apenas a interface.

Agora ela é conversacional.


O impacto para um Programador COBOL Padawan

Durante muitos anos ouvimos que o COBOL seria substituído.

Depois disseram que o Mainframe desapareceria.

Mais recentemente, passaram a afirmar que a Inteligência Artificial substituiria os programadores.

Nenhuma dessas previsões se concretizou da forma anunciada.

O que realmente aconteceu foi uma evolução das ferramentas.

Assim como um compilador COBOL evoluiu, os ambientes de desenvolvimento evoluíram e os pipelines de integração contínua se tornaram padrão, os LLMs estão se tornando mais uma camada da engenharia de software.

Para o Programador COBOL Padawan, isso representa uma oportunidade extraordinária.

Imagine acelerar tarefas como:

  • geração de documentação técnica;

  • explicação de programas legados;

  • criação de casos de teste;

  • revisão de código COBOL;

  • análise de JCLs;

  • conversão de layouts Copybook para JSON;

  • criação de APIs REST para sistemas CICS;

  • preparação de apresentações técnicas;

  • produção de artigos, treinamentos e material didático.

A IA não elimina o conhecimento do especialista. Pelo contrário, amplia sua capacidade de produzir e compartilhar conhecimento.

Quem domina fundamentos de arquitetura, modelagem de dados, sistemas transacionais e processos críticos — características típicas do ecossistema IBM Z — possui uma vantagem significativa ao trabalhar com essas novas ferramentas. Afinal, a IA precisa de contexto, critérios e boas decisões, e esses elementos continuam sendo responsabilidade do profissional.


Conclusão — O verdadeiro diferencial está na engenharia, não na ferramenta

As "100 Claude Tips" são muito mais do que uma coleção de atalhos. Elas representam um mapa de maturidade para quem deseja extrair valor real da Inteligência Artificial.

No início, usamos a IA como uma calculadora sofisticada.

Depois, como um mecanismo de busca conversacional.

Em seguida, como um assistente de programação.

Mas o próximo passo já está acontecendo: transformar a IA em um ambiente integrado de engenharia, capaz de compreender projetos, seguir padrões corporativos, colaborar com equipes, acessar ferramentas externas, automatizar processos e participar ativamente do ciclo de desenvolvimento.

Para quem vive o universo IBM Mainframe, essa evolução não é estranha. Há décadas trabalhamos com orquestração, padronização, bibliotecas compartilhadas, controle de mudanças, segurança, automação e integração entre sistemas. Os conceitos permanecem os mesmos; o que muda é a interface, agora baseada em linguagem natural.

O Programador COBOL Padawan que compreender essa mudança deixará de enxergar o Claude apenas como um chatbot. Passará a vê-lo como um novo membro da equipe: um analista que nunca se cansa de revisar código, um arquiteto que ajuda a avaliar alternativas, um redator técnico incansável, um testador disciplinado e um parceiro de aprendizado contínuo.

No fim das contas, o maior segredo não está em conhecer as cem dicas individualmente. Está em entender que elas formam um ecossistema. Memória, Projects, Prompt Engineering, Claude Code, CLAUDE.md, Artifacts, MCP, Agentes e automações são peças de uma mesma arquitetura.

E arquiteturas bem projetadas sempre foram a especialidade dos profissionais de Mainframe.

Talvez seja por isso que nós, veteranos do IBM Z, estejamos tão bem posicionados para liderar essa nova era da Inteligência Artificial.

Porque, no fundo, continuamos fazendo o que sempre fizemos: projetar sistemas confiáveis, organizar conhecimento e transformar complexidade em soluções elegantes. A diferença é que, agora, temos um novo colega de trabalho sentado ao nosso lado — e ele atende pelo nome de Claude.

quinta-feira, 30 de abril de 2026

🚀 Introdução ao DIO Agent: Seu Parceiro de Jornada

 

Bellacosa Mainframe e os primeiros passos no DIO Agent

🚀 Introdução ao DIO Agent: Seu Parceiro de Jornada

Se existe uma palavra que define a evolução atual da Inteligência Artificial aplicada ao aprendizado, essa palavra é Agente.

O DIO Agent não é apenas um chatbot tradicional que responde perguntas. Ele representa uma nova geração de assistentes inteligentes capazes de compreender contexto, executar tarefas, auxiliar na tomada de decisões e personalizar a experiência de aprendizagem.

Ao longo desta trilha, o aluno deixa de usar a IA apenas como uma ferramenta de consulta e passa a utilizá-la como um verdadeiro copiloto de estudos, capaz de acelerar sua evolução técnica e profissional.


📖 O Que é um Agente de IA?

Antes de entender o DIO Agent, precisamos compreender o conceito de agente.

Um modelo de IA tradicional funciona assim:

Pergunta → Resposta

Já um agente funciona como:

Objetivo → Planejamento → Execução → Resultado

Em outras palavras, ele não apenas responde.

Ele:

  • Analisa o contexto

  • Entende a intenção

  • Planeja ações

  • Utiliza ferramentas

  • Produz resultados

É exatamente por isso que os agentes são considerados a próxima grande revolução da IA.


🤖 O Que é o DIO Agent?

O DIO Agent é um assistente inteligente integrado ao ecossistema da DIO (Digital Innovation One).

Seu objetivo principal é atuar como:

  • Tutor

  • Mentor

  • Instrutor

  • Organizador de estudos

  • Explicador de conceitos

  • Facilitador de desafios

Ele foi criado para reduzir uma das maiores dores dos estudantes de tecnologia:

"Eu não sei por onde começar."

ou

"Estou travado e não consigo avançar."


🎯 O Problema Que o DIO Agent Resolve

Muitos alunos enfrentam dificuldades como:

Excesso de conteúdo

Há milhares de cursos, vídeos e artigos.

O aluno frequentemente se pergunta:

  • O que estudar primeiro?

  • O que é mais importante?

  • Qual tecnologia aprender?


Síndrome da Página em Branco

Quando chega a hora de fazer um projeto:

  • Não sabe como começar

  • Não sabe estruturar o código

  • Não entende o desafio


Conceitos Complexos

Muitos conteúdos técnicos possuem linguagem difícil.

Exemplos:

  • APIs

  • Microsserviços

  • Kubernetes

  • Mainframe

  • IA Generativa

O DIO Agent ajuda traduzindo conceitos complexos para exemplos simples.


🧠 Por Que Isso é Revolucionário?

Historicamente o aprendizado acontecia em três fases:

Era dos Livros

Você precisava procurar a informação.


Era do Google

Você precisava descobrir onde estava a informação.


Era dos Agentes

A informação encontra você.

Além disso:

  • É contextualizada

  • Personalizada

  • Adaptada ao seu nível


🔧 Passo 1: Instale um Harness

Uma das partes mais interessantes da trilha.

Muitos alunos instalam o DIO Agent sem entender o papel do Harness.


O Que é um Harness?

Harness é uma infraestrutura que conecta a IA ao ambiente onde ela irá trabalhar.

Podemos fazer uma analogia simples.

Imagine:

  • O DIO Agent é o motorista.

  • O Harness é o carro.

Sem o carro, o motorista não consegue se mover.

Sem o Harness, o agente não consegue interagir com o ambiente.


O Papel do Harness

Ele funciona como uma camada intermediária responsável por:

  • Comunicação

  • Segurança

  • Integração

  • Execução

Ele permite que o agente:

  • Leia informações

  • Execute comandos

  • Acesse recursos


Analogia Mainframe

Pensando no mundo IBM Mainframe:

O Harness seria semelhante a:

  • TSO

  • ISPF

  • CICS

  • z/OSMF

Esses ambientes permitem que o usuário interaja com o sistema.

O agente também precisa de uma "ponte" semelhante.


🔌 Passo 2: Configure o DIO Agent

Após instalar o Harness, vem a etapa mais importante:

A configuração.


Por Que Configurar?

Uma IA genérica conhece o mundo.

Uma IA configurada conhece o seu contexto.

Isso faz toda diferença.


Exemplo

Pergunta:

Como faço um programa COBOL?

Resposta genérica:

"Utilize as divisões Identification, Environment, Data e Procedure."

Resposta contextualizada:

"Como você trabalha com z/OS, utilize compilação IGYCRCTL e considere integração com DB2."

Percebe a diferença?


🧩 O Poder do Contexto

Quanto mais contexto o agente recebe:

  • Melhor ele entende

  • Melhor ele responde

  • Mais valor ele entrega

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


🎯 Personalização

O DIO Agent pode adaptar respostas para:

Nível de conhecimento

  • Iniciante

  • Intermediário

  • Avançado


Objetivo

  • Conseguir emprego

  • Passar em certificações

  • Aprender programação

  • Fazer projetos


Área

  • Front-End

  • Back-End

  • Cloud

  • Dados

  • IA

  • Mainframe


🧪 Passo 3: Hands-On

Aqui acontece a transformação.

Você deixa de aprender sobre IA e passa a trabalhar com ela.


Skill: Plano de Estudos

Uma das funcionalidades mais poderosas.


O Que Faz?

Cria roteiros personalizados.

Exemplo:

Quero aprender COBOL em 90 dias.

O agente pode criar:

Semana 1

  • História do COBOL

  • Estrutura do programa

Semana 2

  • Variáveis

  • PIC

Semana 3

  • Arquivos VSAM

Semana 4

  • DB2

E assim por diante.


Benefício

Evita o famoso:

"Estudo um pouco de tudo e não aprendo nada."


Skill: Destravar Desafios de Projeto

Muitos alunos travam quando encontram:

  • Projeto final

  • Hackathon

  • Desafio técnico


Como o Agent Ajuda?

Ele não entrega a resposta pronta.

Ele ajuda a:

  • Entender requisitos

  • Dividir problemas

  • Planejar etapas

  • Identificar riscos


Analogia Mainframe

É semelhante ao papel de um analista sênior orientando um programador júnior.

O sênior não faz o trabalho.

Ele mostra o caminho.


Skill: Entenda os Desafios de Código

Outra funcionalidade extremamente importante.


O Problema

Muitos alunos leem um desafio e pensam:

"Não entendi o que estão pedindo."

O problema não é programação.

É interpretação.


O Que o Agent Faz?

Ele ajuda a:

  • Explicar o enunciado

  • Identificar entradas

  • Identificar saídas

  • Criar exemplos


Exemplo

Desafio:

"Receba dois números e retorne sua soma."

O agente pode explicar:

Entrada:

5
7

Saída:

12

Skill: Explicar Conceitos

Talvez a funcionalidade mais poderosa.


O Que Faz?

Transforma conceitos complexos em exemplos simples.


Exemplo Kubernetes

Explicação técnica:

"Orquestrador de containers."

Explicação simplificada:

"Imagine um gerente de restaurante que distribui garçons entre as mesas conforme a demanda."


Exemplo Mainframe

CICS:

"Monitor transacional."

Analogia:

"Uma central telefônica que recebe milhares de chamadas e direciona cada uma ao atendente correto."


🧠 O Verdadeiro Valor do DIO Agent

Muitos pensam que IA serve para responder perguntas.

Isso é apenas a superfície.

O verdadeiro valor está em:

  • Acelerar aprendizado

  • Reduzir frustração

  • Organizar conhecimento

  • Personalizar experiências

  • Aumentar produtividade


☕ Bellacosa Mainframe: O Que Isso Significa Para o Profissional de Mainframe?

Para quem trabalha com:

  • COBOL

  • JCL

  • DB2

  • CICS

  • IMS

  • RACF

  • z/OS

O DIO Agent pode atuar como:

Consultor Técnico

"Explique o funcionamento do DFHCOMMAREA."


Tutor

"Monte um plano de estudos para aprender CICS em 60 dias."


Revisor

"Analise este programa COBOL."


Especialista em Performance

"Como otimizar este SQL DB2?"


Mentor de Carreira

"Quais competências um Analista Mainframe precisa desenvolver em 2026?"


🔮 O Futuro: De Assistentes para Agentes Autônomos

Estamos entrando em uma nova era.

Primeira geração:

  • Google

Segunda geração:

  • Chatbots

Terceira geração:

  • Copilotos

Quarta geração:

  • Agentes Autônomos

O DIO Agent é uma porta de entrada para esse universo.

Quem aprender a trabalhar com agentes hoje estará desenvolvendo uma das competências mais valiosas da próxima década.


Conclusão

A trilha "Configurando o DIO Agent: Seu Parceiro de Jornada" não ensina apenas a instalar uma ferramenta. Ela apresenta uma mudança profunda na forma como aprendemos tecnologia.

O aluno aprende que a IA moderna não é apenas um mecanismo de perguntas e respostas. Ela pode atuar como mentora, instrutora, planejadora, revisora e facilitadora do aprendizado.

Para profissionais de Mainframe, essa transformação é ainda mais relevante. Imagine ter um assistente capaz de explicar JES2, sugerir melhorias em JCL, revisar SQL DB2, criar laboratórios de CICS ou montar trilhas completas de estudo em z/OS. O DIO Agent representa exatamente esse conceito: uma IA especializada em potencializar o conhecimento humano.

Como costumo dizer em minhas aulas:

"O futuro não pertence a quem sabe tudo. Pertence a quem sabe trabalhar em parceria com a Inteligência Artificial."

E o DIO Agent é um excelente primeiro passo nessa jornada. ☕🚀🤖



********************************************************************************************************************************************

DIO Agent

O DIO Agent é um assistente inteligente baseado em Inteligência Artificial que auxilia estudantes e profissionais de tecnologia na criação de planos de estudo, explicação de conceitos técnicos, resolução de desafios de código e aceleração da aprendizagem.

Agentes de Inteligência Artificial

Os agentes de IA representam a evolução dos chatbots tradicionais, oferecendo capacidade de planejamento, execução de tarefas, uso de ferramentas e personalização da experiência do usuário.

Harness para Agentes

Harness é a infraestrutura responsável por conectar o agente ao ambiente operacional, permitindo integração com ferramentas, execução de comandos e interação com recursos externos.

Tecnologias Relacionadas

Claude Code, Google Antigravity, Hermes, OpenHands, Continue.dev, Roo Code, Cline, Cursor, GitHub Copilot, Gemini CLI, Engenharia de Prompt, IA Generativa e Automação Inteligente.

Público-Alvo

Desenvolvedores, estudantes de programação, profissionais de Mainframe, especialistas em COBOL, CICS, DB2, JCL, RACF, z/OS, arquitetos de software, analistas de sistemas e entusiastas de Inteligência Artificial.


********************************************************************************************************************************************
☕ Bellacosa Mainframe • COBOL • CICS • DB2 • JCL • RACF • z/OS • IA Generativa

quarta-feira, 26 de fevereiro de 2025

Pare de Escrever Prompts. Comece a Construir Skills.

 

Bellacosa Mainframe truques para ir mais longe em ia

☕ Um Café no Bellacosa Mainframe

Pare de Escrever Prompts. Comece a Construir Skills.

O Que Todo Programador COBOL Padawan Precisa Saber Sobre a Próxima Evolução da Inteligência Artificial

"No início aprendemos comandos. Depois aprendemos linguagens. Em seguida construímos APIs. Agora estamos entrando na era em que ensinamos a Inteligência Artificial a trabalhar como um especialista."

Existe uma frase que tem aparecido cada vez mais entre desenvolvedores que utilizam Inteligência Artificial no dia a dia:

"Stop prompting Claude manually. Let Skills do it for you."

À primeira vista, parece apenas mais um slogan de marketing. Mas, na realidade, essa frase representa uma das maiores mudanças na forma como desenvolveremos software durante os próximos anos.

Se você é um Programador COBOL Padawan, provavelmente já percebeu que escrever um bom prompt pode ser trabalhoso. Toda vez é necessário explicar o contexto, informar a arquitetura, definir padrões, especificar tecnologias, lembrar convenções de nomenclatura, pedir documentação, solicitar testes e revisar o resultado.

Mas... e se todo esse conhecimento pudesse ser reutilizado?

É exatamente isso que as Skills fazem.

E, curiosamente, para quem trabalha com Mainframe, esse conceito é muito mais familiar do que parece.

Pegue seu café. Hoje vamos conversar sobre por que as Skills podem ser consideradas a próxima grande revolução da Engenharia de Software baseada em Inteligência Artificial.


A evolução da programação

Vamos fazer uma pequena viagem no tempo.

Na década de 1950 praticamente tudo era escrito em linguagem de máquina.

Cada instrução precisava ser codificada manualmente.

Depois surgiram os Assemblys.

Mais tarde vieram linguagens de alto nível como COBOL, FORTRAN e PL/I.

Na década de 70 surgiram bibliotecas reutilizáveis.

Nos anos 80 vieram as sub-rotinas compartilhadas.

Depois apareceram frameworks.

APIs.

Microserviços.

Containers.

Cloud.

Agentes de IA.

E agora...

Skills.

Cada etapa teve um objetivo:

Evitar reinventar a roda.

As Skills levam exatamente essa filosofia para a Inteligência Artificial.


O problema dos prompts gigantes

Imagine pedir ao Claude:

Desenvolva uma API Java usando Spring Boot 3.5, Java 21, PostgreSQL, JWT, Swagger, arquitetura hexagonal, DDD, testes JUnit, integração com Docker, documentação OpenAPI e siga os padrões Clean Code da empresa.

Na primeira vez funciona.

Na segunda também.

Na terceira...

Você percebe que está copiando o mesmo prompt enorme.

Todos os dias.

Isso é desperdício.

É como escrever toda a rotina de cálculo de juros dentro de cada programa COBOL.

Nenhum programador experiente faria isso.

Ele criaria uma rotina reutilizável.


A analogia perfeita para quem programa COBOL

Imagine um sistema bancário.

Você precisa validar um CPF.

Poderia escrever centenas de linhas.

Ou simplesmente fazer:

CALL 'CPFVALID'

Precisa calcular juros?

CALL 'CALCJUROS'

Precisa gravar auditoria?

CALL 'LOGAUDIT'

O programa não precisa conhecer os detalhes.

Ele apenas utiliza um módulo especializado.

As Skills funcionam exatamente assim.

Só que, em vez de encapsular código, elas encapsulam inteligência.


Então... o que é uma Skill?

Muitos acreditam que uma Skill é apenas um prompt salvo.

Isso está longe da realidade.

Uma Skill pode conter:

  • Prompt especializado

  • Conhecimento técnico

  • Exemplos Few-Shot

  • Ferramentas

  • MCPs

  • APIs

  • Memória

  • Fluxos de decisão

  • Templates

  • Regras corporativas

  • Boas práticas

  • Padrões arquiteturais

Na prática, ela funciona como um especialista virtual.

Você não conversa mais com uma IA genérica.

Você conversa com um especialista treinado para resolver exatamente aquele problema.


Imagine um Programador COBOL dentro da IA

Pense em um profissional com trinta anos de experiência em Mainframe.

Ele conhece:

  • COBOL

  • CICS

  • DB2

  • VSAM

  • JCL

  • RACF

  • MQ

  • JES2

  • SDSF

  • SMF

Agora imagine transformar toda essa experiência em uma Skill.

Sempre que alguém precisar analisar um programa COBOL, basta chamar:

COBOL Senior Reviewer

Ela já sabe:

  • padrões IBM

  • performance

  • boas práticas

  • otimização

  • compatibilidade

  • segurança

Sem precisar explicar tudo novamente.


Development / Tech

A primeira categoria apresentada na imagem talvez seja a mais impressionante.

Ela mostra como a IA está deixando de ser apenas um gerador de código para se tornar um verdadeiro membro da equipe de desenvolvimento.


1. Autonomous Coding Agent

Até pouco tempo atrás dizíamos:

Escreva uma função.

Hoje podemos dizer:

Desenvolva todo o sistema.

A Skill analisa requisitos.

Planeja.

Escolhe arquitetura.

Implementa.

Executa testes.

Refatora.

Documenta.

Corrige problemas.

Tudo automaticamente.

É praticamente um desenvolvedor digital.


Imagine isso no Mainframe

Você informa:

"Precisamos modernizar este sistema COBOL."

A Skill poderia:

Analisar milhares de programas.

Localizar dependências.

Encontrar COPYBOOKS.

Gerar documentação.

Descobrir programas mortos.

Mapear chamadas.

Produzir diagramas.

Criar APIs REST.

Gerar testes.

Tudo isso sem intervenção humana.

Isso não é ficção.

Já existem ferramentas caminhando exatamente nessa direção.


2. MCP Server Builder

Aqui entramos em um conceito extremamente importante.

MCP significa Model Context Protocol.

Pense nele como um "CICS" da Inteligência Artificial.

Assim como o CICS conecta programas COBOL a diversos recursos corporativos, o MCP conecta modelos de IA a ferramentas externas.

Imagine Claude acessando:

DB2.

GitHub.

Jenkins.

Jira.

Confluence.

VS Code.

ServiceNow.

Sem copiar informações manualmente.


O sonho de qualquer Analista de Produção

Imagine perguntar:

Existe algum JOB que falhou hoje?

A Skill consulta o JES2.

Lê o SDSF.

Analisa o SYSOUT.

Localiza o ABEND.

Consulta a documentação.

Propõe uma solução.

Tudo em segundos.


3. Parallel Coding

Uma das maiores limitações humanas é que conseguimos fazer apenas uma tarefa por vez.

Os agentes de IA não possuem essa limitação.

Imagine cinco especialistas trabalhando simultaneamente.

Um desenvolve.

Outro testa.

Outro documenta.

Outro revisa segurança.

Outro produz diagramas.

Enquanto você toma café.


Isso lembra muito o Batch

Quem trabalha em Mainframe sabe que um JOB possui vários passos.

Cada STEP executa uma função.

As Skills seguem uma lógica parecida.

Diversos agentes trabalham em paralelo.

Cada um especialista em uma etapa.


4. Navegando milhões de linhas COBOL

Imagine um banco.

20 milhões de linhas.

6 mil programas.

12 mil COPYBOOKS.

Milhares de JCLs.

Você pergunta:

Onde é calculado o IOF?

A Skill percorre toda a base.

Encontra todos os programas.

Mostra quem chama quem.

Identifica impactos.

Em minutos.

É praticamente um Google especializado em código-fonte.


5. Migração automática

Durante décadas ouvimos falar em modernização.

Agora ela começa a ganhar novas ferramentas.

Uma Skill especializada pode auxiliar em:

COBOL → Java

PL/I → C#

Java 8 → Java 21

Spring antigo → Spring Boot moderno

AngularJS → React

Embora ainda exija validação humana, a produtividade aumenta enormemente.


Pesquisa Inteligente

Outra categoria extremamente poderosa é Research.

Ela transforma informação em conhecimento.

Não é apenas pesquisar no Google.

É estudar.

Cruzar fontes.

Comparar versões.

Detectar inconsistências.

Produzir relatórios.


Deep Research Agent

Imagine pedir:

Explique toda a evolução do COBOL desde 1959 até o padrão ISO atual.

Uma Skill pode trabalhar durante horas.

Consultar documentação IBM.

Normas ISO.

Livros.

Artigos.

White Papers.

Gerar um documento técnico extremamente rico.


Competitive Intelligence

Imagine comparar:

IBM Z

AWS

Azure

Google Cloud

Ela produz gráficos.

SWOT.

Custos.

Vantagens.

Desvantagens.

Riscos.

Tudo organizado.


Base de Conhecimento Corporativa

Talvez essa seja uma das aplicações mais valiosas.

Imagine alimentar uma Skill com:

Manuais IBM.

Normas internas.

Padrões da empresa.

Arquiteturas.

Procedimentos.

Políticas.

Agora qualquer desenvolvedor pergunta:

Como devo implementar uma transação CICS THREADSAFE?

Resposta instantânea.

Baseada na documentação oficial da empresa.


Produtividade

Essa categoria provavelmente será a primeira adotada pela maioria das empresas.

Porque gera retorno imediato.

Imagine um assistente que:

Organiza e-mails.

Resume reuniões.

Agenda tarefas.

Controla projetos.

Gera relatórios.

Integra Jira.

Integra Slack.

Integra Teams.

Integra GitHub.

Tudo automaticamente.


Claude Code

Essa categoria é voltada para Engenharia de Software profissional.

Ela inclui:

Revisão automática.

CI/CD.

GitHub.

Segurança.

Testes.

Infraestrutura.

Deploy.

É praticamente um DevOps virtual.


Segurança

Uma Skill especializada pode analisar:

SQL Injection.

Cross Site Scripting.

Dependências vulneráveis.

Tokens expostos.

Senhas.

Segredos.

Bibliotecas desatualizadas.

Tudo antes mesmo do deploy.


Testes

Quantas horas um desenvolvedor gasta escrevendo testes?

Agora imagine pedir apenas:

Gere todos os testes.

A Skill cria:

Unitários.

Integração.

Mock.

Playwright.

Selenium.

Carga.

Performance.

E ainda explica cada cenário.


E para quem trabalha com COBOL?

Aqui está uma oportunidade gigantesca.

Imagine criar Skills como:

COBOL Code Reviewer

Analisa padrões IBM.

Sugere melhorias.

Detecta GO TO desnecessários.

Encontra PERFORMs ineficientes.

Identifica tabelas mal definidas.


JCL Analyzer

Detecta:

Datasets inexistentes.

Passos redundantes.

Condições incorretas.

DISP inadequado.

Espaço insuficiente.

Melhorias de performance.


DB2 SQL Advisor

Analisa SQL.

Sugere índices.

Mostra access path.

Detecta tabelas problemáticas.

Recomenda RUNSTATS.

Explica o motivo.


CICS Performance Advisor

Analisa transações.

COMMAREA.

CHANNEL.

THREADSAFE.

Storage.

CPU.

Espera.

Sugere otimizações.


Abend Investigator

Recebe:

SYSOUT.

Dump.

Mensagens DFH.

Mensagens IEC.

Mensagens IEF.

Mensagens DSN.

Identifica automaticamente a causa raiz.


Creator Economy

Essa categoria interessa muito para quem produz conteúdo técnico.

Imagine escrever apenas:

COBOL Recursivo

A Skill gera automaticamente:

Artigo.

Newsletter.

LinkedIn.

Instagram.

Carrossel.

Quiz.

Vídeo.

Podcast.

Slides.

Infográfico.

E-book.

Tudo mantendo o mesmo estilo editorial.


O futuro pertence às Skills

Durante muitos anos acreditamos que o diferencial seria aprender a escrever prompts melhores.

Hoje já percebemos que isso é apenas uma etapa intermediária.

O verdadeiro patrimônio não será o prompt.

Será a Skill.

Ela concentra conhecimento.

Processos.

Ferramentas.

Experiência.

Boas práticas.

Integrações.

Memória.

Em outras palavras, ela captura aquilo que um profissional levou décadas para aprender.


A visão do Bellacosa Mainframe

Como Programador COBOL Padawan, talvez você esteja pensando:

"Isso tudo parece voltado apenas para quem desenvolve aplicações modernas."

Na verdade, ocorre justamente o contrário.

Os ambientes Mainframe possuem uma das maiores riquezas do mundo da tecnologia: conhecimento acumulado ao longo de décadas.

Existem regras de negócio escritas em COBOL que movimentam bilhões de reais diariamente. Existem sistemas que operam há quarenta anos porque foram projetados com robustez, disciplina e qualidade.

As Skills oferecem uma oportunidade inédita: transformar esse conhecimento em ativos reutilizáveis de Inteligência Artificial. Imagine uma Skill treinada para revisar programas COBOL segundo os padrões da sua empresa, outra especializada em explicar mensagens de ABEND, outra capaz de orientar novos profissionais na criação de JCLs ou na otimização de consultas Db2.

O papel do programador muda. Em vez de apenas escrever código, ele passa a ensinar a IA como um especialista pensa.

Esse talvez seja o maior legado que um profissional experiente pode deixar para as próximas gerações.

Porque, no fim das contas, a IA não substitui décadas de experiência. Ela amplia o alcance dessa experiência.

E é exatamente por isso que o futuro não pertence apenas a quem sabe programar.

Pertence a quem consegue transformar conhecimento em Skills inteligentes, reutilizáveis e escaláveis.

E tenho a impressão de que os Programadores COBOL Padawans que começarem essa jornada agora estarão entre os profissionais mais valiosos da próxima década.

Então, da próxima vez que abrir o Claude, faça uma reflexão antes de escrever um prompt enorme:

Será que este problema merece mais um prompt... ou já está na hora de criar uma Skill? ☕🚀

quarta-feira, 31 de julho de 2024

O Fantasma de 1959 Ainda Está Vivo

 


Bellacosa Mainframe e o fantasma de 1959

☕ Um Café no Bellacosa Mainframe

O Fantasma de 1959 Ainda Está Vivo

IA, Claude Code, watsonx, IBM Z e a Verdadeira História do COBOL em 2026

"Padawan, sempre desconfie de quem anuncia a morte do mainframe. Normalmente essa notícia foi escrita em um computador que acabou de consultar um banco de dados hospedado... em um mainframe."

Existe uma tradição curiosa na indústria de tecnologia.

A cada cinco ou seis anos alguém decreta a morte do COBOL.

Na década de 1990 disseram que o cliente-servidor acabaria com o IBM Z.

Nos anos 2000 foi a Internet.

Depois veio Java.

Em seguida SOA.

Cloud.

Containers.

Kubernetes.

Microservices.

Serverless.

Blockchain.

Metaverso.

Agora chegou a Inteligência Artificial Generativa.

E, em julho de 2026, bastou a Anthropic publicar demonstrações mostrando o Claude Code analisando aplicações COBOL para surgir uma nova manchete:

"A IA acabou de matar o COBOL."

Será?

Pegue sua caneca de café, sente-se diante do terminal 3270 e vamos separar o hype da realidade.


O nascimento de um gigante

COBOL nasceu oficialmente em 1959.

Mas entender essa data exige voltar alguns anos.

Naquela época cada fabricante possuía sua própria linguagem.

Programas escritos para um computador dificilmente funcionavam em outro.

Isso era um enorme problema para governos, bancos e grandes empresas.

Foi então que surgiu o CODASYL (Conference on Data Systems Languages), patrocinado pelo Departamento de Defesa dos Estados Unidos.

O objetivo era simples.

Criar uma linguagem voltada para negócios.

Portável.

Legível.

Fácil de manter.

Nascia o COmmon Business-Oriented Language.

Curiosamente, muitas ideias daquele projeto continuam extremamente atuais.


O verdadeiro objetivo nunca foi velocidade

Quando um padawan começa a estudar programação costuma perguntar:

"COBOL é rápido?"

Essa pergunta já começa errada.

COBOL nunca tentou ser o mais rápido.

Nunca tentou ser elegante.

Nunca tentou ser compacto.

Ele tentou ser compreensível.

Observe:

ADD TAX-AMOUNT TO TOTAL-AMOUNT.

READ CUSTOMER-FILE.

MOVE CUSTOMER-NAME TO REPORT-LINE.

Mesmo alguém que nunca estudou COBOL consegue imaginar o que está acontecendo.

Na década de 1960 isso era revolucionário.

Enquanto outras linguagens eram quase criptográficas, COBOL parecia inglês estruturado.

Essa legibilidade explica por que programas escritos há quarenta anos ainda conseguem ser compreendidos e evoluídos.


O fantasma que movimenta trilhões

Uma das frases mais repetidas na Internet diz:

"95% dos caixas eletrônicos usam COBOL."

Embora a ideia geral esteja correta — COBOL continua extremamente presente no setor financeiro — esse número varia conforme a fonte e normalmente mistura transações bancárias, processamento de cartões e sistemas legados.

A realidade de 2026 é mais interessante do que qualquer porcentagem isolada.

Milhões de linhas COBOL continuam executando diariamente operações críticas em:

  • bancos

  • seguradoras

  • bolsas de valores

  • companhias aéreas

  • empresas de logística

  • previdência

  • processamento de impostos

  • sistemas de saúde

  • governos

Mais importante do que discutir se são 80%, 90% ou 95% das transações é entender por que esses sistemas continuam existindo.


O segredo não é COBOL

Muitos jornalistas acreditam que o problema está na linguagem.

Não está.

O verdadeiro patrimônio é o conhecimento do negócio.

Imagine um programa que calcula juros.

Ele possui um IF aparentemente simples.

Por trás daquele IF podem existir:

  • quarenta anos de mudanças regulatórias;

  • decisões judiciais;

  • exceções para determinados produtos;

  • alterações tributárias;

  • acordos internacionais;

  • regras de auditoria;

  • exigências do Banco Central.

A IA consegue traduzir o código.

Mas ela não consegue deduzir, sozinha, por que aquela regra existe.

Esse conhecimento foi acumulado por gerações de analistas, arquitetos, desenvolvedores e especialistas do negócio.


O ecossistema IBM Z

Outro erro comum é imaginar que um sistema bancário seja apenas um programa COBOL.

Na prática, ele vive dentro de um enorme ecossistema.

Um único programa pode conversar com:

  • Db2 for z/OS

  • IMS

  • CICS

  • MQ

  • VSAM

  • QSAM

  • RACF

  • JES2

  • WLM

  • SMF

  • DFSMS

  • z/OS Connect

  • APIs REST

  • filas distribuídas

  • aplicações Linux on Z

  • microsserviços em OpenShift

Quando alguém diz:

"Vamos migrar esse programa."

Na verdade está dizendo:

"Vamos revalidar dezenas de integrações críticas."

Essa diferença muda completamente a dimensão do problema.


O mito dos programadores aposentados

Outro clichê recorrente afirma que:

"Os programadores COBOL desapareceram."

Isso também merece correção.

É verdade que muitos especialistas possuem décadas de experiência.

Mas também é verdade que existe uma nova geração chegando.

Em 2026 encontramos iniciativas importantes como:

  • IBM Z Xplore;

  • IBM Z Educator Experience;

  • Open Mainframe Project;

  • Linux Foundation;

  • universidades parceiras;

  • bootcamps especializados;

  • cursos online;

  • comunidades técnicas.

O problema não é falta absoluta de profissionais.

O desafio é formar pessoas capazes de compreender sistemas que evoluíram durante cinquenta anos.

Conhecer COBOL leva alguns meses.

Conhecer um banco leva anos.


Então chegou a IA

E chegamos ao ponto que gerou tantas manchetes.

Ferramentas como:

  • Claude Code;

  • ChatGPT;

  • GitHub Copilot;

  • IBM watsonx Code Assistant;

  • Gemini Code Assist;

  • Amazon Q Developer;

começaram a demonstrar capacidades impressionantes.

Hoje elas conseguem:

  • explicar programas COBOL;

  • documentar aplicações;

  • gerar diagramas;

  • localizar dependências;

  • produzir testes;

  • sugerir refatorações;

  • identificar código morto;

  • resumir COPYBOOKs;

  • interpretar JCL;

  • converter trechos para Java, C# ou outras linguagens.

Isso realmente representa uma revolução.

Mas existe uma enorme diferença entre entender código e substituir um sistema crítico.


Claude Code matou a IBM?

Não.

E aqui precisamos separar manchetes da realidade.

A publicação da Anthropic mostrou avanços relevantes na análise de aplicações legadas.

O mercado reagiu rapidamente porque investidores passaram a especular que serviços tradicionais de modernização poderiam se tornar mais baratos.

Entretanto, isso não significa que um banco possa simplesmente executar:

Migrar COBOL → Java

e colocar o novo sistema em produção na semana seguinte.

Na vida real existem:

  • homologação;

  • auditoria;

  • testes funcionais;

  • testes integrados;

  • testes de carga;

  • recuperação de desastres;

  • certificações regulatórias;

  • requisitos legais;

  • validação de performance;

  • planos de rollback.

Nenhuma IA elimina essas etapas.


O verdadeiro papel da IA

Padawan, aqui está a grande lição de 2026.

A IA não substitui o engenheiro.

Ela amplifica sua capacidade.

Hoje um desenvolvedor experiente consegue utilizar IA para:

  • entender programas antigos em minutos;

  • localizar impactos;

  • encontrar chamadas esquecidas;

  • gerar documentação automaticamente;

  • criar fluxogramas;

  • explicar SQL complexo;

  • resumir JCL;

  • identificar oportunidades de melhoria.

Isso reduz semanas de trabalho para horas.

É um enorme ganho de produtividade.


E a IBM?

Outra inconsistência frequente é imaginar que a IBM dependa exclusivamente do COBOL.

A IBM de 2026 é muito diferente da IBM de vinte anos atrás.

Seu portfólio inclui:

  • IBM Z;

  • LinuxONE;

  • watsonx;

  • Red Hat OpenShift;

  • Instana;

  • Turbonomic;

  • HashiCorp;

  • Concert;

  • Storage;

  • Quantum Safe;

  • Guardium;

  • Hybrid Cloud;

  • IA corporativa;

  • consultoria especializada.

Além disso, a própria IBM investe pesadamente em IA para modernização de aplicações.

O IBM watsonx Code Assistant for Z, por exemplo, auxilia na compreensão, documentação e modernização de aplicações COBOL, trabalhando como um copiloto para desenvolvedores, e não como um substituto do conhecimento humano.

Ou seja, a empresa participa da transformação em vez de apenas reagir a ela.


O novo perfil do programador COBOL

O profissional de 2026 não é mais apenas alguém que escreve código.

Ele precisa compreender:

  • arquitetura;

  • APIs;

  • DevOps;

  • Git;

  • containers;

  • Linux;

  • observabilidade;

  • segurança;

  • IA;

  • automação;

  • cloud híbrida.

COBOL continua importante.

Mas agora faz parte de um ecossistema muito maior.

O programador deixa de ser apenas um codificador e passa a atuar como um engenheiro de negócios, capaz de conectar o legado ao mundo moderno.


O conselho do Mestre Bellacosa

Imagine um Mestre Jedi diante de um jovem padawan.

O aprendiz pergunta:

"Professor... a IA vai acabar com o COBOL?"

O mestre sorri.

Aponta para o enorme IBM Z funcionando silenciosamente.

Depois responde:

"Padawan... a IA pode explicar milhões de linhas de código. Pode documentar sistemas inteiros. Pode sugerir melhorias e acelerar modernizações. Mas ela ainda depende de alguém que saiba fazer as perguntas certas, interpretar as respostas e entender o negócio por trás de cada linha."

É exatamente isso que diferencia um operador de ferramenta de um verdadeiro engenheiro.


O futuro já começou

O futuro não será "COBOL versus IA".

Será COBOL com IA.

Será comum ver agentes inteligentes:

  • explicando programas antigos;

  • documentando aplicações automaticamente;

  • criando testes unitários;

  • sugerindo otimizações SQL;

  • identificando impactos antes de uma alteração;

  • auxiliando em BINDs, JCLs e COPYBOOKs;

  • analisando dumps e SQLCODEs;

  • acelerando investigações de ABENDs.

O conhecimento humano continuará sendo indispensável, mas a produtividade será muito maior.


Conclusão

Ao longo de mais de seis décadas, COBOL sobreviveu a praticamente todas as grandes revoluções da computação. Não porque seja imutável, mas porque evoluiu junto com a plataforma IBM Z e continua sustentando aplicações cujo maior valor não está na linguagem, e sim nas regras de negócio que elas implementam.

A Inteligência Artificial Generativa representa, sem dúvida, a maior mudança no desenvolvimento de software desde a popularização da Internet. Ferramentas como Claude Code, ChatGPT e IBM watsonx Code Assistant transformaram a forma de analisar, documentar e modernizar aplicações legadas. Entretanto, elas não substituem décadas de conhecimento acumulado, nem eliminam requisitos de auditoria, segurança, conformidade e testes rigorosos exigidos por ambientes corporativos.

Para o programador COBOL padawan, a mensagem é animadora: nunca houve um momento tão interessante para aprender. Quem dominar COBOL, IBM Z, Db2, CICS, APIs, DevOps e IA terá um perfil raro e extremamente valioso. O profissional do futuro não será aquele que compete contra a IA, mas aquele que sabe utilizá-la para preservar o legado, acelerar a inovação e garantir que sistemas responsáveis por movimentar trilhões de dólares continuem funcionando com a confiabilidade que o mundo espera.

Porque, no fim das contas, o verdadeiro fantasma de 1959 não assombra o mercado. Ele continua trabalhando silenciosamente, vinte e quatro horas por dia, sete dias por semana, garantindo que cartões sejam autorizados, salários sejam pagos, aposentadorias sejam calculadas e bancos permaneçam operando. E agora, em 2026, ele ganhou um novo aliado: a Inteligência Artificial.


quinta-feira, 20 de junho de 2024

Não existe a melhor IA para programar. Existe a IA certa para cada etapa do desenvolvimento.

 

Bellacosa Mainframe e ia para programar

☕ Um Café no Bellacosa Mainframe

Não existe a melhor IA para programar. Existe a IA certa para cada etapa do desenvolvimento.

Durante muitos anos, nós, desenvolvedores, fizemos uma pergunta que parecia fazer todo o sentido:

"Qual é a melhor ferramenta para programar?"

Hoje, essa pergunta está ficando ultrapassada.

O mercado de Inteligência Artificial evoluiu tão rapidamente que não estamos mais escolhendo apenas um editor de código ou um assistente de programação. Estamos montando uma verdadeira equipe de especialistas digitais.

Assim como em um ambiente IBM Mainframe ninguém espera que o COBOL substitua o DB2, ou que o RACF faça o trabalho do JES2, as novas ferramentas de IA possuem responsabilidades diferentes dentro do ciclo de desenvolvimento de software.

Essa talvez seja a maior mudança da Engenharia de Software desde o surgimento do Git e do DevOps.

E, se você é um programador COBOL iniciante ou um desenvolvedor que deseja entrar no universo IBM Z, compreender essa transformação agora pode representar uma enorme vantagem profissional.

Pegue seu café.

Hoje vamos conversar sobre como Claude Code, OpenAI Codex, Cursor e GitHub Copilot estão mudando completamente a forma como escrevemos software.


A evolução das ferramentas de programação

Para entender o presente, precisamos olhar rapidamente para o passado.

Durante décadas, os IDEs eram apenas editores inteligentes.

No Visual Studio, Eclipse ou IDz (IBM Developer for z/OS), a maior ajuda era completar automaticamente uma variável ou sugerir o nome de um método.

Isso era fantástico para a época.

Mas ainda era você quem fazia praticamente todo o trabalho.

Depois surgiu uma nova geração.

Ferramentas como GitHub Copilot começaram a sugerir blocos inteiros de código.

Em vez de completar apenas uma linha, elas conseguiam escrever funções completas.

Foi um salto enorme.

Mesmo assim, a IA continuava esperando ordens.

Ela respondia.

Ela não agia.

Hoje estamos entrando em uma terceira fase.

As IAs deixaram de ser apenas "assistentes" e começaram a atuar como verdadeiros agentes de software.

Agora elas conseguem:

  • entender milhares de arquivos;

  • navegar pelo projeto inteiro;

  • modificar dezenas de programas;

  • executar testes;

  • corrigir erros;

  • atualizar documentação;

  • abrir Pull Requests;

  • revisar código;

  • trabalhar praticamente sozinhas.

Estamos presenciando o nascimento da Engenharia de Software Agêntica.


A analogia perfeita com o IBM Mainframe

Quem trabalha com Mainframe entende muito bem o conceito de especialização.

Pense no z/OS.

Existe o RACF.

Existe o DB2.

Existe o JES2.

Existe o WLM.

Existe o RMF.

Existe o CICS.

Existe o IMS.

Todos fazem parte do mesmo ambiente.

Mas nenhum substitui o outro.

Cada componente resolve um problema específico.

Com as novas IAs acontece exatamente a mesma coisa.

Não existe uma ferramenta capaz de fazer tudo melhor que todas as outras.

Existe uma ferramenta mais adequada para cada tarefa.

Esse conceito é extremamente importante para um desenvolvedor júnior.

Não caia na armadilha de procurar "a melhor IA".

Procure entender qual delas resolve melhor o problema que você possui naquele momento.


Cursor: o parceiro ideal para o desenvolvimento diário

Imagine que você acabou de abrir seu projeto COBOL.

Você precisa criar uma nova rotina.

Alterar uma consulta SQL.

Modificar um programa CICS.

Escrever um serviço Java.

Criar uma API REST.

Nesse cenário, o Cursor provavelmente será seu melhor companheiro.

Sua filosofia é simples:

"Programamos juntos."

Enquanto você escreve, ele acompanha seu raciocínio.

Você pode selecionar um trecho de código e perguntar:

"Explique essa lógica."

Ou:

"Como posso melhorar essa rotina?"

Ou ainda:

"Transforme esse código em algo mais legível."

O Cursor responde praticamente em tempo real.

Ele foi criado para acelerar o trabalho diário do desenvolvedor.

Não tenta substituir você.

Ele trabalha ao seu lado.

É como um colega extremamente experiente sentado na mesa ao lado.


Claude Code: pensando como um arquiteto

Agora imagine outro cenário.

Sua empresa possui um sistema desenvolvido há vinte anos.

Existem:

  • 3.000 programas COBOL;

  • centenas de COPYBOOKS;

  • milhares de JCLs;

  • dezenas de bibliotecas.

O cliente decidiu mudar uma regra de negócio.

Essa alteração afeta praticamente todo o sistema.

Abrir arquivo por arquivo seria inviável.

É exatamente aqui que Claude Code se destaca.

Sua especialidade é compreender o repositório inteiro.

Ele consegue localizar padrões repetidos.

Entender dependências.

Planejar alterações.

Modificar dezenas ou centenas de arquivos.

Executar testes.

Verificar impactos.

Tudo isso praticamente sozinho.

É como colocar um arquiteto de software trabalhando em tempo integral sobre o projeto.


OpenAI Codex: o conceito de delegação

Talvez essa seja a mudança mais revolucionária.

Até pouco tempo atrás, todas as ferramentas funcionavam da mesma maneira.

Você fazia uma pergunta.

A IA respondia.

Fim da história.

OpenAI Codex muda completamente essa lógica.

Agora você pode simplesmente delegar tarefas.

Imagine dizer:

"Corrija todos os problemas encontrados pelo SonarQube."

Ou:

"Atualize toda a documentação deste projeto."

Ou ainda:

"Crie testes automatizados para todas essas classes."

Você envia a tarefa.

Fecha a janela.

Continua trabalhando.

Enquanto isso, agentes executam tudo em segundo plano.

Mais tarde eles retornam com o resultado.

Esse conceito lembra bastante um ambiente Batch do Mainframe.

No z/OS enviamos um JOB para o JES2.

Ele entra na fila.

É executado.

Depois consultamos o SDSF para verificar o resultado.

OpenAI Codex aplica exatamente essa filosofia ao desenvolvimento moderno.

Você não fica esperando.

Você delega.


GitHub Copilot: muito além do autocomplete

Muitas pessoas ainda associam GitHub Copilot apenas ao preenchimento automático de código.

Essa visão já ficou no passado.

Hoje ele faz parte de um ecossistema muito maior.

Ele conversa com o GitHub.

Analisa Pull Requests.

Sugere melhorias.

Resume alterações.

Ajuda em revisões.

Integra-se ao GitHub Actions.

Interage com Issues.

Auxilia equipes inteiras.

Para organizações que já utilizam GitHub Enterprise, essa integração representa um enorme ganho de produtividade.

Não é apenas escrever código.

É participar de todo o ciclo de vida do software.


O erro que muitos iniciantes cometem

É muito comum ver perguntas como:

"Qual IA programa melhor?"

Essa pergunta possui o mesmo problema de perguntar:

"O que é melhor: COBOL ou DB2?"

Ou:

"JCL ou CICS?"

A resposta é:

Depende da tarefa.

Se você precisa escrever código rapidamente, Cursor pode ser excelente.

Se precisa modificar centenas de arquivos, Claude Code provavelmente será superior.

Se deseja executar tarefas em paralelo, Codex é extremamente interessante.

Se trabalha intensamente com GitHub, Copilot oferece uma integração fantástica.

Não existe vencedor.

Existe contexto.


A nova profissão: Orquestrador de IA

Talvez o desenvolvedor do futuro escreva menos código manualmente.

Mas isso não significa que ele será menos importante.

Muito pelo contrário.

Seu trabalho passará a ser:

  • definir arquitetura;

  • validar regras de negócio;

  • revisar resultados;

  • garantir qualidade;

  • supervisionar agentes.

É parecido com a evolução do administrador de Mainframe.

Antigamente muitas tarefas eram feitas manualmente.

Hoje grande parte é automatizada.

Mesmo assim, o conhecimento do profissional continua indispensável.

Porque alguém precisa tomar decisões.


E onde entra o DevOps?

DevOps sempre buscou automatizar o ciclo completo do software.

Agora a Inteligência Artificial amplia esse conceito.

Imagine um pipeline moderno.

O desenvolvedor implementa uma funcionalidade.

Cursor ajuda durante a codificação.

Claude Code revisa impactos em todo o projeto.

OpenAI Codex gera testes automatizados.

GitHub Copilot analisa o Pull Request.

GitHub Actions executa CI/CD.

Tudo praticamente integrado.

Estamos caminhando para pipelines onde humanos e agentes trabalham lado a lado.


O que isso significa para quem programa COBOL?

Muita gente acredita que essas ferramentas servem apenas para JavaScript ou Python.

Isso está longe da realidade.

Hoje diversas IAs já conseguem compreender:

  • COBOL;

  • JCL;

  • PL/I;

  • SQL;

  • REXX;

  • Java;

  • CICS;

  • DB2;

  • VSAM.

Elas conseguem explicar programas antigos.

Criar documentação.

Encontrar dependências.

Sugerir melhorias.

Escrever testes.

Migrar código.

Até mesmo analisar impacto entre COPYBOOKS.

Para quem trabalha em sistemas legados, isso representa um ganho gigantesco de produtividade.


MCP: a próxima grande revolução

Outro conceito que começa a ganhar força é o MCP (Model Context Protocol).

Imagine uma IA que não conhece apenas seu código.

Ela também consegue consultar:

  • Wiki da empresa;

  • documentação interna;

  • banco de dados;

  • APIs;

  • ServiceNow;

  • GitHub;

  • Jira;

  • Confluence;

  • ambiente z/OS.

Tudo usando um protocolo padronizado.

Em vez de copiar informações manualmente, a IA busca o contexto necessário diretamente na origem.

Isso reduz erros e aumenta a precisão das respostas.


Agentes conversando com agentes

Outro conceito importante é o A2A (Agent-to-Agent).

Hoje normalmente um agente resolve uma tarefa.

No futuro próximo teremos vários agentes colaborando entre si.

Imagine uma equipe composta por:

  • Arquiteto;

  • Desenvolvedor;

  • Especialista em testes;

  • Especialista em segurança;

  • Especialista DevOps;

  • Revisor técnico.

Todos eles serão agentes especializados.

Enquanto um programa, outro cria testes.

Enquanto outro verifica vulnerabilidades.

Enquanto outro prepara a documentação.

É praticamente uma fábrica de software funcionando vinte e quatro horas por dia.


Como isso se conecta ao IBM Mainframe?

No mundo IBM Z já convivemos há décadas com ambientes altamente especializados.

Um programa COBOL conversa com DB2.

DB2 conversa com o Storage.

JES2 agenda execução.

WLM distribui carga.

RMF monitora desempenho.

RACF protege recursos.

A nova geração de agentes segue exatamente essa filosofia.

Especialização.

Integração.

Orquestração.

Essa semelhança explica por que muitos profissionais Mainframe conseguem compreender rapidamente esse novo paradigma.

Eles já trabalham em um ambiente distribuído por responsabilidades há muitos anos.


Qual ferramenta um programador júnior deveria aprender primeiro?

Se eu estivesse começando hoje, faria um caminho semelhante a este.

Primeiro aprenderia Git.

Depois dominaria um bom IDE.

Em seguida utilizaria Cursor para acelerar o desenvolvimento.

Quando estivesse confortável, começaria a explorar Claude Code para grandes refatorações.

Depois aprenderia OpenAI Codex para delegação de tarefas.

Finalmente aprofundaria o uso do GitHub Copilot integrado ao fluxo de Pull Requests, revisão e entrega contínua.

Essa sequência acompanha a evolução natural da carreira.

Primeiro você aprende a escrever código.

Depois aprende a melhorar código.

Depois aprende a automatizar tarefas.

Por fim aprende a coordenar equipes — humanas e artificiais.


O futuro pertence a quem sabe combinar ferramentas

Existe uma frase muito conhecida:

"Quando tudo o que você possui é um martelo, todos os problemas parecem pregos."

Com Inteligência Artificial acontece exatamente o contrário.

Quanto mais ferramentas você conhecer, maior será sua capacidade de escolher a solução certa para cada desafio.

Esse é o verdadeiro diferencial.

Não decorar comandos.

Não depender de uma única plataforma.

Mas compreender como cada agente pode contribuir em uma etapa específica do desenvolvimento.


Conclusão

Estamos vivendo um momento histórico na Engenharia de Software. As IAs deixaram de ser simples geradoras de código para se tornarem participantes ativos de todo o ciclo de desenvolvimento. Elas ajudam a planejar, implementar, testar, documentar, revisar e entregar software com uma velocidade antes inimaginável.

Para um programador júnior, especialmente no universo IBM Mainframe, a maior oportunidade não está em encontrar "a ferramenta perfeita". Está em desenvolver uma mentalidade de orquestrador. Aprenda os fundamentos de programação, entenda profundamente o negócio, domine Git e DevOps, e então utilize cada IA de acordo com sua especialidade.

No estilo Bellacosa Mainframe, vale lembrar uma última analogia: um bom sistema IBM Z não depende de um único componente extraordinário, mas da integração harmoniosa entre vários componentes especializados. O mesmo acontecerá com as ferramentas de IA. O profissional que mais se destacará será aquele capaz de montar sua própria "stack de especialistas", sabendo quando usar o Cursor para construir, o Claude Code para refatorar, o OpenAI Codex para delegar tarefas e o GitHub Copilot para revisar e entregar.

O futuro do desenvolvimento de software não será dominado por uma única inteligência artificial. Será construído por desenvolvedores que souberem coordenar inteligências humanas e artificiais para criar soluções mais robustas, seguras, eficientes e inovadoras. E essa transformação já começou.