A Inteligência Artificial Generativa (GenAI) já não é mais uma promessa futurista, mas uma ferramenta de fluxo de trabalho consolidada no desenvolvimento moderno. Para o desenvolvedor Delphi, que muitas vezes lida com grandes bases de código legado e a necessidade de modernização constante, dominar a “Engenharia de Prompt” torna-se uma competência técnica tão crítica quanto conhecer a VCL ou FireMonkey.

Neste artigo, exploraremos os fundamentos apresentados no curso de Engenharia de Software da USP/Esalq, adaptando-os especificamente para o nosso dia a dia com Object Pascal e RAD Studio.

O Que é Engenharia de Prompt?

Ao contrário do que se imagina, Engenharia de Prompt não é apenas “conversar com chatbots”. Trata-se de uma disciplina que intersecciona Engenharia de Software, Inteligência Artificial e Interação Humano-Computador (IHC).

Ela pode ser definida como “a arte e ciência de formular instruções estruturadas para guiar modelos de IA a resultados de alta qualidade”.

O Copiloto e o Piloto

Um conceito fundamental é entender a relação de responsabilidade. A IA é o Copiloto, mas você, engenheiro de software, é o Piloto. A responsabilidade pela idoneidade, segurança e lógica do código final é inteiramente humana. LLMs (Large Language Models) são probabilísticos, não enciclopédias; eles podem gerar respostas que parecem corretas gramaticalmente (sintaxe Pascal perfeita), mas que são logicamente falhas ou usam bibliotecas inexistentes — o fenômeno das “alucinações”.

A Anatomia de um Bom Prompt (Framework 5 Pilares)

O documento base sugere uma estrutura de prompt que funciona como uma especificação técnica informal. Para obter código Delphi moderno e utilizável, devemos seguir estes 5 pilares :

1. Papel: Quem a IA deve simular? (Ex: Arquiteto de Software Sênior em Delphi).
2. Contexto: Qual o cenário? (Ex: Migração de código legado ou criação de uma API Rest).
3. Tarefa: O que deve ser feito? (Ex: Criar uma classe de DTO).
4. Restrições: O que evitar ou impor? (Ex: Usar Generics, não usar With, validar inputs).
5. Formato de Saída: Como entregar? (Ex: Unit completa .pas comentada).

Estudo de Caso: Do Prompt Ruim ao Prompt Eficaz no Delphi

Vamos comparar como um prompt vago difere de um prompt de engenharia aplicado ao Delphi.

❌ O Prompt Ruim

“Crie um código em Delphi para conectar no banco e salvar um cliente.”

Por que falha?

• Vago: Não define qual framework de acesso a dados (FireDAC, Zeos, ADO?).
• Sem Restrições: Pode gerar código inseguro (SQL Injection) ou práticas obsoletas (como usar TTable).
• Resultado Imprevisível: A IA pode alucinar componentes que não existem na sua versão do Delphi.

✅ O Prompt Bom (Engenharia Aplicada)

Aplicando a estrutura de 5 pilares:

[PAPEL] Atue como um Especialista em Delphi 13 e Clean Code.

[CONTEXTO] Estamos desenvolvendo um backend utilizando o padrão Repository.

[TAREFA] Crie uma Interface e uma Classe de Implementação para salvar dados de um cliente (TCustomer).

[RESTRIÇÕES]

1. Use FireDAC (TFDQuery) para acesso a dados.
2. Utilize SQL parametrizado para evitar injeção.
3. Implemente tratamento de exceções com try..finally para liberar a Query.
4. O método deve receber um objeto da classe TCustomer (assuma que ela já existe).
5. Use const nos parâmetros para otimização

[OUTPUT] Apenas o código da Unit (Interface e Implementation), sem explicações excessivas.

Código Gerado (Exemplo)

unit Customer.Repository;

interface

uses
  System.SysUtils, FireDAC.Comp.Client, Customer.Model;

type
  ICustomerRepository = interface
    ['{GUID-GERADO-AQUI}']
    procedure Save(const ACustomer: TCustomer);
  end;

  TCustomerRepository = class(TInterfacedObject, ICustomerRepository)
  private
    FConnection: TFDConnection;
  public
    constructor Create(AConnection: TFDConnection);
    procedure Save(const ACustomer: TCustomer);
  end;

implementation

{ TCustomerRepository }

constructor TCustomerRepository.Create(AConnection: TFDConnection);
begin
  FConnection := AConnection;
end;

procedure TCustomerRepository.Save(const ACustomer: TCustomer);
var
  LQuery: TFDQuery;
begin
  LQuery := TFDQuery.Create(nil);
  try
    LQuery.Connection := FConnection;
    LQuery.SQL.Text := 'INSERT INTO CUSTOMERS (NAME, EMAIL) VALUES (:NAME, :EMAIL)';
    
    // Uso de parâmetros conforme restrição de segurança
    LQuery.ParamByName('NAME').AsString := ACustomer.Name;
    LQuery.ParamByName('EMAIL').AsString := ACustomer.Email;
    
    LQuery.ExecSQL;
  finally
    LQuery.Free;
  end;
end;

end.

Técnicas e Detalhes Técnicos

1. Prevenção de Alucinações

No Delphi, as IAs tendem a alucinar nomes de units (ex: inventar System.Json.Serializers em vez de usar REST.Json ou System.JSON). A técnica de “Grounding” (ancoragem) consiste em listar explicitamente no prompt as Units permitidas ou a versão do Delphi, como feito no exemplo acima (“Delphi 12 Athens”).

2. Processo Iterativo

A engenharia de prompt não é “one-shot” (uma única tentativa). O fluxo recomendado é:

1. Draft: Criação do prompt inicial.
2. Teste: Execução no IDE (Compilar).
3. Análise: O código compila? Segue as boas práticas?
4. Refino: Ajuste do prompt para corrigir erros ou melhorar a performance .

3. Validação de Segurança

Um dos maiores riscos apontados no material é a vulnerabilidade de segurança. Ao pedir código Delphi, sempre inclua a restrição explícita: “Evite concatenação de strings em SQL, use parâmetros”. Isso mitiga o risco de injeção que a IA poderia introduzir por ter sido treinada também com códigos ruins da internet.

Conclusão

A Engenharia de Prompt é uma competência estratégica que eleva a produtividade do desenvolvedor Delphi, permitindo focar na arquitetura e nas regras de negócio enquanto a IA cuida da implementação (“boilerplate”). No entanto, a validação humana é obrigatória. Nunca confie cegamente na saída; você continua sendo o piloto.

Referências Bibliográficas

SANTOS, Helder Prado. Minicurso: Engenharia de Prompt para Engenheiros de Software. Piracicaba: USP ESALQ, 2026. 46 p. Apresentação em PDF.

OPENAI. GPT-4 Technical Report. arXiv:2303.08774, 2023. Disponível em: https://doi.org/10.48550/arXiv.2303.08774. Acesso em: 21 jan. 2026.

PHOENIX, J.; TAYLOR, M. Prompt Engineering for Generative AI: Future-proof inputs for reliable AI outputs at scale. O’Reilly Media, 2024.