A geração de código via IA para linguagens modernas e populares (como Python ou JavaScript) costuma ser direta. No entanto, para Delphi (Object Pascal), o desafio é único. O Delphi possui um legado de quase 30 anos, o que significa que existem dezenas de dialetos, bibliotecas obsoletas e paradigmas conflitantes misturados nos dados de treinamento dos modelos de IA.

Um prompt vago como “Crie uma função para baixar um arquivo em Delphi” pode resultar em um código “Frankenstein” que mistura sintaxe do Delphi 7 com recursos do Delphi Alexandria, ou que utiliza componentes que você não tem instalados.

Este artigo detalha como estruturar seus prompts para obter código limpo, moderno (ou legado, se necessário) e, acima de tudo, compilável.

O Contexto Temporal: Definindo a Versão do Compilador

O erro mais comum ao pedir código Delphi é assumir que a IA sabe qual “era” do Delphi você está usando. O Object Pascal evoluiu drasticamente.

Por que isso quebra o código?

• Generics: Introduzidos no Delphi 2009. Se você usa Delphi 7, código com TList<T> falhará.
• Métodos Anônimos: Introduzidos no Delphi 2009.
• Variáveis Inline: Introduzidas no Delphi 10.3 Rio. A IA adora usá-las (ex: var I: Integer := 0; dentro do begin), mas isso quebra em versões anteriores (XE7, Seattle, Berlin).

A Técnica de Prompt: “Contexto de Versão Explícito”

Sempre inicie seu prompt definindo a versão exata ou o intervalo de compatibilidade.

Exemplo de Prompt Ruim:

“Faça um loop for para ler um TStringList.”

Exemplo de Prompt Bom (Moderno):

“Atue como um especialista em Delphi 11 Alexandria. Escreva um loop usando sintaxe moderna (inline variables) para iterar sobre um TStringList.”

Exemplo de Prompt Bom (Legado):

“Estou usando Delphi 7. Escreva um código compatível com esta versão. Não use Generics, não use métodos anônimos. Declare todas as variáveis antes do bloco begin.”

Ecossistema de Bibliotecas: Nativo vs. Terceiros

A IA foi treinada em muito código open-source que utiliza bibliotecas populares como Indy, JEDI (JVCL) ou TMS. Se você não especificar o que usar, a IA frequentemente alucinará dependências.

RTL/VCL vs. FireMonkey (FMX)

A distinção entre VCL (Windows puro) e FMX (Multiplataforma) é crucial. Um TEdit existe em ambos, mas suas propriedades e eventos diferem.

O Problema do HTTP

Se você pedir uma requisição HTTP, a IA tende a usar o componente Indy (IdHTTP) porque ele foi o padrão por décadas. No entanto, em versões modernas, a biblioteca nativa System.Net.HttpClient (THTTPClient) é preferível por usar a camada segura do SO (evitando o inferno das DLLs do OpenSSL).

Estratégia de Prompt: Use Restrições Negativas e Diretivas de Preferência.

Prompt: “Crie uma função para fazer um POST em uma API REST.

• Framework: VCL.
• Bibliotecas: Use APENAS bibliotecas nativas da RTL (System.Net, System.JSON).
• Restrição: NÃO use componentes Indy (IdHTTP) e NÃO use bibliotecas de terceiros como RestRequest4Delphi.”

Higiene de Código: With, Try/Finally e Vazamentos de Memória

O Delphi não possui Garbage Collection automática para classes (exceto interfaces e em plataformas ARC, que foi descontinuado no compilador desktop). A IA, acostumada com Python/C#, frequentemente esquece de liberar memória.

O Perigo do With

O comando with é considerado má prática moderna porque dificulta o debugging e a leitura. A IA adora usar with para economizar tokens na resposta.

A Regra de Ouro: Try/Finally

Qualquer objeto criado deve ser protegido por um bloco try...finally para garantir que Free seja chamado mesmo se ocorrer uma exceção.

