Aprende Delphi con IA: crea un generador de firmas profesionales

¿Podemos desarrollar una aplicación para Windows pidiendo ayuda a una inteligencia artificial y comprobando el resultado en Delphi?

En este primer proyecto de Aprende Delphi con IA vamos a recorrer ese proceso: definir una aplicación, pedir el código, revisar lo que recibimos, ampliar sus funciones y comprobar que funciona.

El resultado es un generador de firmas profesionales, desarrollado en Object Pascal para Delphi 12.1 Community Edition, con una interfaz VCL y componentes estándar. Permite introducir datos personales y profesionales, elegir entre tres estilos de firma, copiar el resultado y guardarlo como un archivo de texto.

El proyecto se ha desarrollado con ayuda de ChatGPT. La compilación y las pruebas posteriores las ha realizado el autor en Delphi, confirmando que la aplicación funciona correctamente.

1. Qué papel tiene la IA en este proyecto

La IA nos ayuda durante el desarrollo: propone una estructura, escribe código, explica sus decisiones y adapta el proyecto cuando pedimos cambios. La aplicación terminada funciona por sí misma: no necesita conectarse a ChatGPT, utilizar una clave de API ni enviar los datos del usuario a un servicio externo.

Durante el desarrollo	Al utilizar la aplicación
Conversamos con la IA para definir y mejorar el proyecto.	Introducimos los datos de nuestra firma.
Revisamos los archivos que genera.	Elegimos un estilo.
Abrimos el proyecto en Delphi y lo compilamos.	Generamos, copiamos o guardamos el resultado.
Comunicamos errores o mejoras a la IA.	La aplicación funciona sin Internet.

Este será el método de trabajo: pedir algo concreto, revisar la entrega, probarla y mejorarla. Los prompts que aparecen a continuación están preparados para reproducir ese recorrido. Son una versión organizada del proceso seguido, no una transcripción literal de toda la conversación.

2. Empezar por una aplicación pequeña y definida

Nuestra primera idea fue sencilla: introducir nombre, cargo y empresa, y convertir esos datos en una firma de texto.

• Generar una firma y mostrarla en un TMemo.
• Copiarla al portapapeles.
• Limpiar el formulario.
• Avisar si faltaba el nombre.

Esta elección permite comprobar visualmente casi todo lo que hace el programa y trabajar con conceptos habituales de Delphi: formularios, controles, propiedades, eventos, condiciones y cadenas de texto.

Antes de pedir código fijamos las condiciones técnicas. Una petición demasiado abierta puede terminar en un proyecto pensado para otra versión de Delphi o con dependencias que no tenemos.

3. El primer prompt: explicar qué necesitamos y con qué herramientas

Quiero desarrollar una aplicación llamada Generador de firmas profesionales.

Debe utilizar Delphi 12.1 Community Edition, Object Pascal y Windows VCL.

Utiliza únicamente componentes estándar disponibles en Community Edition. La aplicación debe funcionar sin Internet.

El usuario introducirá nombre, cargo y empresa. El nombre será obligatorio.

Añade botones para generar una firma en un TMemo, copiarla al portapapeles y limpiar el formulario. Muestra mensajes comprensibles cuando falte el nombre o no haya una firma que copiar.

Define los controles en el formulario y enlaza sus eventos OnClick para poder revisarlos desde el diseñador y Object Inspector.

Entrega archivos coherentes .pas, .dfm, .dpr y .dproj, además de un README y un ZIP sin ejecutables ni temporales.

No afirmes que has compilado el proyecto si no lo has hecho. Yo lo abriré, compilaré y probaré en Delphi.

Esta petición establece el objetivo, la tecnología, las funciones y la entrega. Generar código y comprobar que compila son pasos distintos. En nuestro proceso, la revisión inicial fue estática; la validación real llegó después, al utilizar Delphi.

4. Qué archivos debe entregar la IA

Una aplicación VCL no se reduce a pegar código en un archivo .pas. El formulario, el proyecto y los eventos deben encajar.

