Translate

Mostrar mensagens com a etiqueta GitHub Copilot. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta GitHub Copilot. Mostrar todas as mensagens

quarta-feira, 20 de maio de 2026

SKILL.md : O JCL da Inteligência Artificial?




☕ Um Café no Bellacosa Mainframe

SKILL.md

O JCL da Inteligência Artificial?

Como transformar prompts descartáveis em componentes reutilizáveis de IA

"Programadores COBOL nunca escreveram comandos repetidos quando podiam criar uma PROC. O SKILL.md segue exatamente essa filosofia."


O problema do Prompt Engineering

Hoje a maioria das pessoas trabalha assim:

Abre ChatGPT

↓

Escreve um prompt enorme

↓

Recebe resposta

↓

Fecha

↓

No dia seguinte...

Escreve tudo novamente

É praticamente isso.

Imagine um DBA que toda manhã tivesse que escrever novamente o JCL inteiro para executar o RUNSTATS.

Ninguém faria isso.

Criaria uma PROC.

Ou um CLIST.

Ou um REXX.

Ou um Script.

Ou um Pipeline.

Então por que fazemos isso com IA?


O nascimento do SKILL.md

A ideia do SKILL.md é simples.

Em vez de guardar conhecimento na cabeça...

...guardamos conhecimento em arquivos.

Esses arquivos descrevem exatamente:

  • quando executar

  • como executar

  • quais regras seguir

  • quais ferramentas usar

  • qual formato devolver

Ou seja...

não é um prompt.

É um módulo.


Pense como um programador COBOL

No COBOL existe:

COPYBOOK

Você escreve uma vez.

Depois reutiliza em centenas de programas.

O SKILL.md é praticamente o COPYBOOK da IA.


Outro exemplo.

No z/OS temos

PROC JCL

Em vez de copiar:

IEFBR14

DISP

SPACE

DCB

...

criamos

PROC

e chamamos:

//STEP EXEC PROC=BACKUP

O SKILL.md faz exatamente isso.


Em vez de escrever

Analise este código COBOL...

gere documentação...

explique...

crie testes...

faça HTML...

gere JSON...

você apenas chama

/documentar-cobol

E pronto.


O que realmente existe dentro de um SKILL.md?

A imagem resume isso muito bem.

Vamos aprofundar.


1 Nome

name:

É o identificador.

Exemplo

documentar-cobol

ou

analisar-jcl

ou

explicar-vsam

2 Description

Essa talvez seja a parte mais importante.

Ela não serve apenas para humanos.

Serve para a IA descobrir:

"quando devo usar este Skill?"

Exemplo.

Sempre que o usuário enviar um programa COBOL
e pedir documentação.

Observe.

Não é um prompt.

É um gatilho.


3 Instructions

Aqui mora o cérebro.

Exemplo.

1 Leia o código

2 Identifique variáveis

3 Gere fluxograma

4 Explique SQL

5 Explique CICS

6 Gere documentação

7 Gere Markdown

É praticamente um algoritmo.


4 Constraints

Muito importante.

Exemplo.

Nunca invente campos

Nunca altere lógica

Explique apenas o que existe

Sempre preserve comentários

Sem restrições...

a IA improvisa.

Com restrições...

ela fica previsível.


5 Output

Como devolver.

Exemplo.

Markdown

JSON

HTML

Tabela

Mermaid

Ascii Art

PlantUML

Isso elimina enorme parte da inconsistência.


Progressive Disclosure

Essa parte da imagem é excelente.

Ela mostra algo pouco conhecido.

A IA não precisa carregar tudo imediatamente.

Ela faz:

Stage 1

↓

Carrega apenas metadados

Depois

Stage 2

↓

Carrega instruções completas

Depois

Stage 3

↓

Busca scripts externos

Isso reduz consumo de contexto.

É parecido com paginação de memória.

Ou até mesmo:

Demand Paging

no z/OS.

Só carrega quando precisa.


Anatomia

A imagem resume assim:

name

description

instructions

Mas, na prática, um bom Skill costuma ter também:

Examples

References

Templates

Output

Validation

Error Handling

Scripts

Assets

Ou seja...

é quase um pequeno projeto.


Estrutura de diretórios

A imagem mostra algo como

.claude/

skills/

review-pr/

Dentro temos

SKILL.md

scripts/

references/

assets/

Isso é fantástico.

Porque aproxima IA da engenharia de software.

Não existe mais um prompt perdido.

Existe um componente organizado.


Um exemplo para Mainframe

Imagine:

skills/

analisar-cobol/

SKILL.md

copybooks/

templates/

scripts/

Dentro do Skill:

Receba um programa COBOL.

Explique:

Data Division

Working Storage

Linkage

File Section

Procedure Division

CICS

SQL

VSAM

Performance

Sugestões

Checklist

Fluxograma

Sempre igual.

Sempre consistente.


Outro exemplo

Imagine um Skill chamado

