O RadIA nasceu com uma proposta simples de explicar e difícil de executar bem: levar inteligência artificial para dentro do Delphi sem transformar a IDE em apenas mais uma janela de chat. A ideia sempre foi que a IA pudesse participar do fluxo real de desenvolvimento, com acesso controlado a contexto, projeto, editor, designer, build, testes, debugger e evidências.
A versão 2.7.0 é importante porque não tenta vender uma novidade isolada. Ela fecha uma baseline funcional determinística. Em outras palavras: pega capacidades que vinham amadurecendo nas versões anteriores e as consolida em um conjunto mais previsível, mais validado e mais fácil de demonstrar.
O foco desta release é clareza operacional. O RadIA precisa entender melhor a intenção do usuário, escolher o caminho certo dentro da IDE, pedir consentimento quando houver risco, executar ações reais e deixar evidências suficientes para que o desenvolvedor confie no resultado.
O que significa uma baseline funcional determinística
Quando falamos em IA dentro de uma IDE, é comum cair na armadilha de avaliar apenas a qualidade da resposta textual. Mas uma ferramenta para desenvolvimento precisa ir além. Ela precisa funcionar de forma repetível, respeitar o projeto, preservar o workspace, saber quando está no editor de código, quando precisa ir para o designer e quando deve parar para pedir confirmação.
No RadIA 2.7.0, a palavra determinística aparece porque os fluxos principais foram cercados por requisitos verificáveis. Não basta o agente dizer que entendeu. Ele precisa passar por uma matriz de testes e evidências.
A release certifica, por exemplo, prompts naturais em português e inglês para os templates de projeto suportados. Também certifica intenções de navegação entre Code e Design em uma IDE real, incluindo erro estruturado e cancelamento seguro. E valida a revisão por bloco com solicitação de alterações comentada, sem modificar o buffer antes da decisão do usuário.
Essa abordagem muda a conversa. Em vez de perguntar apenas “a IA consegue responder?”, a pergunta passa a ser “o runtime consegue transformar uma intenção em uma ação segura, observável e reproduzível?”.
Criação natural de projetos para todos os templates
Uma das maiores evoluções do RadIA desde as versões anteriores é a criação de projetos por linguagem natural.
Na 2.6.0, o cenário mais visível foi a calculadora VCL: o usuário podia pedir uma aplicação simples, o RadIA montava uma jornada, criava o projeto, abria na IDE, compilava, executava testes e validava a interface. Aquilo mostrou que o plugin podia ir além da geração de texto.
Na 2.7.0, essa capacidade deixa de ficar concentrada em um caso especial e passa a cobrir todos os templates certificados:
- Console;
- VCL;
- FireMonkey;
- Library;
- Package;
- DUnitX;
- Windows Service.
O ponto mais importante aqui não é apenas ter mais templates. É permitir que o usuário peça em linguagem natural, em português ou inglês, e o RadIA reconheça a intenção, colete dados ausentes, gere preview, peça consentimento e só então materialize os arquivos.
Isso preserva uma diferença essencial entre assistente e automação perigosa. O RadIA não deve sair escrevendo no disco porque “achou” que entendeu. Ele deve transformar a intenção em um plano revisável, mostrar o que será criado e respeitar a autorização do usuário.
Menos comando decorado, mais intenção compreendida
Ferramentas poderosas costumam nascer cheias de comandos. Isso é natural durante a evolução técnica, mas cria uma barreira para o uso cotidiano. O desenvolvedor não deveria precisar lembrar exatamente qual comando ativa qual jornada para tarefas comuns.
O RadIA 2.7.0 avança nessa direção: o usuário pode expressar intenção. Pedidos naturais de criação agora são parte da matriz certificada, não apenas um atalho conveniente.
Esse detalhe muda a ergonomia. Em vez de pensar primeiro na ferramenta, o desenvolvedor pensa no objetivo:
crie um projeto console para testar uma rotina
ou:
create a DUnitX project for this validation
O RadIA se responsabiliza por encaixar essa intenção no fluxo correto. Se faltar informação, ele pergunta. Se a ação for estrutural, ele exige consentimento. Se houver validação, ela aparece como evidência.
Essa é uma das vantagens práticas de colocar a IA dentro da IDE: o assistente conhece o ambiente onde a ação vai acontecer.
Code e Design: a IDE como parte do raciocínio
Uma IDE Delphi não é apenas um editor de texto. Ela tem designer visual, arquivos .pas, .dfm, propriedades, eventos, componentes, builds, depuração e navegação entre superfícies diferentes.
Por isso, um agente útil para Delphi precisa entender quando uma intenção pertence ao código e quando pertence ao design.
A versão 2.7.0 certifica essa separação:
- intenções de layout, propriedades, inspeção e componentes ativam Design;
- intenções de código, eventos, debug e testes ativam Code;
- navegação inválida falha de forma estruturada;
- cancelamento não executa a ação.
Essa é uma melhoria menos chamativa do que “gerar um projeto”, mas é muito importante. Grande parte da produtividade no Delphi vem justamente da alternância entre código e designer. Se a IA não respeita essa dinâmica, ela força o usuário a corrigir manualmente o contexto o tempo todo.
Com a navegação orientada por intenção, o RadIA se aproxima mais do fluxo real do desenvolvedor: olhar uma propriedade, ajustar um componente, criar um evento, voltar ao código, compilar e testar.
Revisão por bloco com comentários antes da mutação
Outra melhoria central da 2.7.0 está na revisão por bloco.
O RadIA já vinha evoluindo a ideia de revisar mudanças diretamente no contexto do editor. A release 2.7.0 adiciona um comportamento importante: solicitar alterações com comentário pelo gutter, menu ou ferramenta, sem modificar imediatamente o buffer.
Isso parece sutil, mas melhora bastante a relação entre IA e revisão humana.
Em vez de aplicar ou rejeitar uma sugestão de forma binária, o desenvolvedor pode pedir um ajuste específico. O comentário permanece consultável e bloqueia o Apply até ser resolvido. Ou seja: o RadIA trata feedback como parte do ciclo de revisão, não como uma conversa solta que pode se perder.
Essa abordagem combina melhor com trabalho profissional. Código não é apenas gerado; ele é discutido, revisado, ajustado e validado. A IA precisa entrar nesse fluxo sem atropelar o controle do desenvolvedor.
Segurança operacional: erro e cancelamento também são funcionalidades
Quando uma ferramenta executa ações reais, sucesso não é o único cenário que importa. Falhas previsíveis precisam ser tratadas com a mesma seriedade.
O RadIA 2.7.0 valida navegação inválida com erro estruturado e cancelamento sem execução da ação. Isso é fundamental porque, em um ambiente integrado à IDE, uma ação errada pode custar tempo, alterar estado visual, trocar contexto ou induzir o usuário a tomar uma decisão com base em uma tela incorreta.
Um bom agente não é aquele que sempre tenta fazer alguma coisa. É aquele que sabe quando parar, explicar o motivo e preservar o estado.
Essa filosofia aparece em várias partes do RadIA: consentimento antes de mutações, preview antes da criação de projetos, bloqueio de Apply enquanto há comentário pendente, evidência após validação e documentação dos limites da release.
Evidências reproduzíveis nos alvos suportados
O RadIA 2.7.0 foi validado nos três alvos atuais:
| IDE | Arquitetura | Estado |
|---|---|---|
| Delphi 12 Athens | Win32 | Suportado e validado |
| Delphi 13 | Win32 | Suportado e validado |
| Delphi 13 | IDE64 | Suportado e validado |
Deslize a tabela para os lados para ver todas as colunas.
A auditoria da release registra:
- Delphi 12 Win32 Release e DUnitX;
- Delphi 13 Win32 Release e DUnitX;
- Delphi 13 IDE64 Release e DUnitX, com 1065 testes aprovados e sem vazamentos;
- testes web aprovados;
- lint aprovado;
- testes documentais aprovados;
- SonarQube com gate OK, cobertura de 83,2%, duplicação de 1,8% e zero issues;
- pacotes, instalador e instalação final nas três metas.
Esses números importam porque deixam claro que a release não é apenas uma coleção de ideias. Ela foi fechada com uma matriz de qualidade.
Para uma extensão que roda dentro do processo da IDE, isso é ainda mais importante. Estabilidade não é luxo. Um plugin instável não atrapalha apenas a si mesmo; ele atrapalha o ambiente onde o desenvolvedor trabalha o dia inteiro.
O catálogo de 132 ferramentas internas
A versão 2.7.0 documenta um catálogo de 132 ferramentas internas.
Esse número não deve ser lido como uma competição de quantidade. A parte interessante é o que ele representa: o RadIA evoluiu para uma plataforma de capacidades organizadas. Há ferramentas para contexto, projeto, editor, build, testes, debugger, designer, conhecimento, diagnóstico, instalação, MCP, revisão e fluxos agentivos.
O usuário não precisa conhecer cada ferramenta individualmente para começar. Mas a existência de um catálogo documentado torna a plataforma auditável. O comando /tools mostra o que está disponível na instância atual, e a documentação explica quando cada grupo deve ser usado.
Essa transparência é uma vantagem importante. Em vez de uma IA opaca dizendo “vou tentar”, o RadIA expõe capacidades, riscos, limites e evidências.
O que a 2.7.0 não tenta fazer
Uma boa release também precisa deixar claro o que está fora do escopo.
O RadIA 2.7.0 não substitui o WebView, não adiciona suporte a C++ ou Lazarus e não muda o modelo de instalação para um produto comercial. Essa clareza é saudável. Ela evita expectativa errada e mantém a evolução concentrada na experiência Delphi atual.
O foco é fechar bem a base funcional existente:
- criar projetos por intenção natural;
- alternar Code e Design de forma previsível;
- revisar blocos com feedback comentado;
- validar os alvos suportados;
- entregar instalador visual;
- manter documentação e evidências alinhadas.
Nem toda versão precisa abrir uma frente nova. Às vezes, a evolução mais importante é tornar o que já existe confiável o suficiente para virar base.
O instalador visual continua sendo o caminho do usuário final
Para o usuário final, o caminho recomendado continua simples: baixar o instalador visual da release.
RadIA-v2.7.0-Setup.exe
O instalador cobre os alvos suportados e evita que o usuário precise escolher manualmente pacotes internos. Isso reduz erro de instalação e melhora suporte.
Os artefatos internos continuam úteis para validação, proveniência e composição do instalador, mas a experiência pública deve ser direta: baixar o setup, escolher os alvos e abrir a IDE.
O instalador da versão 2.7.0 não é assinado por decisão do projeto. O SHA-256 publicado é:
92EA4A6599736F348394CE22872672A27314A51FDF574BFEC7117045BFB980EB
Por que essa versão importa
A versão 2.7.0 importa porque transforma maturidade técnica em experiência verificável.
O RadIA já tinha chat, ferramentas, contexto, revisão, terminal, criação de projetos e integração com a IDE. A 2.7.0 organiza parte desse conjunto em uma baseline funcional: prompts naturais certificados, Code/Design com intenção, revisão comentada sem mutação e evidência nos alvos suportados.
Isso é o tipo de evolução que torna uma ferramenta mais útil na prática. O desenvolvedor não quer apenas ver uma demonstração impressionante. Ele quer abrir o Delphi, pedir uma tarefa, entender o plano, manter controle sobre as mudanças e confiar que o resultado foi validado.
O RadIA caminha nessa direção: IA como parte do ciclo de desenvolvimento, não como uma camada solta ao lado da IDE.
Como instalar
Feche todas as instâncias do Delphi e acesse a página oficial da release:
Baixe e execute:
RadIA-v2.7.0-Setup.exe
Depois de instalar, abra o Delphi novamente. As janelas principais do RadIA mostram a versão no caption, facilitando a confirmação do build carregado.
O RadIA é open source. O código-fonte, os testes, a documentação e o histórico completo estão no repositório oficial no GitHub.
Conclusão
O RadIA 2.7.0 não é apenas uma atualização incremental. É um ponto de estabilização.
Ele mostra que a integração de IA com Delphi pode ser tratada como engenharia de produto: com intenção natural, consentimento, revisão, navegação pela IDE, validação automatizada e evidências reproduzíveis.
Essa é a diferença entre um chat que ajuda e um assistente que participa do desenvolvimento.
O chat continua importante, mas passa a ser apenas uma das superfícies. O valor maior está no runtime ao redor dele: as ferramentas, os limites, o histórico, a validação e a capacidade de agir dentro da IDE sem tirar o desenvolvedor do controle.
Com a 2.7.0, o RadIA consolida essa direção e cria uma base mais firme para os próximos passos.
0 comentário(s)