Archivo	Para qué sirve
GeneradorFirmas.dpr	Inicia la aplicación y crea el formulario principal.
GeneradorFirmas.dproj	Guarda la configuración del proyecto para Delphi.
Principal.pas	Contiene la declaración del formulario y la lógica de los botones.
Principal.dfm	Define los controles, sus propiedades y los eventos enlazados.
README.md	Explica cómo abrir el proyecto y qué pruebas realizar.

Si el botón se llama btnGenerar en el formulario, el código debe utilizar ese mismo nombre. Además, su evento OnClick tiene que apuntar al método correspondiente:

procedure TfrmPrincipal.btnGenerarClick(Sender: TObject);

No basta con que ese método exista: el botón debe tenerlo asignado. Podemos pedir esta revisión a la IA:

Revisa la coherencia entre Principal.pas y Principal.dfm. Comprueba que todos los controles existen con el mismo nombre y tipo, y que cada OnClick apunta a un método declarado e implementado. Indica qué has revisado y qué requiere una prueba real en Delphi.

Esta revisión ayuda a detectar problemas antes de compilar, aunque no sustituye a la compilación.

5. La primera versión era útil, pero demasiado simple

Una vez preparado el proyecto inicial, surgió una observación: la aplicación hacía lo solicitado, pero podía resultar poco interesante como ejemplo completo. Aquí aparece uno de los usos más prácticos de la IA: mejorar una primera versión mediante una nueva conversación.

La primera versión me parece demasiado simple. Propón mejoras que tengan utilidad real y que sigan siendo accesibles para un principiante con Delphi 12.1 Community Edition. Mantén VCL, componentes estándar y funcionamiento sin Internet.

Entre las propuestas estaban los estilos de firma, los datos de contacto, la exportación, una vista previa automática y recordar los datos entre sesiones. Elegimos tres mejoras:

• Añadir correo, teléfono y web.
• Permitir elegir entre tres estilos.
• Guardar el resultado en un archivo TXT.

La vista previa automática y la conservación de datos quedaron para posibles ampliaciones. Esta decisión permite introducir conceptos nuevos sin convertir el primer proyecto en una aplicación demasiado extensa.

6. El segundo prompt: pedir una ampliación concreta

Amplía el proyecto existente con correo, teléfono y web opcionales.

Añade un TComboBox con tres estilos: Clásica, Compacta y Con separadores.

Los campos vacíos deben omitirse sin dejar líneas vacías ni separadores sueltos.

Añade un botón Guardar TXT y un TSaveDialog. Guarda la firma mostrada en UTF-8, pide confirmación antes de sobrescribir y muestra un mensaje si falla la escritura.

Mantén la generación mediante el botón Generar. Al limpiar, vacía todos los campos y restablece el estilo Clásica.

Actualiza el README y el ZIP con los fuentes.

La petición incluye comportamientos concretos, no solo nombres de funciones. “Guardar en TXT” deja muchas decisiones abiertas. Especificar UTF-8, cancelación, sobrescritura y mensajes de error facilita revisar el resultado. Indicar qué ocurre cuando faltan datos evita firmas con barras o puntos sobrantes.

7. Abrir el proyecto generado en Delphi

1. Extrae todo el contenido del ZIP en una carpeta de trabajo.
2. Abre Delphi 12.1 Community Edition.
3. Abre GeneradorFirmas.dproj.
4. Selecciona el destino Windows de 32 bits.
5. Abre Principal.pas.
6. Pulsa F12 para alternar entre el código y el diseñador.

En la versión entregada, el proyecto utiliza la configuración Base. Antes de ejecutar, comprueba que aparecen las seis entradas, la lista de estilos, los cuatro botones y el área de resultado. Este paso conecta lo que hemos pedido a la IA con los componentes reales de Delphi.

8. Entender el formulario desde el diseñador