JCL Review

Quando alguém envia

//STEP01 EXEC PGM=IDCAMS

automaticamente a IA faz:

✔ verifica DISP

✔ verifica SPACE

✔ verifica UNIT

✔ verifica DCB

✔ verifica GDG

✔ verifica retorno

✔ identifica problemas

✔ sugere melhorias

Sem escrever prompt algum.


Outro exemplo

RACF Auditor

Entrada

Comandos RACF

Saída

Riscos

Boas práticas

Least Privilege

Violação

Explicação

Checklist

Normas IBM

Outro exemplo

Explicar Dump S0C7

Sempre devolvendo

Causa

Registro PSW

Offset

Hex

Instrução COBOL

Correção

Exemplo

Por que isso escala?

Porque agora existe padronização.

Imagine uma empresa.

Hoje.

100 desenvolvedores.

Cada um escreve prompts diferentes.

Resultados diferentes.

Qualidade diferente.

Agora imagine.

Todos usam

review-api

review-cobol

review-java

security

documentation

A empresa inteira produz praticamente no mesmo padrão.


Isso lembra muito...

Quem trabalha em Mainframe provavelmente percebeu.

SKILL.md lembra vários conceitos clássicos:

MainframeMundo IA
PROCSkill
COPYBOOKSkill compartilhado
CLISTSkill
REXXSkill com lógica
ISPF PanelInterface para Skill
JCL ProcedureReutilização
PARMLIBConfiguração
EXITPersonalização
Macro AssemblerTemplate reutilizável

Na verdade...

a filosofia é praticamente a mesma.


Skills × Config × MCP

A imagem também mostra essa diferença.

Skills

São capacidades.

Gerar documentação

Revisar código

Criar testes

Explicar erros

Converter formatos

São executadas sob demanda.


Configs

São comportamentos permanentes.

Exemplo.

Sempre responda em português.

Sempre seja objetivo.

Nunca gere código inseguro.

É equivalente às configurações globais do ambiente.


MCP

É outra camada completamente diferente.

MCP conecta IA a recursos externos.

Por exemplo:

GitHub

Jira

Confluence

PostgreSQL

Oracle

VSCode

Filesystem

AWS

IBM APIs

Enquanto um Skill ensina como pensar, o MCP fornece acesso ao mundo externo.


O futuro: IA Programável

A mensagem mais importante da imagem é esta:

"The shift is happening towards programmable AI systems."

Esse é realmente o movimento que está ganhando força.

A evolução pode ser vista em quatro fases:

2023

Prompt Engineering

2024

Prompt Libraries

2025

AI Agents

2026+

Skills

MCP

Workflows

Memory

Ferramentas

Automação

Cada etapa reduz trabalho manual e aumenta a reutilização e a previsibilidade.


Como isso se aplica ao Bellacosa Mainframe

Esse conceito combina muito com o projeto Bellacosa Mainframe. Em vez de criar prompts longos para cada artigo ou análise, você pode construir uma biblioteca de Skills especializadas, por exemplo:

  • Artigo Bellacosa — gera artigos longos no seu estilo, com curiosidades, história, exemplos, SEO, FAQ e chamadas para ação.

  • Review COBOL — analisa código COBOL com foco em bancos brasileiros, boas práticas, legibilidade e performance.

  • Analisador JCL — valida DISP, SPACE, GDG, retornos, organização dos DDs e oportunidades de melhoria.

  • Explicador CICS — detalha COMMAREA, Channels/Containers, TSQ/TDQ, RESP/RESP2, BMS e tratamento de erros.

  • Gerador de Quiz — cria avaliações com diferentes níveis de dificuldade e gabarito comentado.

  • Criador de Laboratórios — produz exercícios práticos para Hercules, ADCD e ambientes IBM Z.

  • SEO Blogspot — gera meta description, marcadores, slug e estrutura otimizada para mecanismos de busca.

Cada Skill seria reutilizada inúmeras vezes, garantindo consistência em todos os seus conteúdos.


Conclusão

O SKILL.md representa uma mudança importante na forma de trabalhar com IA. O foco deixa de ser escrever prompts elaborados para cada interação e passa a ser a criação de componentes reutilizáveis, documentados e padronizados, muito semelhantes aos princípios que profissionais de mainframe já utilizam há décadas com COPYBOOKs, PROCs, CLISTs, REXX e módulos reutilizáveis.

No fim das contas, a lógica é familiar para qualquer desenvolvedor experiente:

Não copie conhecimento. Encapsule-o. Não repita instruções. Reutilize-as. Não trate a IA como uma calculadora. Trate-a como uma plataforma programável.

Essa mudança aproxima a Inteligência Artificial das boas práticas de engenharia de software e tende a tornar seu uso mais confiável, escalável e sustentável em ambientes corporativos — exatamente como aconteceu com a evolução do desenvolvimento no mundo IBM Z ao longo das últimas décadas.

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

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.