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