Componente	Nombre	Función
TEdit	edtNombre	Nombre obligatorio.
TEdit	edtCargo	Cargo profesional.
TEdit	edtEmpresa	Empresa.
TEdit	edtCorreo	Correo electrónico.
TEdit	edtTelefono	Teléfono.
TEdit	edtWeb	Página web.
TComboBox	cmbEstilo	Selección del estilo.
TMemo	memFirma	Firma generada.
TButton	btnGenerar	Generar el resultado.
TButton	btnCopiar	Copiar al portapapeles.
TButton	btnGuardar	Guardar en TXT.
TButton	btnLimpiar	Reiniciar el formulario.
TSaveDialog	dlgGuardar	Elegir el archivo de destino.

Las etiquetas TLabel identifican los campos. Selecciona cmbEstilo y revisa estas propiedades en Object Inspector:

Style = csDropDownList
ItemIndex = 0

La lista permite seleccionar uno de los estilos disponibles. El índice 0 corresponde al primero: Clásica. En Items aparecen, en este orden:

Clásica
Compacta
Con separadores

Ese orden importa porque el código utiliza ItemIndex para decidir cómo construir la firma. En memFirma, las propiedades principales son:

ReadOnly = True
ScrollBars = ssBoth
WordWrap = False

El resultado se puede seleccionar, pero no modificar manualmente. Las líneas largas pueden consultarse con la barra de desplazamiento horizontal. Para entender estas decisiones podemos preguntar:

Explícame las propiedades del TComboBox y del TMemo de este proyecto. Relaciona cada propiedad con lo que observa el usuario y dime dónde se modifica en Object Inspector.

9. Revisar los eventos OnClick

Selecciona cada botón en el diseñador y abre la pestaña Events de Object Inspector. Los enlaces deben ser:

Botón	OnClick
btnGenerar	btnGenerarClick
btnCopiar	btnCopiarClick
btnGuardar	btnGuardarClick
btnLimpiar	btnLimpiarClick

En el proyecto descargado ya están asignados. Si reproduces el formulario desde cero, asigna primero los nombres de los controles y crea los manejadores desde Events. Delphi preparará la declaración y el cuerpo del método. Evita duplicar un método pegando una segunda implementación con el mismo nombre.

10. Qué hace el código al generar la firma

El evento de generación empieza leyendo los datos:

Nombre := Trim(edtNombre.Text);
Cargo := Trim(edtCargo.Text);
Empresa := Trim(edtEmpresa.Text);
Correo := Trim(edtCorreo.Text);
Telefono := Trim(edtTelefono.Text);
Web := Trim(edtWeb.Text);

Trim elimina los espacios al principio y al final de cada entrada. Esto permite tratar un nombre formado únicamente por espacios como una entrada vacía. A continuación se comprueba el campo obligatorio:

if Nombre = '' then
begin
  memFirma.Clear;
  MessageDlg('Escribe tu nombre para generar la firma.',
    mtWarning, [mbOK], 0);
  edtNombre.SetFocus;
  Exit;
end;

Este bloque elimina una posible firma anterior, muestra un mensaje, devuelve el cursor al nombre y sale del procedimiento. Vaciar el resultado evita que, después de un intento de generación incorrecto, el usuario copie por accidente una firma anterior.

Cargo, empresa y datos de contacto son opcionales. En esta versión, correo, teléfono y web se tratan como texto libre; no se verifica su formato ni su existencia.

Explícame por qué se utiliza Exit después de validar el nombre y qué ocurriría si eliminara esa línea.

11. Cómo evitamos los separadores sobrantes

Para construir las firmas compactas utilizamos una función auxiliar:

function UnirDatos(const Valores: array of string;
  const Separador: string): string;
var
  Valor: string;
begin
  Result := '';
  for Valor in Valores do
    if Valor <> '' then
    begin
      if Result <> '' then
        Result := Result + Separador;
      Result := Result + Valor;
    end;
end;

La función recibe una lista de textos y el separador que queremos utilizar. Recorre los valores y añade únicamente los que contienen texto. Antes de añadir un separador, comprueba si ya existe contenido en el resultado.

UnirDatos([Nombre, Cargo, Empresa], ' | ')

Con todos los campos rellenos produce:

Ana García | Desarrolladora Delphi | Estudio Norte

Si dejamos el cargo vacío, produce:

Ana García | Estudio Norte

Este detalle conviene incluirlo en la petición a la IA. La aplicación puede compilar y, aun así, producir un resultado poco cuidado cuando faltan datos.

12. Los tres estilos de firma

El programa utiliza cmbEstilo.ItemIndex para elegir el formato.

Clásica

Cada dato presente ocupa una línea:

Ana García
Desarrolladora Delphi
Estudio Norte
ana@ejemplo.com
+34 600 123 456
www.ejemplo.com

El código añade los valores opcionales solo cuando contienen texto:

memFirma.Lines.Add(Nombre);
if Cargo <> '' then memFirma.Lines.Add(Cargo);
if Empresa <> '' then memFirma.Lines.Add(Empresa);

El mismo criterio se aplica al correo, teléfono y web.

Compacta

Agrupa los datos profesionales y los de contacto:

Ana García | Desarrolladora Delphi | Estudio Norte
ana@ejemplo.com | +34 600 123 456 | www.ejemplo.com

La función UnirDatos evita que aparezcan separadores correspondientes a campos vacíos.

Con separadores

Presenta el nombre en mayúsculas y separa el bloque profesional del contacto:

ANA GARCÍA
Desarrolladora Delphi · Estudio Norte
────────────────────────────
ana@ejemplo.com · +34 600 123 456
www.ejemplo.com

La línea divisoria aparece únicamente cuando existe algún dato de contacto. Si solo introducimos el nombre, el resultado contiene únicamente el nombre.

Cuando cambies los datos o el estilo, vuelve a pulsar Generar. La versión actual actualiza el resultado mediante ese botón.

13. Copiar la firma al portapapeles

La instrucción principal es:

Clipboard.AsText := TrimRight(memFirma.Text);

Clipboard permite acceder al portapapeles mediante la unidad Vcl.Clipbrd. TrimRight elimina los caracteres de espacio en blanco del final del resultado, incluido el salto de línea final que puede contener el memo.

Antes de copiar, el programa comprueba si hay una firma. Si no existe, muestra un aviso. La operación está protegida con try/except: si falla el acceso al portapapeles, informa del problema y permite reintentarlo.

Al copiar, comprueba primero si existe un resultado. Si el acceso al portapapeles falla, muestra un mensaje comprensible y no confirmes que la copia se ha realizado.

14. Guardar la firma como archivo TXT

El componente TSaveDialog permite elegir dónde guardar el archivo. En Object Inspector, el proyecto utiliza estas propiedades:

DefaultExt = txt
FileName = MiFirma.txt
Filter = Archivo de texto (*.txt)|*.txt

Entre sus opciones se encuentra ofOverwritePrompt, que solicita confirmación si el archivo de destino ya existe. El código comprueba primero si el usuario acepta el diálogo:

if not dlgGuardar.Execute then
  Exit;

Si cancela, el procedimiento termina. Cuando acepta, se guarda el resultado:

TFile.WriteAllText(
  dlgGuardar.FileName,
  TrimRight(memFirma.Text),
  TEncoding.UTF8
);

Esta operación utiliza System.IOUtils y guarda el texto con codificación UTF-8 para conservar las tildes, la eñe y los separadores de la firma. Un bloque try/except trata los errores de escritura. Si se produce un fallo, la firma permanece visible para intentar guardarla en otra ubicación.

15. Limpiar el formulario

El botón Limpiar prepara una nueva firma:

edtNombre.Clear;
edtCargo.Clear;
edtEmpresa.Clear;
edtCorreo.Clear;
edtTelefono.Clear;
edtWeb.Clear;
cmbEstilo.ItemIndex := 0;
memFirma.Clear;
edtNombre.SetFocus;

Además de vaciar los campos, restablece el estilo Clásica y sitúa el cursor en el nombre. No elimina archivos exportados ni borra lo que ya hayamos copiado al portapapeles de Windows.