Estratégia de Prompt: Crie uma seção de “Regras de Estilo” no seu prompt.

Prompt: “…Ao escrever o código, siga estritamente estas regras:

1. Anti-Pattern: NUNCA use a declaração with. Seja explícito (ex: Button1.Caption em vez de with Button1).
2. Segurança: Envolva toda criação de objeto em blocos try..finally para garantir a liberação de memória.
3. Destruição: Use Free ou FreeAndNil.”

O Prompt Mestre (Template)

Para obter resultados consistentes, recomendo usar uma estrutura de prompt modular. Copie e adapte o template abaixo:

Template de Engenharia de Prompt para Delphi

**CONTEXTO:**
Você é um Arquiteto de Software sênior especialista em Delphi [INSERIR VERSÃO: ex: 10.4 Sydney].

**TAREFA:**
[Descreva o problema aqui: ex: Ler um arquivo JSON e popular um TMemo]

**REQUISITOS TÉCNICOS:**
1.  **Compatibilidade:** O código deve compilar estritamente em Delphi [VERSÃO].
2.  **Bibliotecas:** Use apenas a RTL nativa ([System.JSON, System.SysUtils]). NÃO use bibliotecas de terceiros.
3.  **Framework:** Aplicação [VCL / FireMonkey / Console].

**DIRETRIZES DE QUALIDADE (OBRIGATÓRIO):**
* **Gerenciamento de Memória:** Todo objeto instanciado DEVE ser protegido por `try...finally` e liberado.
* **Estilo:** NÃO use a palavra-chave `with`. Nomeie variáveis seguindo PascalCase com prefixos padrão (ex: `lStringList`, `btnOk`).
* **Tratamento de Erros:** Capture exceções específicas onde necessário.

**SAÍDA:**
Forneça apenas o código Object Pascal comentado e pronto para uso.

Exemplo Prático: Comparação de Resultados

Veja a diferença que a engenharia de prompt faz na prática.

Prompt Genérico

“Como leio um JSON em Delphi?”

Resultado Típico da IA: Geralmente usa LkJSON ou bibliotecas antigas, não trata vazamento de memória se o JSON for inválido, e usa variáveis globais.

Prompt Engenheirado (Usando o Template acima)

“Delphi 11, use System.JSON, VCL, sem ‘with’, com try/finally.”

Resultado Otimizado:

procedure LerJsonSeguro(const AJsonString: string; AMemo: TMemo);
var
  LJsonObj: TJSONObject; // Variável local explícita
  LPair: TJSONPair;
begin
  // Validação básica
  if AJsonString.Trim = '' then Exit;

  LJsonObj := nil;
  try
    try
      // Parse do JSON usando System.JSON nativo
      LJsonObj := TJSONObject.ParseJSONValue(AJsonString) as TJSONObject;

      if Assigned(LJsonObj) then
      begin
        AMemo.Lines.BeginUpdate;
        try
          AMemo.Lines.Clear;
          // Iteração sem usar 'with'
          for LPair in LJsonObj do
          begin
            AMemo.Lines.Add(Format('%s: %s', [LPair.JsonString.Value, LPair.JsonValue.Value]));
          end;
        finally
          AMemo.Lines.EndUpdate;
        end;
      end;
    except
      on E: Exception do
        AMemo.Lines.Add('Erro ao ler JSON: ' + E.Message);
    end;
  finally
    // Garantia de liberação de memória
    if Assigned(LJsonObj) then
      LJsonObj.Free;
  end;
end;

Conclusão

A chave para obter código Delphi útil de uma IA não é saber perguntar, mas saber restringir. O Delphi permite muitas maneiras de fazer a mesma coisa, e a maioria delas está obsoleta ou é insegura. Ao especificar a versão do compilador, proibir o uso de with e exigir try/finally, você força o modelo a atuar como um desenvolvedor Delphi sênior, e não como um novato copiando código de fóruns de 2005.