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:

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:

Baixar o RadIA 2.7.0

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.