16. Compilar y comprobar el resultado

Compila con la opción Build del proyecto y ejecuta con F9. En este proyecto, el autor confirmó la compilación y las pruebas satisfactorias. Si estás siguiendo el tutorial, realiza también tus propias comprobaciones.

Prueba	Resultado esperado
Generar con todos los datos.	Firma completa con el estilo elegido.
Generar solo con el nombre.	Sin datos opcionales ni separadores sobrantes.
Dejar el nombre vacío.	Mensaje de validación y foco en el nombre.
Introducir únicamente espacios en el nombre.	Mismo aviso que con el nombre vacío.
Cambiar entre los tres estilos y generar.	Formato correspondiente a cada selección.
Copiar y pegar en Bloc de notas.	Texto igual al resultado generado.
Guardar en TXT y abrirlo.	Texto correcto, incluidas tildes y eñes.
Cancelar el diálogo de guardado.	No se guarda ningún archivo nuevo.
Guardar sobre un archivo existente.	Petición de confirmación.
Pulsar Limpiar.	Campos vacíos y estilo Clásica.
Cerrar y volver a abrir.	Formulario vacío.
Utilizar la aplicación sin Internet.	Funciones disponibles.

No te limites a comprobar el caso en el que todos los campos están completos. Los campos vacíos, las cancelaciones y los cambios de estilo también forman parte del comportamiento de la aplicación.

17. Cómo pedir ayuda a la IA si aparece un error

Si algo falla, proporciona información concreta. En lugar de escribir solamente “no funciona”, utiliza un mensaje como este:

Estoy utilizando Delphi 12.1 Community Edition con el destino Windows de 32 bits.

Al compilar aparece este mensaje:

[Pega aquí el error completo.]

La línea señalada está en este método:

[Pega el método o el fragmento relacionado.]

Explica la causa y propón el cambio mínimo necesario. Mantén los nombres de los controles y la compatibilidad con el proyecto.

Si el programa compila, pero el resultado no es el esperado, describe cómo reproducirlo:

Selecciono el estilo Compacta, relleno nombre y empresa y dejo cargo vacío.

Espero que aparezca un único separador entre nombre y empresa.

Este es el resultado que obtengo:

[Pega el resultado.]

Revisa la construcción de la firma y explica la corrección.

Cuanto más concreta sea la información, más fácil será comprobar si la solución propuesta resuelve el problema.

18. Qué hemos aprendido sobre programar con IA

El proyecto comenzó con una petición pequeña y creció mediante una segunda iteración. Hemos utilizado la IA para convertir una idea en requisitos, preparar un proyecto VCL, implementar eventos y validaciones, proponer mejoras, añadir formatos y exportación, explicar el código y preparar una guía de pruebas.

Por nuestra parte, hemos decidido el alcance, revisado la interfaz y comprobado el resultado en Delphi. Ese es el enfoque de Aprende Delphi con IA: desarrollar aplicaciones reales y entender las decisiones que las hacen funcionar.

19. Descarga el proyecto completo

Descargar DH-IA-01 — Generador de firmas profesionales (ZIP)

Incluye el código fuente en Object Pascal, el formulario VCL, los archivos del proyecto y las instrucciones de uso. Extrae el ZIP y abre GeneradorFirmas.dproj en Delphi 12.1 Community Edition.

El proyecto ha sido compilado y probado por el autor. La descarga contiene los fuentes y la documentación, sin ejecutables. El archivo está alojado en InformatOLI.

20. Tu siguiente mejora con IA

Para continuar practicando, puedes pedir una nueva función:

Añade una casilla para recordar los datos entre sesiones. Explica dónde se guardan, cómo se recuperan y qué debe ocurrir cuando el usuario desactiva la opción. Mantén la compatibilidad con Delphi 12.1 Community Edition.

Otra posibilidad es actualizar la firma automáticamente al modificar los campos. Elige una ampliación, define su comportamiento, pide una explicación del código y vuelve a probar el proyecto. Así cada nueva función se convierte también en una oportunidad para aprender Delphi.